Made ComponentMap compatible with automapping

Author: jagregory

src/FluentNHibernate.Specs/Automapping/AutomappingSpecs.Components.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using FluentNHibernate.Automapping;
+using FluentNHibernate.Mapping;
 using FluentNHibernate.MappingModel.ClassBased;
 using FluentNHibernate.Specs.Automapping.Fixtures;
 using FluentNHibernate.Utils;
@@ -42,6 +43,51 @@ public override bool IsComponent(Type type)
         }
     }
 
+    public class when_the_automapper_is_told_to_map_an_entity_and_a_component_that_has_an_associated_ComponentMap
+    {
+        Establish context = () =>
+            mapper = AutoMap.Source(
+                    new StubTypeSource(typeof(Entity), typeof(Component)),
+                    new TestConfiguration())
+                .AddMappingsFromSource(new StubTypeSource(typeof(CompMap)));
+
+        Because of = () =>
+            mappings = mapper.BuildMappings()
+                .SelectMany(x => x.Classes);
+
+        It should_map_the_entity = () =>
+            mappings.ShouldContain(x => x.Type == typeof(Entity));
+
+        It should_not_map_the_component_as_an_entity = () =>
+            mappings.ShouldNotContain(x => x.Type == typeof(Component));
+
+        It should_map_the_component_as_a_component_of_the_entity = () =>
+            mappings.Single(x => x.Type == typeof(Entity))
+                .Components.ShouldContain(x => x.Type == typeof(Component));
+
+        It should_use_the_component_map_for_mapping = () =>
+            mappings.Single().Components.Single().Access.ShouldEqual("none");
+
+        static AutoPersistenceModel mapper;
+        static IEnumerable<ClassMapping> mappings;
+
+        class TestConfiguration : DefaultAutomappingConfiguration
+        {
+            public override bool IsComponent(Type type)
+            {
+                return type == typeof(Component);
+            }
+        }
+
+        class CompMap : ComponentMap<Component>
+        {
+            public CompMap()
+            {
+                Access.None();
+            }
+        }
+    }
+
     public class when_the_automapper_maps_nested_comonents
     {
         Establish context = () =>

src/FluentNHibernate/Automapping/AutoPersistenceModel.cs

@@ -43,6 +43,23 @@ public AutoPersistenceModel(IAutomappingConfiguration cfg)
             componentResolvers.Add(new AutomappedComponentResolver(autoMapper, cfg));
         }
 
+        public AutoPersistenceModel AddMappingsFromAssemblyOf<T>()
+        {
+            return AddMappingsFromAssembly(typeof(T).Assembly);
+        }
+
+        public new AutoPersistenceModel AddMappingsFromAssembly(Assembly assembly)
+        {
+            AddMappingsFromSource(new AssemblyTypeSource(assembly));
+            return this;
+        }
+
+        public new AutoPersistenceModel AddMappingsFromSource(ITypeSource source)
+        {
+            base.AddMappingsFromSource(source);
+            return this;
+        }
+
         /// <summary>
         /// Specify alterations to be used with this AutoPersisteceModel
         /// </summary>

src/FluentNHibernate/Cfg/AutoMappingsContainer.cs

@@ -71,7 +71,8 @@ public AutoMappingsContainer ExportTo(TextWriter textWriter)
         /// Applies any added mappings to the NHibernate Configuration
         /// </summary>
         /// <param name="cfg">NHibernate Configuration instance</param>
-        internal void Apply(Configuration cfg)
+        /// <param name="model"></param>
+        internal void Apply(Configuration cfg, PersistenceModel model)
         {
             foreach (var mapping in mappings)
             {
@@ -81,6 +82,7 @@ internal void Apply(Configuration cfg)
                 if (exportTextWriter != null)
                     mapping.WriteMappingsTo(exportTextWriter);
 
+                mapping.ImportProviders(model);
                 mapping.Configure(cfg);
             }
         }

src/FluentNHibernate/Cfg/MappingConfiguration.cs

@@ -83,7 +83,7 @@ public void Apply(Configuration cfg)
 
             HbmMappings.Apply(cfg);
             FluentMappings.Apply(model);
-            AutoMappings.Apply(cfg);
+            AutoMappings.Apply(cfg, model);
 
             model.Configure(cfg);
         }

src/FluentNHibernate/PersistenceModel.cs

@@ -309,6 +309,27 @@ public bool ValidationEnabled
             get { return validationVisitor.Enabled; }
             set { validationVisitor.Enabled = value; }
         }
+
+        internal void ImportProviders(PersistenceModel model)
+        {
+            model.classProviders.Each(x =>
+            {
+                if (!classProviders.Contains(x))
+                    classProviders.Add(x);
+            });
+
+            model.subclassProviders.Each(x =>
+            {
+                if (!subclassProviders.Contains(x))
+                    subclassProviders.Add(x);
+            });
+
+            model.componentProviders.Each(x =>
+            {
+                if (!componentProviders.Contains(x))
+                    componentProviders.Add(x);
+            });
+        }
     }
 
     public interface IMappingProvider