Add ability to specify access for parent references in components

Fixes #120

+semver:breaking

Author: hazzik

src/FluentNHibernate.Testing/DomainModel/Mapping/ComponentElementPartTester.cs

@@ -21,6 +21,22 @@ public void CanIncludeParentReference()
                 .HasAttribute("name", "MyParent");
         }
 
+        [Test]
+        public void CanSetParentReferenceAccess()
+        {
+            new MappingTester<PropertyTarget>()
+                .ForMapping(m =>
+                    m.HasMany(x => x.Components)
+                        .Component(c =>
+                        {
+                            c.Map(x => x.Name);
+                            c.ParentReference(x => x.MyParent, FluentNHibernate.Mapping.Access.BackField);
+                        }))
+                .Element("class/bag/composite-element/parent").Exists()
+                .HasAttribute("name", "MyParent")
+                .HasAttribute("access", "backfield");
+        }
+
         [Test]
         public void CanCreateNestedCompositeElement()
         {

src/FluentNHibernate.Testing/DomainModel/Mapping/ComponentPartTester.cs

@@ -19,6 +19,21 @@ public void ComponentCanIncludeParentReference()
                 .HasAttribute("name", "MyParent");
         }
 
+        [Test]
+        public void ComponentCanSetParentReferenceAccessStrategy()
+        {
+            new MappingTester<PropertyTarget>()
+                .ForMapping(m =>
+                    m.Component(x => x.Component, c =>
+                    {
+                        c.Map(x => x.Name);
+                        c.ParentReference(x => x.MyParent, FluentNHibernate.Mapping.Access.BackField);
+                    }))
+                .Element("class/component/parent").ShouldBeInParentAtPosition(0)
+                .HasAttribute("name", "MyParent")
+                .HasAttribute("access", "backfield");
+        }
+
         [Test]
         public void ComponentDoesntHaveUniqueAttributeByDefault()
         {

src/FluentNHibernate/Conventions/Inspections/IParentInspector.cs

@@ -1,7 +1,10 @@
+using FluentNHibernate.Mapping;
+
 namespace FluentNHibernate.Conventions.Inspections
 {
     public interface IParentInspector : IInspector
     {
         string Name { get; }
+        Access Access { get; }
     }
 }

src/FluentNHibernate/Conventions/Inspections/ParentInspector.cs

@@ -1,5 +1,5 @@
 using System;
-using System.Reflection;
+using FluentNHibernate.Mapping;
 using FluentNHibernate.MappingModel;
 
 namespace FluentNHibernate.Conventions.Inspections
@@ -33,5 +33,10 @@ public string Name
         {
             get { return mapping.Name; }
         }
+
+        public Access Access
+        {
+            get { return Access.FromString(mapping.Access); }
+        }
     }
 }

src/FluentNHibernate/Mapping/ComponentPartBase.cs

@@ -59,16 +59,34 @@ public AccessStrategyBuilder<TBuilder> Access
         /// </example>
         public TBuilder ParentReference(Expression<Func<TEntity, object>> expression)
         {
-            return ParentReference(expression.ToMember());
+            var property = expression.ToMember();
+            return ParentReference(property, MemberAccessResolver.Resolve(property));
         }
 
-        private TBuilder ParentReference(Member property)
+        /// <summary>
+        /// Specify a parent reference for this component
+        /// </summary>
+        /// <param name="expression">Parent property</param>
+        /// <param name="access">Access to parent property</param>
+        /// <example>
+        /// ParentReference(x => x.Parent, Access.Backfield);
+        /// </example>
+        public TBuilder ParentReference(Expression<Func<TEntity, object>> expression, Access access)
+        {
+            return ParentReference(expression.ToMember(), access);
+        }
+
+        TBuilder ParentReference(Member property, Access access)
         {
             var parentMapping = new ParentMapping
             {
                 ContainingEntityType = typeof(TEntity)
             };
             parentMapping.Set(x => x.Name, Layer.Defaults, property.Name);
+
+            if (access != Mapping.Access.Property && access != Mapping.Access.Unset)
+                parentMapping.Set(x => x.Access, Layer.Defaults, access.ToString());
+            
             attributes.Set("Parent", Layer.Defaults, parentMapping);
 
             return (TBuilder)this;

src/FluentNHibernate/Mapping/CompositeElementPart.cs

@@ -117,12 +117,33 @@ protected virtual ManyToOnePart<TOther> References<TOther>(Member property, stri
         /// <param name="expression">Parent reference property</param>
         /// <returns>Component being mapped</returns>
         public void ParentReference(Expression<Func<T, object>> expression)
+        {
+            var property = expression.ToMember();
+            ParentReference(property, MemberAccessResolver.Resolve(property));
+        }
+
+        /// <summary>
+        /// Maps a property of the component class as a reference back to the containing entity
+        /// </summary>
+        /// <param name="expression">Parent reference property</param>
+        /// <param name="access">Access to parent reference property</param>
+        /// <returns>Component being mapped</returns>
+        public void ParentReference(Expression<Func<T, object>> expression, Access access)
+        {
+            ParentReference(expression.ToMember(), access);
+        }
+
+        void ParentReference(Member property, Access access)
         {
             var parentMapping = new ParentMapping
             {
                 ContainingEntityType = entity
             };
-            parentMapping.Set(x => x.Name, Layer.Defaults, expression.ToMember().Name);
+            parentMapping.Set(x => x.Name, Layer.Defaults, property.Name);
+
+            if (access != Access.Property && access != Access.Unset)
+                parentMapping.Set(x => x.Access, Layer.Defaults, access.ToString());
+
             attributes.Set("Parent", Layer.Defaults, parentMapping);
         }
 

src/FluentNHibernate/MappingModel/Output/XmlParentWriter.cs

@@ -23,6 +23,9 @@ public override void ProcessParent(ParentMapping parentMapping)
 
             if (parentMapping.IsSpecified("Name"))
                 parentElement.WithAtt("name", parentMapping.Name);
+            
+            if (parentMapping.IsSpecified("Access"))
+                parentElement.WithAtt("access", parentMapping.Access);
         }
     }
 }

src/FluentNHibernate/MappingModel/ParentMapping.cs

@@ -24,12 +24,17 @@ public override void AcceptVisitor(IMappingModelVisitor visitor)
             visitor.ProcessParent(this);
         }
 
+        public Type ContainingEntityType { get; set; }
+
         public string Name
         {
             get { return attributes.GetOrDefault<string>("Name"); }
         }
 
-        public Type ContainingEntityType { get; set; }
+        public string Access
+        {
+            get { return attributes.GetOrDefault<string>("Access"); }
+        }
 
         public override bool Equals(object obj)
         {