Fix for issue #104: FNH should mark ReferenceComponent as mapped when it is overridden in IAutoMappingOverride

Author: hazzik

src/FluentNHibernate.Testing/AutoMapping/Apm/AutoPersistenceModelTests.cs

@@ -10,7 +10,7 @@
 namespace FluentNHibernate.Testing.AutoMapping.Apm
 {
     [TestFixture]
-    public partial class AutoPersistenceModelTests : BaseAutoPersistenceTests
+    public partial class AutoPersistenceModelTests
     {
         [Test]
         public void CanSearchForOpenGenericTypes()

src/FluentNHibernate.Testing/AutoMapping/Overrides/ReferenceComponentOverrides.cs

@@ -0,0 +1,43 @@
+using System;
+using FluentNHibernate.Automapping;
+using NUnit.Framework;
+
+namespace FluentNHibernate.Testing.AutoMapping.Overrides
+{
+    public class ReferenceComponentOverrides
+    {
+        [Test]
+        public void should_be_able_to_build_mapping()
+        {
+            var source = new StubTypeSource(typeof(IncomingDocument), typeof(DocumentNumber));
+
+            var persistenceModel = AutoMap.Source(source, new AutomappingConfiguration())
+                .Override<IncomingDocument>(m => m.Component(x => x.IncomingNumber)
+                    .ColumnPrefix("INCOMING_"));
+
+            Assert.DoesNotThrow(() => persistenceModel.BuildMappings());
+        }
+
+        class AutomappingConfiguration : DefaultAutomappingConfiguration
+        {
+            public override bool IsComponent(Type type)
+            {
+                return type == typeof(DocumentNumber);
+            }
+
+            public override bool ShouldMap(Type type)
+            {
+                return type == typeof(IncomingDocument);
+            }
+        }
+
+        class DocumentNumber
+        {}
+
+        class IncomingDocument
+        {
+            public virtual int Id { get; set; }
+            public virtual DocumentNumber IncomingNumber { get; set; }
+        }
+    }
+}

src/FluentNHibernate.Testing/FluentNHibernate.Testing.csproj

@@ -101,6 +101,7 @@
     <Compile Include="AutoMapping\Apm\AlterationTests.cs" />
     <Compile Include="AutoMapping\Apm\ConcreteBaseClassTests.cs" />
     <Compile Include="AutoMapping\Apm\Conventions\VersionConventionTests.cs" />
+    <Compile Include="AutoMapping\Overrides\ReferenceComponentOverrides.cs" />
     <Compile Include="AutoMapping\Overrides\AutoMappingOverrideAlterationTests.cs" />
     <Compile Include="AutoMapping\Apm\CacheOverrideTests.cs" />
     <Compile Include="AutoMapping\Apm\Conventions\HasManyConventionTests.cs" />

src/FluentNHibernate/Automapping/AutoMapping.cs

@@ -40,10 +40,9 @@ void IAutoClasslike.AlterModel(ClassMappingBase mapping)
         {
             mapping.MergeAttributes(attributes.Clone());
 
-            if (mapping is ClassMapping)
+            var classMapping = mapping as ClassMapping;
+            if (classMapping != null)
             {
-                var classMapping = (ClassMapping)mapping;
-
                 if (providers.Id != null)
                     classMapping.Set(x => x.Id, Layer.Defaults, providers.Id.GetIdentityMapping());
 
@@ -129,8 +128,8 @@ IPropertyIgnorer IPropertyIgnorer.IgnoreProperties(Func<Member, bool> predicate)
             return this;
         }
 
-		public AutoJoinedSubClassPart<TSubclass> JoinedSubClass<TSubclass>(string keyColumn, Action<AutoJoinedSubClassPart<TSubclass>> action)
-			where TSubclass : T
+        public AutoJoinedSubClassPart<TSubclass> JoinedSubClass<TSubclass>(string keyColumn, Action<AutoJoinedSubClassPart<TSubclass>> action)
+            where TSubclass : T
         {
             var genericType = typeof(AutoJoinedSubClassPart<>).MakeGenericType(typeof(TSubclass));
             var joinedclass = (AutoJoinedSubClassPart<TSubclass>)Activator.CreateInstance(genericType, keyColumn);
@@ -140,7 +139,7 @@ public AutoJoinedSubClassPart<TSubclass> JoinedSubClass<TSubclass>(string keyCol
 
             providers.Subclasses[typeof(TSubclass)] = joinedclass;
 
-		    return joinedclass;
+            return joinedclass;
         }
 
         public IAutoClasslike JoinedSubClass(Type type, string keyColumn)
@@ -155,31 +154,31 @@ public IAutoClasslike JoinedSubClass(Type type, string keyColumn)
         }
 
         public AutoJoinedSubClassPart<TSubclass> JoinedSubClass<TSubclass>(string keyColumn)
-			where TSubclass : T
-		{
-			return JoinedSubClass<TSubclass>(keyColumn, null);
-		}
+            where TSubclass : T
+        {
+            return JoinedSubClass<TSubclass>(keyColumn, null);
+        }
 
-		public AutoSubClassPart<TSubclass> SubClass<TSubclass>(object discriminatorValue, Action<AutoSubClassPart<TSubclass>> action)
-			where TSubclass : T
+        public AutoSubClassPart<TSubclass> SubClass<TSubclass>(object discriminatorValue, Action<AutoSubClassPart<TSubclass>> action)
+            where TSubclass : T
         {
             var genericType = typeof(AutoSubClassPart<>).MakeGenericType(typeof(TSubclass));
             var subclass = (AutoSubClassPart<TSubclass>)Activator.CreateInstance(genericType, null, discriminatorValue);
-            
+
             if (action != null)
                 action(subclass);
 
             // remove any mappings for the same type, then re-add
             providers.Subclasses[typeof(TSubclass)] = subclass;
 
-		    return subclass;
+            return subclass;
         }
 
         public AutoSubClassPart<TSubclass> SubClass<TSubclass>(object discriminatorValue)
-			where TSubclass : T
-		{
-			return SubClass<TSubclass>(discriminatorValue, null);
-		}
+            where TSubclass : T
+        {
+            return SubClass<TSubclass>(discriminatorValue, null);
+        }
 
         public IAutoClasslike SubClass(Type type, string discriminatorValue)
         {
@@ -191,10 +190,10 @@ public IAutoClasslike SubClass(Type type, string discriminatorValue)
 
             return (IAutoClasslike)subclass;
         }
-        
+
         // hide the base one D:
-        private new void Join(string table, Action<JoinPart<T>> action)
-        { }
+        new void Join(string table, Action<JoinPart<T>> action)
+        {}
 
         public void Join(string table, Action<AutoJoinPart<T>> action)
         {

src/FluentNHibernate/Mapping/ClasslikeMapBase.cs

@@ -238,7 +238,14 @@ DynamicComponentPart<IDictionary> DynamicComponent(Member member, Action<Dynamic
         /// <returns>Component reference builder</returns>
         public virtual ReferenceComponentPart<TComponent> Component<TComponent>(Expression<Func<T, TComponent>> member)
         {
-            var part = new ReferenceComponentPart<TComponent>(member.ToMember(), typeof(T));
+            return Component<TComponent>(member.ToMember());
+        }
+
+        ReferenceComponentPart<TComponent> Component<TComponent>(Member member)
+        {
+            OnMemberMapped(member);
+
+            var part = new ReferenceComponentPart<TComponent>(member, typeof(T));
 
             providers.Components.Add(part);
 
@@ -287,7 +294,7 @@ ComponentPart<TComponent> Component<TComponent>(Member member, Action<ComponentP
 
             var part = new ComponentPart<TComponent>(typeof(T), member);
 
-            action(part);
+            if (action != null) action(part);
 
             providers.Components.Add(part);