?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Fixed MR-84
[castle.git] / ActiveRecord / Castle.ActiveRecord / Framework / Internal / ActiveRecordModelBuilder.cs
blob0a1e49ac72cb40332299953987a201ee8e3a4f08
1 // Copyright 2004-2007 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;
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 model.PrimaryKey = new PrimaryKeyModel(prop, propAtt);
226 }
227 }
228 else if (attribute is CompositeKeyAttribute)
229 {
230 CompositeKeyAttribute propAtt = attribute as CompositeKeyAttribute;
231 isArProperty = true;
232
233 model.CompositeKey = new CompositeKeyModel(prop, propAtt);
234 }
235 else if (attribute is AnyAttribute)
236 {
237 AnyAttribute anyAtt = attribute as AnyAttribute;
238 isArProperty = true;
239 anyModel = new AnyModel(prop, anyAtt);
240 model.Anys.Add(anyModel);
241
242 CollectMetaValues(anyModel.MetaValues, prop);
243 }
244 else if (attribute is PropertyAttribute)
245 {
246 PropertyAttribute propAtt = attribute as PropertyAttribute;
247 isArProperty = true;
248
249 model.Properties.Add(new PropertyModel(prop, propAtt));
250 }
251 else if (attribute is NestedAttribute)
252 {
253 NestedAttribute propAtt = attribute as NestedAttribute;
254 isArProperty = true;
255
256 ActiveRecordModel nestedModel = new ActiveRecordModel(prop.PropertyType);
257
258 nestedModel.IsNestedType = true;
259
260 Type nestedType = propAtt.MapType ?? prop.PropertyType;
261 nestedModel.IsNestedCompositeType = model.IsNestedCompositeType;
262 ProcessProperties(nestedType, nestedModel);
263 ProcessFields(nestedType, nestedModel);
264
265 NestedModel nested = new NestedModel(prop, propAtt, nestedModel);
266 nestedModel.ParentNested = nested;
267
268 model.Components.Add(nested);
269 }
270 else if (attribute is NestedParentReferenceAttribute)
271 {
272 NestedParentReferenceAttribute nestedParentAtt = attribute as NestedParentReferenceAttribute;
273 isArProperty = true;
274
275 model.ComponentParent.Add(new NestedParentReferenceModel(prop, nestedParentAtt));
276 }
277 else if (attribute is JoinedKeyAttribute)
278 {
279 JoinedKeyAttribute propAtt = attribute as JoinedKeyAttribute;
280 isArProperty = true;
281
282 if (model.Key != null)
283 {
284 throw new ActiveRecordException("You can't specify more than one JoinedKeyAttribute. " +
285 "Check type " + model.Type.FullName);
286 }
287
288 model.Key = new KeyModel(prop, propAtt);
289 }
290 else if (attribute is VersionAttribute)
291 {
292 VersionAttribute propAtt = attribute as VersionAttribute;
293 isArProperty = true;
294
295 if (model.Version != null)
296 {
297 throw new ActiveRecordException("You can't specify more than one VersionAttribute. " +
298 "Check type " + model.Type.FullName);
299 }
300
301 model.Version = new VersionModel(prop, propAtt);
302 }
303 else if (attribute is TimestampAttribute)
304 {
305 TimestampAttribute propAtt = attribute as TimestampAttribute;
306 isArProperty = true;
307
308 if (model.Timestamp != null)
309 {
310 throw new ActiveRecordException("You can't specify more than one TimestampAttribute. " +
311 "Check type " + model.Type.FullName);
312 }
313
314 model.Timestamp = new TimestampModel(prop, propAtt);
315 }
316 // Relations
317 else if (attribute is OneToOneAttribute)
318 {
319 OneToOneAttribute propAtt = attribute as OneToOneAttribute;
320 isArProperty = true;
321
322 model.OneToOnes.Add(new OneToOneModel(prop, propAtt));
323 }
324 else if (attribute is BelongsToAttribute)
325 {
326 BelongsToAttribute propAtt = attribute as BelongsToAttribute;
327 isArProperty = true;
328
329 model.BelongsTo.Add(new BelongsToModel(prop, propAtt));
330 }
331 // The ordering is important here, HasManyToAny must comes before HasMany!
332 else if (attribute is HasManyToAnyAttribute)
333 {
334 HasManyToAnyAttribute propAtt = attribute as HasManyToAnyAttribute;
335 isArProperty = true;
336
337 hasManyToAnyModel = new HasManyToAnyModel(prop, propAtt);
338 model.HasManyToAny.Add(hasManyToAnyModel);
339
340 CollectMetaValues(hasManyToAnyModel.MetaValues, prop);
341 }
342 else if (attribute is HasManyAttribute)
343 {
344 HasManyAttribute propAtt = attribute as HasManyAttribute;
345 isArProperty = true;
346
347 HasManyModel hasManyModel = new HasManyModel(prop, propAtt);
348 if (propAtt.DependentObjects)
349 {
350 ActiveRecordModel dependentObjectModel = new ActiveRecordModel(propAtt.MapType);
351 dependentObjectModel.IsNestedType = true;
352 dependentObjectModel.IsNestedCompositeType = true;
353 ProcessProperties(propAtt.MapType, dependentObjectModel);
354
355 hasManyModel.DependentObjectModel = new DependentObjectModel(prop, propAtt, dependentObjectModel);
356 }
357 model.HasMany.Add(hasManyModel);
358 }
359 else if (attribute is HasAndBelongsToManyAttribute)
360 {
361 HasAndBelongsToManyAttribute propAtt = attribute as HasAndBelongsToManyAttribute;
362 isArProperty = true;
363
364 model.HasAndBelongsToMany.Add(new HasAndBelongsToManyModel(prop, propAtt));
365 }
366 else if (attribute is Any.MetaValueAttribute)
367 {
368 if (prop.GetCustomAttributes(typeof(HasManyToAnyAttribute), false).Length == 0 &&
369 prop.GetCustomAttributes(typeof(AnyAttribute), false).Length == 0
370 )
371 throw new ActiveRecordException(
372 "You can't specify an Any.MetaValue without specifying the Any or HasManyToAny attribute. " +
373 "Check type " + prop.DeclaringType.FullName);
374 }
375 else if (attribute is CompositeUserTypeAttribute)
376 {
377 CompositeUserTypeAttribute propAtt = attribute as CompositeUserTypeAttribute;
378 isArProperty = true;
379
380 model.CompositeUserType.Add(new CompositeUserTypeModel(prop, propAtt));
381 }
382
383 if (attribute is CollectionIDAttribute)
384 {
385 CollectionIDAttribute propAtt = attribute as CollectionIDAttribute;
386
387 model.CollectionIDs.Add(new CollectionIDModel(prop, propAtt));
388 }
389 if (attribute is HiloAttribute)
390 {
391 HiloAttribute propAtt = attribute as HiloAttribute;
392
393 model.Hilos.Add(new HiloModel(prop, propAtt));
394 }
395 }
396
397 if (!isArProperty)
398 {
399 model.NotMappedProperties.Add(prop);
400 }
401 }
402 }
403
404 private static void CollectMetaValues(IList metaStore, PropertyInfo prop)
405 {
406 if (metaStore == null)
407 throw new ArgumentNullException("metaStore");
408
409 Any.MetaValueAttribute[] metaValues =
410 prop.GetCustomAttributes(typeof(Any.MetaValueAttribute), false) as Any.MetaValueAttribute[];
411
412 if (metaValues == null || metaValues.Length == 0)
413 return;
414
415 foreach (Any.MetaValueAttribute attribute in metaValues)
416 {
417 metaStore.Add(attribute);
418 }
419 }
420
421 private static bool ShouldCheckBase(Type type)
422 {
423 // Changed as suggested http://support.castleproject.org/jira/browse/AR-40
424 bool shouldCheck = IsRootType(type);
425
426 if (shouldCheck) // Perform more checks
427 {
428 Type basetype = type.BaseType;
429
430 while (basetype != typeof(object))
431 {
432 if (basetype.IsDefined(typeof(JoinedBaseAttribute), false)) return false;
433
434 object[] attrs = basetype.GetCustomAttributes(typeof(ActiveRecordAttribute), false);
435
436 if (attrs.Length != 0)
437 {
438 ActiveRecordAttribute arAttribute = attrs[0] as ActiveRecordAttribute;
439 if (arAttribute.DiscriminatorColumn != null)
440 return false;
441 }
442 else
443 {
444 return true;
445 }
446
447 basetype = basetype.BaseType;
448 }
449 }
450
451 return shouldCheck;
452 }
453
454 private static bool IsRootType(Type type)
455 {
456 bool isRootType = type.BaseType != typeof(object) &&
457 type.BaseType != typeof(ActiveRecordBase) &&
458 type.BaseType != typeof(ActiveRecordValidationBase);
459 // && !type.BaseType.IsDefined(typeof(ActiveRecordAttribute), false);
460
461 // generic check
462 if (type.BaseType.IsGenericType)
463 {
464 isRootType = type.BaseType.GetGenericTypeDefinition() != typeof(ActiveRecordBase<>) &&
465 type.BaseType.GetGenericTypeDefinition() != typeof(ActiveRecordValidationBase<>);
466 }
467
468 return isRootType;
469 }
470
471 private static void ProcessActiveRecordAttribute(Type type, ActiveRecordModel model)
472 {
473 object[] attrs = type.GetCustomAttributes(typeof(ActiveRecordAttribute), false);
474
475 if (attrs.Length == 0)
476 {
477 throw new ActiveRecordException(
478 String.Format("Type {0} is not using the ActiveRecordAttribute, which is obligatory.", type.FullName));
479 }
480
481 ActiveRecordAttribute arAttribute = attrs[0] as ActiveRecordAttribute;
482
483 PopulateActiveRecordAttribute(arAttribute, model);
484 }
485 }
486 }
Git import of castle svn