Fix for weird key column issue

1.1 introduced a regression where entities that are the target of
multiple Reference mappings from the same source would end up with
multiple key columns being defined based on the property names.

The source of this was the RelationshipKeyPairingVisitor, which frankly
I have no idea what it was trying to do. I think it might have something
to do with composite keys and relationships, but the usage isn't very
clear. For the time being I've removed this functionality.

Author: jagregory

src/FluentNHibernate.Specs/Conventions/BiDirectionalKeysSpecs.cs

@@ -21,9 +21,14 @@ public class when_mapping_a_many_to_one_one_to_many_bi_directional_relationship
             child = mappings.SelectMany(x => x.Classes).FirstOrDefault(x => x.Type == typeof(Child));
         };
 
+        // these are ignored due to a regression this code caused - as this feature was added only as an
+        // experiment, I doubt anyone will miss it for the time being.
+
+        [Ignore]
         It should_use_the_many_to_one_columns_for_the_one_to_many_key = () =>
             parent.Collections.Single().Key.Columns.Select(x => x.Name).ShouldContainOnly("one", "two");
 
+        [Ignore]
         It shouldnt_alter_the_many_to_one_columns = () =>
             child.References.Single().Columns.Select(x => x.Name).ShouldContainOnly("one", "two");
 

src/FluentNHibernate.Specs/FluentInterface/BiDirectionalKeyIssueSpecs.cs

@@ -0,0 +1,30 @@
+using System.Linq;
+using FluentNHibernate.MappingModel.ClassBased;
+using FluentNHibernate.Specs.FluentInterface.Fixtures.BiDirectionalKeyIssue;
+using Machine.Specifications;
+
+namespace FluentNHibernate.Specs.FluentInterface
+{
+    public class when_there_are_two_references_to_the_same_entity
+    {
+        Establish context = () =>
+        {
+            model = new FluentNHibernate.PersistenceModel();
+            model.Add(new ContactMap());
+            model.Add(new ContactEmailMap());
+            model.Add(new ContactPhoneMap());
+            model.Add(new CaseMap());
+        };
+
+        Because of = () =>
+            contact_mapping = model.BuildMappingFor<Contact>();
+
+        It should_work_like_1_0_did_aka_not_create_multiple_columns_to_the_same_entity = () =>
+            contact_mapping.Collections
+                .Single(x => x.Name == "EmailAddresses")
+                .Key.Columns.Select(x => x.Name).ShouldContainOnly("Contact_id");
+
+        static FluentNHibernate.PersistenceModel model;
+        static ClassMapping contact_mapping;
+    }
+}

src/FluentNHibernate.Specs/FluentInterface/Fixtures/BiDirectionalKeyIssue.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using FluentNHibernate.Mapping;
+
+namespace FluentNHibernate.Specs.FluentInterface.Fixtures.BiDirectionalKeyIssue
+{
+    public abstract class Entity
+    {
+        public Guid Id { get; set; }
+    }
+
+    public class ContactMap : DomainMap<Contact>
+    {
+        public ContactMap()
+        {
+            HasMany(x => x.EmailAddresses);
+            HasMany(x => x.PhoneNumbers);
+        }
+    }
+
+    public class Contact : Entity
+    {
+        public virtual IEnumerable<ContactEmail> EmailAddresses { get; set; }
+        public virtual IEnumerable<ContactPhone> PhoneNumbers { get; set; }
+    }
+
+    public class ContactEmail : Entity
+    {
+        public virtual string EmailAddress { get; set; }
+        public virtual Contact Contact { get; set; }
+    }
+
+    public class ContactPhone : Entity
+    {
+        public virtual string PhoneNumber { get; set; }
+    }
+
+    public class ContactEmailMap : DomainMap<ContactEmail>
+    {
+        public ContactEmailMap()
+        {
+            Map(c => c.EmailAddress);
+            References(x => x.Contact);
+        }
+    }
+
+    public class ContactPhoneMap : DomainMap<ContactPhone>
+    {
+        public ContactPhoneMap()
+        {
+            Map(c => c.PhoneNumber);
+        }
+    }
+
+    public class DomainMap<T> : ClassMap<T> where T : Entity
+    {
+        public DomainMap()
+        {
+            Id(x => x.Id).Column("id").GeneratedBy.GuidComb();
+            Table(typeof(T).Name);
+        }
+    }
+
+    public class CaseMap : DomainMap<Case>
+    {
+        public CaseMap()
+        {
+            References(c => c.AlternateContact);
+            References(c => c.Contact);
+            Table("Cases");
+        }
+    }
+
+    public class Case : Entity
+    {
+        public virtual Contact Contact { get; set; }
+        public virtual Contact AlternateContact { get; set; }
+    }
+}

src/FluentNHibernate.Specs/FluentNHibernate.Specs.csproj

@@ -144,7 +144,9 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Automapping\AutomappingSpecs.NestedClasses.cs" />
+    <Compile Include="FluentInterface\BiDirectionalKeyIssueSpecs.cs" />
     <Compile Include="FluentInterface\ExternalComponentOutputSpecs.cs" />
+    <Compile Include="FluentInterface\Fixtures\BiDirectionalKeyIssue.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

src/FluentNHibernate/Automapping/Steps/ReferenceStep.cs

@@ -26,6 +26,7 @@ public bool ShouldMap(Member member)
         public void Map(ClassMappingBase classMap, Member member)
         {
             var manyToOne = CreateMapping(member);
+            manyToOne.ContainingEntityType = classMap.Type;
             classMap.AddReference(manyToOne);
         }
 

src/FluentNHibernate/MappingModel/KeyMapping.cs

@@ -87,7 +87,7 @@ public void AddDefaultColumn(ColumnMapping mapping)
 
         public void ClearColumns()
         {
-            columns.Clear();
+            columns.ClearAll();
         }
 
         public override bool IsSpecified(string property)

src/FluentNHibernate/Visitors/RelationshipKeyPairingVisitor.cs

@@ -14,30 +14,15 @@ public override void ProcessManyToOne(ManyToOneMapping thisSide)
             // other side is always going to be a collection for a many-to-one mapping
             var otherSide = (ICollectionMapping)thisSide.OtherSide;
 
-            // both sides have user-defined key columns... leave alone!
-            if (otherSide.Key.Columns.HasUserDefined() && thisSide.Columns.HasUserDefined())
-                return;
-
-            if (otherSide.Key.Columns.HasUserDefined())
+            if (thisSide.ContainingEntityType == otherSide.ContainingEntityType)
             {
-                // only other side has user-defined columns, so we'll bring them across to this side
-                thisSide.ClearColumns();
-                otherSide.Key.Columns.Each(x => thisSide.AddColumn(x.Clone()));
-                return;
-            }
+                // special case for self-referential relationships
+                if (thisSide.Columns.HasUserDefined() || otherSide.Key.Columns.HasUserDefined())
+                    return; // leave alone if user defined
 
-            if (otherSide.Key.Columns.HasUserDefined())
-            {
-                // only other side has user-defined columns, so we'll bring them across to this side
-                thisSide.ClearColumns();
-                otherSide.Key.Columns.Each(x => thisSide.AddColumn(x.Clone()));
-                return;
+                otherSide.Key.ClearColumns();
+                thisSide.Columns.Each(x => otherSide.Key.AddDefaultColumn(x.Clone()));
             }
-
-            // the other side doesn't have any user defined columns, so we'll use the ones from this side
-            // whether they're user defined or not.
-            otherSide.Key.ClearColumns();
-            thisSide.Columns.Each(x => otherSide.Key.AddColumn(x.Clone()));
         }
     }
 }