?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed untyped contructor from ComponentRegistration and add a protected setter.
[castle.git] / ActiveRecord / Castle.ActiveRecord / Framework / Internal / ActiveRecordModelBuilder.cs
blob60630ef58d5e95976e968874926120d0cbf26d3a
1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 namespace Castle.ActiveRecord.Framework.Internal
16 {
17 using System;
18 using System.Collections.Generic;
19 using System.Reflection;
20 using Castle.Components.Validator;
21
22 /// <summary>
23 /// Bulids an <see cref="ActiveRecordModel"/> from a type and does some inital validation.
24 /// </summary>
25 public class ActiveRecordModelBuilder
26 {
27 private static readonly BindingFlags DefaultBindingFlags = BindingFlags.DeclaredOnly | BindingFlags.Public |
28 BindingFlags.Instance | BindingFlags.NonPublic;
29
30 private static readonly BindingFlags FieldDefaultBindingFlags = BindingFlags.DeclaredOnly | BindingFlags.Public |
31 BindingFlags.NonPublic | BindingFlags.Instance;
32
33 private readonly ActiveRecordModelCollection coll = new ActiveRecordModelCollection();
34
35 private static readonly IValidatorRegistry validatorRegistry = new CachedValidationRegistry();
36
37 /// <summary>
38 /// Creates a <see cref="ActiveRecordModel"/> from the specified type.
39 /// </summary>
40 /// <param name="type">The type.</param>
41 /// <returns></returns>
42 public ActiveRecordModel Create(Type type)
43 {
44 if (type == null) throw new ArgumentNullException("type");
45
46 if (type.IsDefined(typeof(ActiveRecordSkipAttribute), false)) return null;
47
48 ActiveRecordModel model = new ActiveRecordModel(type);
49
50 coll.Add(model);
51
52 PopulateModel(model, type);
53
54 ActiveRecordBase.Register(type, model);
55
56 return model;
57 }
58
59 /// <summary>
60 /// Gets the models.
61 /// </summary>
62 /// <value>The models.</value>
63 public ActiveRecordModelCollection Models
64 {
65 get { return coll; }
66 }
67
68 /// <summary>
69 /// Gets the validator registry used to create the validators
70 /// </summary>
71 public static IValidatorRegistry ValidatorRegistry
72 {
73 get { return validatorRegistry; }
74 }
75
76 /// <summary>
77 /// Populates the model from tye type
78 /// </summary>
79 /// <param name="model">The model.</param>
80 /// <param name="type">The type.</param>
81 private static void PopulateModel(ActiveRecordModel model, Type type)
82 {
83 ProcessActiveRecordAttribute(type, model);
84
85 ProcessImports(type, model);
86
87 ProcessJoinedBaseAttribute(type, model);
88
89 ProcessProperties(type, model);
90
91 ProcessFields(type, model);
92 }
93
94 private static void ProcessImports(Type type, ActiveRecordModel model)
95 {
96 object[] attrs = type.GetCustomAttributes(typeof(ImportAttribute), false);
97
98 foreach (ImportAttribute att in attrs)
99 {
100 ImportModel im = new ImportModel(att);
101 model.Imports.Add(im);
102 }
103 }
104
105 private static void ProcessJoinedBaseAttribute(Type type, ActiveRecordModel model)
106 {
107 model.IsJoinedSubClassBase = type.IsDefined(typeof(JoinedBaseAttribute), false);
108 }
109
110 private static void PopulateActiveRecordAttribute(ActiveRecordAttribute attribute, ActiveRecordModel model)
111 {
112 model.ActiveRecordAtt = attribute;
113
114 if (attribute.DiscriminatorColumn != null)
115 {
116 model.IsDiscriminatorBase = true;
117
118 if (attribute.DiscriminatorValue == null)
119 {
120 throw new ActiveRecordException(
121 String.Format("You must specify a discriminator value for the type {0}", model.Type.FullName));
122 }
123 }
124 else if (attribute.DiscriminatorType != null)
125 {
126 throw new ActiveRecordException(
127 String.Format("The usage of DiscriminatorType for {0} is meaningless", model.Type.FullName));
128 }
129
130 if (model.ActiveRecordAtt.Table == null)
131 {
132 string safename = GetSafeName(model.Type.Name);
133 model.ActiveRecordAtt.Table = ActiveRecordModel.pluralizeTableNames
134 ? Inflector.Pluralize(safename)
135 : safename;
136 }
137 }
138
139 /// <summary>
140 /// Remove the generic part from the type name.
141 /// </summary>
142 /// <param name="name"></param>
143 /// <returns></returns>
144 private static string GetSafeName(string name)
145 {
146 int index = name.IndexOf("`");
147
148 if (index == -1) return name;
149
150 return name.Substring(0, index);
151 }
152
153 private static void ProcessFields(Type type, ActiveRecordModel model)
154 {
155 //Check persistent fields of the base class as well
156 if (ShouldCheckBase(type))
157 {
158 ProcessFields(type.BaseType, model);
159 }
160
161 FieldInfo[] fields = type.GetFields(FieldDefaultBindingFlags);
162
163 foreach (FieldInfo field in fields)
164 {
165 if (field.IsDefined(typeof(FieldAttribute), false))
166 {
167 FieldAttribute fieldAtt = field.GetCustomAttributes(typeof(FieldAttribute), false)[0] as FieldAttribute;
168
169 model.Fields.Add(new FieldModel(field, fieldAtt));
170 }
171 }
172 }
173
174 private static void ProcessProperties(Type type, ActiveRecordModel model)
175 {
176 // Check persistent properties of the base class as well
177 if (ShouldCheckBase(type))
178 {
179 ProcessProperties(type.BaseType, model);
180 }
181
182 PropertyInfo[] props = type.GetProperties(DefaultBindingFlags);
183
184 foreach (PropertyInfo prop in props)
185 {
186 bool isArProperty = false;
187 AnyModel anyModel;
188 HasManyToAnyModel hasManyToAnyModel;
189
190 object[] valAtts = prop.GetCustomAttributes(typeof(AbstractValidationAttribute), true);
191
192 foreach (AbstractValidationAttribute valAtt in valAtts)
193 {
194 IValidator validator = valAtt.Build();
195 validator.Initialize(validatorRegistry, prop);
196
197 model.Validators.Add(validator);
198 }
199
200 foreach (object attribute in prop.GetCustomAttributes(false))
201 {
202 if (attribute is PrimaryKeyAttribute)
203 {
204 PrimaryKeyAttribute propAtt = attribute as PrimaryKeyAttribute;
205 isArProperty = true;
206
207 // Joined Subclasses must not have PrimaryKey
208 if (type.IsDefined(typeof(JoinedBaseAttribute), true) && // JoinedBase in a superclass
209 !type.IsDefined(typeof(JoinedBaseAttribute), false)) // but not here
210 {
211 throw new ActiveRecordException("You can't specify a PrimaryKeyAttribute in a joined subclass. " +
212 "Check type " + model.Type.FullName);
213 }
214
215 if (prop.PropertyType.IsDefined(typeof(CompositeKeyAttribute), true))
216 {
217 object[] att = prop.PropertyType.GetCustomAttributes(typeof(CompositeKeyAttribute), true);
218
219 CompositeKeyAttribute cAtt = att[0] as CompositeKeyAttribute;
220
221 model.CompositeKey = new CompositeKeyModel(prop, cAtt);
222 }
223 else
224 {
225 if (!propAtt.IsOverride && model.PrimaryKey != null)
226 {
227 throw new ActiveRecordException("You can't specify more than one PrimaryKeyAttribute in a " +
228 "class. Check type " + model.Type.FullName);
229 }
230
231 model.PrimaryKey = new PrimaryKeyModel(prop, propAtt);
232 }
233 }
234 else if (attribute is CompositeKeyAttribute)
235 {
236 CompositeKeyAttribute propAtt = attribute as CompositeKeyAttribute;
237 isArProperty = true;
238
239 model.CompositeKey = new CompositeKeyModel(prop, propAtt);
240 }
241 else if (attribute is AnyAttribute)
242 {
243 AnyAttribute anyAtt = attribute as AnyAttribute;
244 isArProperty = true;
245 anyModel = new AnyModel(prop, anyAtt);
246 model.Anys.Add(anyModel);
247
248 CollectMetaValues(anyModel.MetaValues, prop);
249 }
250 else if (attribute is PropertyAttribute)
251 {
252 PropertyAttribute propAtt = attribute as PropertyAttribute;
253 isArProperty = true;
254
255 // If this property overrides a base class property remove the old one
256 if (propAtt.IsOverride)
257 {
258 for (int index = 0; index < model.Properties.Count; ++index)
259 {
260 PropertyModel oldModel = (PropertyModel)model.Properties[index];
261
262 if (oldModel.Property.Name == prop.Name)
263 {
264 model.Properties.RemoveAt(index);
265 break;
266 }
267 }
268 }
269
270 model.Properties.Add(new PropertyModel(prop, propAtt));
271 }
272 else if (attribute is NestedAttribute)
273 {
274 NestedAttribute propAtt = attribute as NestedAttribute;
275 isArProperty = true;
276
277 ActiveRecordModel nestedModel = new ActiveRecordModel(prop.PropertyType);
278
279 nestedModel.IsNestedType = true;
280
281 Type nestedType = propAtt.MapType ?? prop.PropertyType;
282 nestedModel.IsNestedCompositeType = model.IsNestedCompositeType;
283 ProcessProperties(nestedType, nestedModel);
284 ProcessFields(nestedType, nestedModel);
285
286 NestedModel nested = new NestedModel(prop, propAtt, nestedModel);
287 nestedModel.ParentNested = nested;
288
289 model.Components.Add(nested);
290 }
291 else if (attribute is NestedParentReferenceAttribute)
292 {
293 NestedParentReferenceAttribute nestedParentAtt = attribute as NestedParentReferenceAttribute;
294 isArProperty = true;
295
296 model.ComponentParent.Add(new NestedParentReferenceModel(prop, nestedParentAtt));
297 }
298 else if (attribute is JoinedKeyAttribute)
299 {
300 JoinedKeyAttribute propAtt = attribute as JoinedKeyAttribute;
301 isArProperty = true;
302
303 if (model.Key != null)
304 {
305 throw new ActiveRecordException("You can't specify more than one JoinedKeyAttribute. " +
306 "Check type " + model.Type.FullName);
307 }
308
309 model.Key = new KeyModel(prop, propAtt);
310 }
311 else if (attribute is VersionAttribute)
312 {
313 VersionAttribute propAtt = attribute as VersionAttribute;
314 isArProperty = true;
315
316 if (model.Version != null)
317 {
318 throw new ActiveRecordException("You can't specify more than one VersionAttribute. " +
319 "Check type " + model.Type.FullName);
320 }
321
322 model.Version = new VersionModel(prop, propAtt);
323 }
324 else if (attribute is TimestampAttribute)
325 {
326 TimestampAttribute propAtt = attribute as TimestampAttribute;
327 isArProperty = true;
328
329 if (model.Timestamp != null)
330 {
331 throw new ActiveRecordException("You can't specify more than one TimestampAttribute. " +
332 "Check type " + model.Type.FullName);
333 }
334
335 model.Timestamp = new TimestampModel(prop, propAtt);
336 }
337 // Relations
338 else if (attribute is OneToOneAttribute)
339 {
340 OneToOneAttribute propAtt = attribute as OneToOneAttribute;
341 isArProperty = true;
342
343 model.OneToOnes.Add(new OneToOneModel(prop, propAtt));
344 }
345 else if (attribute is BelongsToAttribute)
346 {
347 BelongsToAttribute propAtt = attribute as BelongsToAttribute;
348 isArProperty = true;
349
350 model.BelongsTo.Add(new BelongsToModel(prop, propAtt));
351 }
352 // The ordering is important here, HasManyToAny must comes before HasMany!
353 else if (attribute is HasManyToAnyAttribute)
354 {
355 HasManyToAnyAttribute propAtt = attribute as HasManyToAnyAttribute;
356 isArProperty = true;
357
358 hasManyToAnyModel = new HasManyToAnyModel(prop, propAtt);
359 model.HasManyToAny.Add(hasManyToAnyModel);
360
361 CollectMetaValues(hasManyToAnyModel.MetaValues, prop);
362 }
363 else if (attribute is HasManyAttribute)
364 {
365 HasManyAttribute propAtt = attribute as HasManyAttribute;
366 isArProperty = true;
367
368 HasManyModel hasManyModel = new HasManyModel(prop, propAtt);
369 if (propAtt.DependentObjects)
370 {
371 ActiveRecordModel dependentObjectModel = new ActiveRecordModel(propAtt.MapType);
372 dependentObjectModel.IsNestedType = true;
373 dependentObjectModel.IsNestedCompositeType = true;
374 ProcessProperties(propAtt.MapType, dependentObjectModel);
375
376 hasManyModel.DependentObjectModel = new DependentObjectModel(prop, propAtt, dependentObjectModel);
377 }
378 model.HasMany.Add(hasManyModel);
379 }
380 else if (attribute is HasAndBelongsToManyAttribute)
381 {
382 HasAndBelongsToManyAttribute propAtt = attribute as HasAndBelongsToManyAttribute;
383 isArProperty = true;
384
385 model.HasAndBelongsToMany.Add(new HasAndBelongsToManyModel(prop, propAtt));
386 }
387 else if (attribute is Any.MetaValueAttribute)
388 {
389 if (prop.GetCustomAttributes(typeof(HasManyToAnyAttribute), false).Length == 0 &&
390 prop.GetCustomAttributes(typeof(AnyAttribute), false).Length == 0
391 )
392 throw new ActiveRecordException(
393 "You can't specify an Any.MetaValue without specifying the Any or HasManyToAny attribute. " +
394 "Check type " + prop.DeclaringType.FullName);
395 }
396 else if (attribute is CompositeUserTypeAttribute)
397 {
398 CompositeUserTypeAttribute propAtt = attribute as CompositeUserTypeAttribute;
399 isArProperty = true;
400
401 model.CompositeUserType.Add(new CompositeUserTypeModel(prop, propAtt));
402 }
403
404 if (attribute is CollectionIDAttribute)
405 {
406 CollectionIDAttribute propAtt = attribute as CollectionIDAttribute;
407
408 model.CollectionIDs.Add(new CollectionIDModel(prop, propAtt));
409 }
410 if (attribute is HiloAttribute)
411 {
412 HiloAttribute propAtt = attribute as HiloAttribute;
413
414 model.Hilos.Add(new HiloModel(prop, propAtt));
415 }
416 }
417
418 if (!isArProperty)
419 {
420 model.NotMappedProperties.Add(prop);
421 }
422 }
423 }
424
425 private static void CollectMetaValues(IList<Any.MetaValueAttribute> metaStore, PropertyInfo prop)
426 {
427 if (metaStore == null)
428 throw new ArgumentNullException("metaStore");
429
430 Any.MetaValueAttribute[] metaValues =
431 prop.GetCustomAttributes(typeof(Any.MetaValueAttribute), false) as Any.MetaValueAttribute[];
432
433 if (metaValues == null || metaValues.Length == 0)
434 return;
435
436 foreach (Any.MetaValueAttribute attribute in metaValues)
437 {
438 metaStore.Add(attribute);
439 }
440 }
441
442 private static bool ShouldCheckBase(Type type)
443 {
444 // Changed as suggested http://support.castleproject.org/jira/browse/AR-40
445 bool shouldCheck = IsRootType(type);
446
447 if (shouldCheck) // Perform more checks
448 {
449 Type basetype = type.BaseType;
450
451 while (basetype != typeof(object))
452 {
453 if (basetype.IsDefined(typeof(JoinedBaseAttribute), false)) return false;
454
455 object[] attrs = basetype.GetCustomAttributes(typeof(ActiveRecordAttribute), false);
456
457 if (attrs.Length != 0)
458 {
459 ActiveRecordAttribute arAttribute = attrs[0] as ActiveRecordAttribute;
460 if (arAttribute.DiscriminatorColumn != null)
461 return false;
462 }
463 else
464 {
465 return true;
466 }
467
468 basetype = basetype.BaseType;
469 }
470 }
471
472 return shouldCheck;
473 }
474
475 private static bool IsRootType(Type type)
476 {
477 bool isRootType = type.BaseType != typeof(object) &&
478 type.BaseType != typeof(ActiveRecordBase) &&
479 type.BaseType != typeof(ActiveRecordValidationBase);
480 // && !type.BaseType.IsDefined(typeof(ActiveRecordAttribute), false);
481
482 // generic check
483 if (type.BaseType.IsGenericType)
484 {
485 isRootType = type.BaseType.GetGenericTypeDefinition() != typeof(ActiveRecordBase<>) &&
486 type.BaseType.GetGenericTypeDefinition() != typeof(ActiveRecordValidationBase<>);
487 }
488
489 return isRootType;
490 }
491
492 private static void ProcessActiveRecordAttribute(Type type, ActiveRecordModel model)
493 {
494 object[] attrs = type.GetCustomAttributes(typeof(ActiveRecordAttribute), false);
495
496 if (attrs.Length == 0)
497 {
498 throw new ActiveRecordException(
499 String.Format("Type {0} is not using the ActiveRecordAttribute, which is obligatory.", type.FullName));
500 }
501
502 ActiveRecordAttribute arAttribute = attrs[0] as ActiveRecordAttribute;
503
504 PopulateActiveRecordAttribute(arAttribute, model);
505 }
506 }
507 }
Git import of castle svn