Fixing exact source member matching, re: issue #34 / Removing 'Root' prefix from non-root qualified member joined names / Increasing test coverage

Author: SteveWilkes

AgileMapper.UnitTests.NonParallel/AgileMapper.UnitTests.NonParallel.csproj

@@ -79,6 +79,7 @@
     <Compile Include="NonParallelTestsBase.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SimpleTypeConversion\WhenConvertingToStrings.cs" />
+    <Compile Include="WhenViewingMappingPlans.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config" />

AgileMapper.UnitTests.NonParallel/WhenViewingMappingPlans.cs

@@ -0,0 +1,40 @@
+namespace AgileObjects.AgileMapper.UnitTests.NonParallel
+{
+    using Shouldly;
+    using TestClasses;
+    using Xunit;
+
+    public class WhenViewingMappingPlans : NonParallelTestsBase
+    {
+        [Fact]
+        public void ShouldCreateAPlanSetViaTheStaticApi()
+        {
+            TestThenReset(() =>
+            {
+                var plans = Mapper.GetPlansFor<Product>().To<ProductDto>().ToString();
+
+                plans.ShouldContain("Rule Set: CreateNew");
+                plans.ShouldContain("Rule Set: Overwrite");
+                plans.ShouldContain("Rule Set: Merge");
+            });
+        }
+
+        [Fact]
+        public void ShouldShowAllCachedMappingPlansViaTheStaticApi()
+        {
+            TestThenReset(() =>
+            {
+                Mapper.GetPlanFor<MysteryCustomer>().ToANew<MysteryCustomerViewModel>();
+                Mapper.GetPlansFor(new MegaProduct()).To<ProductDtoMega>();
+
+                var plan = Mapper.GetPlansInCache();
+
+                plan.ShouldContain("MysteryCustomer -> MysteryCustomerViewModel");
+                plan.ShouldContain("MegaProduct -> ProductDtoMega");
+                plan.ShouldContain("Rule set: CreateNew");
+                plan.ShouldContain("Rule set: Merge");
+                plan.ShouldContain("Rule set: Overwrite");
+            });
+        }
+    }
+}

AgileMapper.UnitTests/Configuration/Inline/WhenConfiguringDataSourcesInline.cs

@@ -313,6 +313,21 @@ public void ShouldApplyDifferingTargetTypeInlineDataSourceMemberConfig()
             }
         }
 
+        [Fact]
+        public void ShouldHandleANullSourceMember()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var result = mapper
+                    .Map(default(PersonViewModel))
+                    .ToANew<Person>(cfg => cfg
+                        .Map((pvm, p) => "Named: " + pvm.Name)
+                        .To(p => p.Name));
+
+                result.ShouldBeNull();
+            }
+        }
+
         #region Helper Members
 
         private static Expression<Func<IMappingData<PublicProperty<int>, PublicField<int>>, object>> SubtractOne =>

AgileMapper.UnitTests/WhenMappingOverComplexTypeMembers.cs

@@ -65,6 +65,15 @@ public void ShouldNotPopulateAMemberWithNoMatchingSource()
             result.Address.ShouldBeNull();
         }
 
+        // See https://github.com/agileobjects/AgileMapper/issues/34
+        [Fact]
+        public void ShouldNotPopulateAMemberWithANullSource()
+        {
+            var result = Mapper.Map(new RockModel()).Over(new PaperModel());
+
+            result.Paper.ShouldBeNull();
+        }
+
         [Fact]
         public void ShouldNotOverwriteAMemberWithNoMatchingSource()
         {
@@ -135,5 +144,37 @@ public void ShouldHandleANullReadOnlyNestedMemberProperty()
 
             result.Value.ShouldBeNull();
         }
+
+        #region Helper Classes
+
+        internal class PaperModel
+        {
+            public int Id { get; set; }
+
+            public int? PaperId { get; set; }
+
+            public Paper Paper { get; set; }
+        }
+
+        internal class RockModel
+        {
+            public int Id { get; set; }
+
+            public int? RockId { get; set; }
+
+            public Rock Rock { get; set; }
+        }
+
+        internal class Rock
+        {
+            public int Id { get; set; }
+        }
+
+        internal class Paper
+        {
+            public int Id { get; set; }
+        }
+
+        #endregion
     }
 }

AgileMapper/Constants.cs

@@ -13,6 +13,7 @@ internal static class Constants
     {
         public static readonly bool ReflectionNotPermitted = ReflectionExtensions.ReflectionNotPermitted;
 
+        public static readonly string RootMemberName = "Root";
         public static readonly string EnumerableElementName = "[i]";
 
         public static readonly Type[] NoTypeArguments = Enumerable<Type>.EmptyArray;

AgileMapper/DataSources/ConfiguredDictionaryDataSourceFactory.cs

@@ -25,12 +25,10 @@ public override bool AppliesTo(IBasicMapperData mapperData)
                 return false;
             }
 
-            return Matches(mapperData.TargetMember) && base.AppliesTo(mapperData);
+            return mapperData.TargetMember.Matches(TargetDictionaryEntryMember) && 
+                   base.AppliesTo(mapperData);
         }
 
-        public bool Matches(QualifiedMember targetMember)
-            => targetMember.Matches(TargetDictionaryEntryMember);
-
         protected override bool MembersConflict(UserConfiguredItemBase otherItem)
         {
             return otherItem is ConfiguredDictionaryDataSourceFactory otherDictionaryItem &&

AgileMapper/Members/DictionaryTargetMember.cs

@@ -121,11 +121,9 @@ protected override QualifiedMember CreateRuntimeTypedMember(Type runtimeType)
 
         public override bool Matches(IQualifiedMember otherMember)
         {
-            var matches = base.Matches(otherMember);
-
             if (_key == null)
             {
-                return matches;
+                return base.Matches(otherMember);
             }
 
             return GetKeyNameOrNull() == otherMember.Name;

AgileMapper/Members/MemberExtensions.cs

@@ -10,6 +10,7 @@
     using Extensions;
     using NetStandardPolyfills;
     using ReadableExpressions.Extensions;
+    using static System.StringComparison;
 
     internal static class MemberExtensions
     {
@@ -32,12 +33,12 @@ private static string GetMemberPath(IQualifiedMember member, IQualifiedMember ro
                 return rootTypeName;
             }
 
-            if (memberPath.StartsWith(rootMember.Name, StringComparison.Ordinal))
+            if (memberPath.StartsWith(rootMember.Name, Ordinal))
             {
                 return rootTypeName + memberPath.Substring(rootMember.Name.Length);
             }
 
-            var rootMemberNameIndex = memberPath.IndexOf("." + rootMember.Name + ".", StringComparison.Ordinal);
+            var rootMemberNameIndex = memberPath.IndexOf("." + rootMember.Name + ".", Ordinal);
 
             if (rootMemberNameIndex == -1)
             {
@@ -132,18 +133,33 @@ public static ICollection<string> ExtendWith(
             return mapperContext.NamingSettings.ExtendJoinedNames(parentJoinedNames, memberMatchingNames);
         }
 
-        public static bool CouldMatch(this IEnumerable<string> memberNames, IEnumerable<string> otherMemberNames)
+        public static bool CouldMatch(this ICollection<string> memberNames, ICollection<string> otherMemberNames)
         {
+            if (otherMemberNames.HasOne() && (otherMemberNames.First() == Constants.RootMemberName) ||
+                memberNames.HasOne() && (memberNames.First() == Constants.RootMemberName))
+            {
+                return true;
+            }
+
             return otherMemberNames
-                .Any(otherJoinedName => memberNames
-                    .Any(joinedName => otherJoinedName.StartsWith(joinedName, StringComparison.OrdinalIgnoreCase)));
+                .Any(otherJoinedName => (otherJoinedName == Constants.RootMemberName) || memberNames
+                    .Any(joinedName => (joinedName == Constants.RootMemberName) || otherJoinedName.StartsWith(joinedName, OrdinalIgnoreCase)));
         }
 
-        public static bool Match(this IEnumerable<string> memberNames, IEnumerable<string> otherMemberNames)
+        public static bool Match(this ICollection<string> memberNames, ICollection<string> otherMemberNames)
         {
-            return memberNames
-                .Intersect(otherMemberNames, StringComparer.OrdinalIgnoreCase)
-                .Any();
+            if (!memberNames.HasOne())
+            {
+                return memberNames
+                    .Intersect(otherMemberNames, StringComparer.OrdinalIgnoreCase)
+                    .Any();
+            }
+
+            var memberName = memberNames.First();
+
+            return otherMemberNames.HasOne()
+                ? memberName.Equals(otherMemberNames.First(), OrdinalIgnoreCase)
+                : otherMemberNames.Any(otherMemberName => otherMemberName.Equals(memberName, OrdinalIgnoreCase));
         }
 
         public static TMember GetElementMember<TMember>(this TMember enumerableMember)

AgileMapper/Members/NamingSettings.cs

@@ -140,7 +140,7 @@ private IEnumerable<string> EnumerateMatchingNames(Member member)
         {
             if (member.IsRoot)
             {
-                yield return "Root";
+                yield return Constants.RootMemberName;
                 yield break;
             }
 
@@ -177,8 +177,16 @@ public ICollection<string> GetJoinedNamesFor(string[][] matchingNameSets)
 
         public ICollection<string> ExtendJoinedNames(ICollection<string> parentJoinedNames, string[] names)
         {
+            var firstParentJoinedName = parentJoinedNames.First();
+
+            if (parentJoinedNames.HasOne() && (firstParentJoinedName == Constants.RootMemberName))
+            {
+                // Don't bother to prepend 'Root' as a joined name:
+                return names;
+            }
+
             var isElementMember = (names.Length == 1) && (names[0] == Constants.EnumerableElementName);
-            var wasElementMember = parentJoinedNames.First().EndsWith(Constants.EnumerableElementName, StringComparison.Ordinal);
+            var wasElementMember = firstParentJoinedName.EndsWith(Constants.EnumerableElementName, StringComparison.Ordinal);
 
             var numberOfExtendedJoinedNames = isElementMember
                 ? parentJoinedNames.Count

AgileMapper/Members/SourceMemberMatcher.cs

@@ -47,9 +47,11 @@ private static bool ExactMatchingSourceMemberExists(
         {
             var sourceMember = QuerySourceMembers(
                 parentSourceMember,
-                m => m.Name == targetData.MapperData.TargetMember.Name).FirstOrDefault();
+                m => targetData.MapperData.TargetMember.LeafMember.Equals(m) ||
+                     targetData.MapperData.TargetMember.JoinedNames.Match(new[] { m.Name }))
+                .FirstOrDefault();
 
-            if ((sourceMember == null) || 
+            if ((sourceMember == null) ||
                 !TypesAreCompatible(sourceMember.Type, targetData.MapperData))
             {
                 matchingMember = null;