Support for mapping object-typed dictionaries to object-typed dictionaries, re: issue #10 / Caching source and target members according to mapped source and target types / Simplifying AdHocDataSource use

Author: SteveWilkes

AgileMapper.UnitTests/AgileMapper.UnitTests.csproj

@@ -80,6 +80,7 @@
     <Compile Include="Dictionaries\Configuration\WhenConfiguringDictionaryMappingIncorrectly.cs" />
     <Compile Include="Dictionaries\Configuration\WhenConfiguringNestedDictionaryMapping.cs" />
     <Compile Include="Dictionaries\Configuration\WhenConfiguringTargetDictionaryMapping.cs" />
+    <Compile Include="Dictionaries\WhenCreatingRootDictionaryMembers.cs" />
     <Compile Include="TestClasses\MegaProduct.cs" />
     <Compile Include="TestClasses\ProductDto.cs" />
     <Compile Include="TestClasses\ProductDtoMega.cs" />

AgileMapper.UnitTests/Dictionaries/WhenCreatingRootDictionaryMembers.cs

@@ -0,0 +1,32 @@
+namespace AgileObjects.AgileMapper.UnitTests.Dictionaries
+{
+    using System.Collections.Generic;
+    using AgileMapper.Members;
+    using Shouldly;
+    using TestClasses;
+    using Xunit;
+
+    public class WhenCreatingRootDictionaryMembers
+    {
+        [Fact]
+        public void ShouldVarySourceMembersByTargetType()
+        {
+            var memberFactory = new QualifiedMemberFactory(MapperContext.Default);
+
+            var dictionaryToPersonArraySourceMember = memberFactory
+                .RootSource<Dictionary<string, Person[]>, Person[]>()
+                as DictionarySourceMember;
+
+            dictionaryToPersonArraySourceMember.ShouldNotBeNull();
+
+            // ReSharper disable once PossibleNullReferenceException
+            dictionaryToPersonArraySourceMember.CouldContainSourceInstance.ShouldBeTrue();
+
+            var dictionaryToObjectSourceMember = memberFactory
+                .RootSource<Dictionary<string, Person[]>, PersonViewModel[]>()
+                as DictionarySourceMember;
+
+            dictionaryToObjectSourceMember.ShouldNotBeSameAs(dictionaryToPersonArraySourceMember);
+        }
+    }
+}

AgileMapper.UnitTests/Dictionaries/WhenMappingOnToDictionaryMembers.cs

@@ -8,7 +8,7 @@
     public class WhenMappingOnToDictionaryMembers
     {
         [Fact]
-        public void ShouldMapADictionaryOnToAConvertibleSimpleTypedDictionary()
+        public void ShouldMapAnIDictionaryOnToAConvertibleSimpleTypedDictionary()
         {
             var guidOne = Guid.NewGuid();
             var guidTwo = Guid.NewGuid();

AgileMapper.UnitTests/Dictionaries/WhenMappingOverDictionaryMembers.cs

@@ -71,5 +71,42 @@ public void ShouldOverwriteADictionaryToAConvertibleSimpleTypedDictionary()
             target.Value["Four"].ShouldBeNull();
             target.Value["Five"].ShouldBe(5);
         }
+
+        // See https://github.com/agileobjects/AgileMapper/issues/10
+        [Fact]
+        public void ShouldMapADictionaryMemberOverADictionaryMember()
+        {
+            var source = new PublicProperty<Dictionary<string, object>>
+            {
+                Value = new Dictionary<string, object>
+                {
+                    ["One!"] = new PersonViewModel { Name = "One!" },
+                    ["Two!"] = new PersonViewModel { Name = "Two!" }
+                }
+            };
+
+
+            var target = new PublicProperty<Dictionary<string, object>>
+            {
+                Value = new Dictionary<string, object>
+                {
+                    ["Two!"] = new PersonViewModel { Name = "Three!" }
+                }
+            };
+
+            var existingTarget = target.Value;
+
+            Mapper.Map(source).Over(target);
+
+            target.Value.ShouldBeSameAs(existingTarget);
+
+            target.Value.ContainsKey("One!").ShouldBeTrue();
+            target.Value["One!"].ShouldBeOfType<PersonViewModel>();
+            ((PersonViewModel)target.Value["One!"]).Name.ShouldBe("One!");
+
+            target.Value.ContainsKey("Two!").ShouldBeTrue();
+            target.Value["Two!"].ShouldBeOfType<PersonViewModel>();
+            ((PersonViewModel)target.Value["Two!"]).Name.ShouldBe("Two!");
+        }
     }
 }

AgileMapper.UnitTests/Members/WhenDeterminingRecursion.cs

@@ -11,7 +11,7 @@ public class WhenDeterminingRecursion : MemberTestsBase
         public void ShouldNotCountARootMemberAsRecursive()
         {
             var rootMember = new QualifiedMemberFactory(DefaultMapperContext)
-                .RootTarget<PublicProperty<string>>();
+                .RootTarget<Person, PublicProperty<string>>();
 
             rootMember.IsRecursion.ShouldBeFalse();
         }

AgileMapper/Api/Configuration/CustomDataSourceTargetMemberSpecifier.cs

@@ -101,7 +101,7 @@ private bool IsDictionaryEntry(LambdaExpression targetMemberLambda, out Dictiona
 
             var rootMember = (DictionaryTargetMember)_configInfo.MapperContext
                 .QualifiedMemberFactory
-                .RootTarget<TTarget>();
+                .RootTarget<TSource, TTarget>();
 
             entryMember = rootMember.Append(typeof(TSource), entryKey);
             return true;

AgileMapper/DataSources/AdHocDataSource.cs

@@ -1,11 +1,12 @@
 namespace AgileObjects.AgileMapper.DataSources
 {
     using System.Linq.Expressions;
+    using Members;
 
     internal class AdHocDataSource : DataSourceBase
     {
-        public AdHocDataSource(IDataSource wrappedDataSource, Expression value)
-            : base(wrappedDataSource, value)
+        public AdHocDataSource(IQualifiedMember targetMember, Expression value)
+            : base(targetMember, value)
         {
         }
     }

AgileMapper/DataSources/DataSourceBase.cs

@@ -119,7 +119,7 @@ public Expression AddCondition(Expression value, Expression alternateBranch = nu
                 : Expression.IfThen(Condition, value);
         }
 
-        public Expression GetMemberPopulation(IMemberMapperData mapperData)
+        public Expression GetTargetMemberPopulation(IMemberMapperData mapperData)
             => mapperData.GetTargetMemberPopulation(Value);
     }
 }

AgileMapper/DataSources/DataSourceSet.cs

@@ -79,7 +79,7 @@ public Expression GetPopulationExpression(IMemberMapperData mapperData)
                     continue;
                 }
 
-                var memberPopulation = dataSource.GetMemberPopulation(mapperData);
+                var memberPopulation = dataSource.GetTargetMemberPopulation(mapperData);
 
                 population = dataSource.AddCondition(memberPopulation, population);
                 population = dataSource.AddPreCondition(population);

AgileMapper/DataSources/IDataSource.cs

@@ -21,6 +21,6 @@ internal interface IDataSource : IConditionallyChainable
 
         Expression AddCondition(Expression value, Expression alternateBranch = null);
 
-        Expression GetMemberPopulation(IMemberMapperData mapperData);
+        Expression GetTargetMemberPopulation(IMemberMapperData mapperData);
     }
 }