Flatten to dynamic

AgileMapper.UnitTests/AgileMapper.UnitTests.csproj

@@ -96,8 +96,30 @@
     <Compile Include="Configuration\Inline\WhenValidatingMappingsInline.cs" />
     <Compile Include="Configuration\Inline\WhenViewingMappingPlans.cs" />
     <Compile Include="Configuration\WhenViewingMappingPlans.cs" />
-    <Compile Include="Dictionaries\WhenMergingObjectsFromDictionaries.cs" />
-    <Compile Include="Dictionaries\WhenOverwritingObjectsFromDictionaries.cs" />
+    <Compile Include="Dictionaries\WhenMappingFromDictionariesOnToComplexTypes.cs" />
+    <Compile Include="Dictionaries\WhenMappingFromDictionariesOnToEnumerableMembers.cs" />
+    <Compile Include="Dictionaries\WhenMappingFromDictionariesOverComplexTypes.cs" />
+    <Compile Include="Dictionaries\WhenMappingFromDictionariesToNewComplexTypeMembers.cs" />
+    <Compile Include="Dictionaries\WhenMappingFromDictionariesToNewEnumerableMembers.cs" />
+    <Compile Include="Dictionaries\WhenMappingFromDictionariesToNewEnumerables.cs" />
+    <Compile Include="Dynamics\Configuration\WhenConfiguringDynamicMappingIncorrectly.cs" />
+    <Compile Include="Dynamics\Configuration\WhenConfiguringSourceDynamicMapping.cs" />
+    <Compile Include="Dynamics\Configuration\WhenConfiguringTargetDynamicMapping.cs" />
+    <Compile Include="Dynamics\WhenMappingFromDynamicsOverComplexTypeMembers.cs" />
+    <Compile Include="Dynamics\WhenMappingFromDynamicsOverComplexTypes.cs" />
+    <Compile Include="Dynamics\WhenMappingFromDynamicsOverEnumerableMembers.cs" />
+    <Compile Include="Dynamics\WhenMappingFromDynamicsOverEnumerables.cs" />
+    <Compile Include="Dynamics\WhenMappingFromDynamicsToNewComplexTypeMembers.cs" />
+    <Compile Include="Dynamics\WhenMappingFromDynamicsToNewComplexTypes.cs" />
+    <Compile Include="Dynamics\WhenMappingFromDynamicsToNewEnumerableMembers.cs" />
+    <Compile Include="Dynamics\WhenMappingFromDynamicsToNewEnumerables.cs" />
+    <Compile Include="Dynamics\WhenMappingOnToDynamics.cs" />
+    <Compile Include="Dynamics\WhenMappingOnToDynamicMembers.cs" />
+    <Compile Include="Dynamics\WhenMappingOverDynamicMembers.cs" />
+    <Compile Include="Dynamics\WhenMappingOverDynamics.cs" />
+    <Compile Include="Dynamics\WhenMappingToNewEnumerablesOfDynamic.cs" />
+    <Compile Include="Dynamics\WhenMappingToNewDynamicMembers.cs" />
+    <Compile Include="Dynamics\WhenMappingToNewDynamics.cs" />
     <Compile Include="Extensions\WhenEquatingExpressions.cs" />
     <Compile Include="MapperCloning\WhenCloningConstructorDataSources.cs" />
     <Compile Include="MapperCloning\WhenCloningMemberIgnores.cs" />
@@ -180,7 +202,7 @@
     <Compile Include="WhenAnalysingCollections.cs" />
     <Compile Include="MapperCloning\WhenCloningDataSources.cs" />
     <Compile Include="WhenFlatteningObjects.cs" />
-    <Compile Include="Dictionaries\WhenMappingNewObjectsFromDictionaries.cs" />
+    <Compile Include="Dictionaries\WhenMappingFromDictionariesToNewComplexTypes.cs" />
     <Compile Include="Dictionaries\WhenMappingFromDictionaryMembers.cs" />
     <Compile Include="Dictionaries\WhenMappingOnToDictionaries.cs" />
     <Compile Include="Dictionaries\WhenMappingOnToDictionaryMembers.cs" />

AgileMapper.UnitTests/Configuration/WhenConfiguringNameMatching.cs

@@ -3,7 +3,7 @@
     using System;
     using System.Collections.Generic;
     using AgileMapper.Configuration;
-    using AgileMapper.Extensions;
+    using AgileMapper.Extensions.Internal;
     using Shouldly;
     using TestClasses;
     using Xunit;

AgileMapper.UnitTests/Configuration/WhenIgnoringMembersByFilter.cs

@@ -1,6 +1,7 @@
 namespace AgileObjects.AgileMapper.UnitTests.Configuration
 {
     using System;
+    using AgileMapper.Extensions.Internal;
     using TestClasses;
     using Xunit;
 
@@ -331,8 +332,7 @@ public void ShouldIgnoreMembersBySourceTypeTargetTypeAndPathMatch()
                 mapper.WhenMapping
                     .From<PublicField<Address>>()
                     .To<PublicProperty<Address>>()
-                    .IgnoreTargetMembersWhere(member =>
-                        member.Path.Equals("Value.Line2", StringComparison.OrdinalIgnoreCase));
+                    .IgnoreTargetMembersWhere(member => member.Path.EqualsIgnoreCase("Value.Line2"));
 
                 var matchingSource = new PublicField<Address> { Value = new Address { Line1 = "Here", Line2 = "Here!" } };
                 var nonMatchingSource = new { Value = new Address { Line1 = "There", Line2 = "There!" } };

AgileMapper.UnitTests/Configuration/WhenIgnoringMembersByGlobalFilter.cs

@@ -1,7 +1,7 @@
 namespace AgileObjects.AgileMapper.UnitTests.Configuration
 {
     using System;
-    using System.Linq;
+    using AgileMapper.Extensions.Internal;
     using Shouldly;
     using TestClasses;
     using Xunit;
@@ -209,8 +209,7 @@ public void ShouldIgnoreMembersByPathMatch()
                 var source = new { Address = new Address { Line1 = "ONE!", Line2 = "TWO!" } };
 
                 mapper.WhenMapping
-                    .IgnoreTargetMembersWhere(member =>
-                        member.Path.Equals("Value.Line1", StringComparison.OrdinalIgnoreCase));
+                    .IgnoreTargetMembersWhere(member => member.Path.EqualsIgnoreCase("Value.Line1"));
 
                 mapper.WhenMapping
                     .From(source)

AgileMapper.UnitTests/Dictionaries/Configuration/WhenConfiguringDictionaryMappingIncorrectly.cs

@@ -14,7 +14,7 @@ public void ShouldErrorIfCustomMemberKeyIsNull()
             var configEx = Should.Throw<MappingConfigurationException>(() =>
             {
                 Mapper.WhenMapping
-                    .Dictionaries
+                    .FromDictionaries
                     .To<PublicField<string>>()
                     .MapFullKey(null)
                     .To(pf => pf.Value);
@@ -29,7 +29,7 @@ public void ShouldErrorIfCustomMemberNameIsNull()
             var configEx = Should.Throw<MappingConfigurationException>(() =>
             {
                 Mapper.WhenMapping
-                    .Dictionaries
+                    .FromDictionaries
                     .To<PublicField<string>>()
                     .MapMemberNameKey(null)
                     .To(pf => pf.Value);
@@ -46,12 +46,12 @@ public void ShouldErrorIfIgnoredMemberIsGivenCustomMemberKey()
                 using (var mapper = Mapper.CreateNew())
                 {
                     mapper.WhenMapping
-                        .Dictionaries
+                        .FromDictionaries
                         .To<Person>()
                         .Ignore(p => p.Id);
 
                     mapper.WhenMapping
-                        .Dictionaries
+                        .FromDictionaries
                         .To<Person>()
                         .MapFullKey("PersonId")
                         .To(p => p.Id);
@@ -69,12 +69,12 @@ public void ShouldErrorIfIgnoredMemberIsGivenCustomMemberName()
                 using (var mapper = Mapper.CreateNew())
                 {
                     mapper.WhenMapping
-                        .Dictionaries
+                        .FromDictionaries
                         .To<PublicField<string>>()
                         .Ignore(pf => pf.Value);
 
                     mapper.WhenMapping
-                        .Dictionaries
+                        .FromDictionaries
                         .To<PublicField<string>>()
                         .MapMemberNameKey("ValueValue")
                         .To(pf => pf.Value);
@@ -92,13 +92,13 @@ public void ShouldErrorIfCustomDataSourceMemberIsGivenCustomMemberKey()
                 using (var mapper = Mapper.CreateNew())
                 {
                     mapper.WhenMapping
-                        .Dictionaries
+                        .FromDictionaries
                         .To<Person>()
                         .Map((d, p) => d.Count)
                         .To(p => p.Name);
 
                     mapper.WhenMapping
-                        .Dictionaries
+                        .FromDictionaries
                         .To<Person>()
                         .MapFullKey("PersonName")
                         .To(p => p.Name);
@@ -116,13 +116,13 @@ public void ShouldErrorIfCustomDataSourceMemberIsGivenCustomMemberName()
                 using (var mapper = Mapper.CreateNew())
                 {
                     mapper.WhenMapping
-                        .Dictionaries
+                        .FromDictionaries
                         .To<Person>()
                         .Map((d, p) => d.Count)
                         .To(p => p.Name);
 
                     mapper.WhenMapping
-                        .Dictionaries
+                        .FromDictionaries
                         .To<Person>()
                         .MapMemberNameKey("PersonName")
                         .To(p => p.Name);
@@ -159,77 +159,76 @@ public void ShouldErrorIfAnUnreadableSourceMemberIsSpecified()
         }
 
         [Fact]
-        public void ShouldErrorIfMemberNamesAreFlattenedAndSeparatedGlobally()
+        public void ShouldErrorIfRedundantSourceSeparatorIsConfigured()
         {
             var configEx = Should.Throw<MappingConfigurationException>(() =>
             {
                 using (var mapper = Mapper.CreateNew())
                 {
                     mapper.WhenMapping
-                        .Dictionaries
-                        .UseFlattenedMemberNames()
-                        .UseMemberNameSeparator("+");
+                        .FromDictionaries
+                        .UseMemberNameSeparator(".");
                 }
             });
 
+            configEx.Message.ShouldContain("already");
             configEx.Message.ShouldContain("global");
-            configEx.Message.ShouldContain("flattened");
+            configEx.Message.ShouldContain("'.'");
         }
 
         [Fact]
-        public void ShouldErrorIfMemberNamesAreSeparatedAndFlattenedGlobally()
+        public void ShouldErrorIfMemberNamesAreFlattenedAndSeparatedGlobally()
         {
             var configEx = Should.Throw<MappingConfigurationException>(() =>
             {
                 using (var mapper = Mapper.CreateNew())
                 {
                     mapper.WhenMapping
-                        .Dictionaries
-                        .UseMemberNameSeparator("+")
-                        .UseFlattenedMemberNames();
+                        .FromDictionaries
+                        .UseFlattenedTargetMemberNames()
+                        .UseMemberNameSeparator("+");
                 }
             });
 
             configEx.Message.ShouldContain("global");
-            configEx.Message.ShouldContain("separated with '+'");
+            configEx.Message.ShouldContain("flattened");
         }
 
         [Fact]
-        public void ShouldErrorIfMemberNamesAreFlattenedAndSeparatedForASpecificTargetType()
+        public void ShouldErrorIfMemberNamesAreSeparatedAndFlattenedGlobally()
         {
             var configEx = Should.Throw<MappingConfigurationException>(() =>
             {
                 using (var mapper = Mapper.CreateNew())
                 {
                     mapper.WhenMapping
                         .Dictionaries
-                        .To<PublicField<PublicProperty<string>>>()
-                        .UseFlattenedMemberNames()
-                        .UseMemberNameSeparator("_");
+                        .UseMemberNameSeparator("+")
+                        .UseFlattenedTargetMemberNames();
                 }
             });
 
-            configEx.Message.ShouldContain("PublicField<PublicProperty<string>>");
-            configEx.Message.ShouldContain("flattened");
+            configEx.Message.ShouldContain("global");
+            configEx.Message.ShouldContain("separated with '+'");
         }
 
         [Fact]
-        public void ShouldErrorIfMemberNamesAreSeparatedAndFlattenedForASpecificTargetType()
+        public void ShouldErrorIfDifferentSeparatorsSpecifiedForASpecificTargetType()
         {
             var configEx = Should.Throw<MappingConfigurationException>(() =>
             {
                 using (var mapper = Mapper.CreateNew())
                 {
                     mapper.WhenMapping
-                        .Dictionaries
-                        .To<PublicProperty<PublicField<int>>>()
-                        .UseMemberNameSeparator("+")
-                        .UseFlattenedMemberNames();
+                        .FromDictionaries
+                        .To<PublicField<PublicProperty<string>>>()
+                        .UseMemberNameSeparator("-")
+                        .UseMemberNameSeparator("_");
                 }
             });
 
-            configEx.Message.ShouldContain("PublicProperty<PublicField<int>>");
-            configEx.Message.ShouldContain("separated with '+'");
+            configEx.Message.ShouldContain("PublicField<PublicProperty<string>>");
+            configEx.Message.ShouldContain("separated with '-'");
         }
 
         [Fact]
@@ -280,6 +279,24 @@ public void ShouldErrorIfAnElementKeyPartHasMultipleIndexPlaceholders()
                 "pattern must contain a single 'i' character as a placeholder for the enumerable index");
         }
 
+        [Fact]
+        public void ShouldErrorIfRedundantGlobalElementKeyPartIsConfigured()
+        {
+            var configEx = Should.Throw<MappingConfigurationException>(() =>
+            {
+                using (var mapper = Mapper.CreateNew())
+                {
+                    mapper.WhenMapping
+                        .Dictionaries
+                        .UseElementKeyPattern("[i]");
+                }
+            });
+
+            configEx.Message.ShouldContain("already");
+            configEx.Message.ShouldContain("global");
+            configEx.Message.ShouldContain("[i]");
+        }
+
         [Fact]
         public void ShouldErrorIfCustomTargetMemberKeyIsNotAConstant()
         {