Releases/1.1.0 preview

AgileMapper.PerformanceTester.Net45/AgileMapper.PerformanceTester.Net45.csproj

@@ -37,8 +37,8 @@
     <Reference Include="AgileObjects.NetStandardPolyfills, Version=1.4.0.0, Culture=neutral, PublicKeyToken=06131ac1c008ad4e, processorArchitecture=MSIL">
       <HintPath>..\packages\AgileObjects.NetStandardPolyfills.1.4.0\lib\net40\AgileObjects.NetStandardPolyfills.dll</HintPath>
     </Reference>
-    <Reference Include="AgileObjects.ReadableExpressions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
-      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.0.0\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
+    <Reference Include="AgileObjects.ReadableExpressions, Version=2.1.0.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
+      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.1.0\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
     </Reference>
     <Reference Include="AutoMapper, Version=7.0.1.0, Culture=neutral, PublicKeyToken=be96cd2c38ef1005, processorArchitecture=MSIL">
       <HintPath>..\packages\AutoMapper.7.0.1\lib\net45\AutoMapper.dll</HintPath>

AgileMapper.PerformanceTester.Net45/packages.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="AgileObjects.NetStandardPolyfills" version="1.4.0" targetFramework="net452" />
-  <package id="AgileObjects.ReadableExpressions" version="2.0.0" targetFramework="net452" />
+  <package id="AgileObjects.ReadableExpressions" version="2.1.0" targetFramework="net452" />
   <package id="AutoMapper" version="7.0.1" targetFramework="net452" />
   <package id="Expressmapper" version="1.9.1" targetFramework="net452" />
   <package id="Mapster" version="3.2.0" targetFramework="net452" />

AgileMapper.UnitTests.Common/ShouldExtensions.cs

@@ -400,7 +400,7 @@ public static IDictionary<TKey, TValue> ShouldContainKeyAndValue<TKey, TValue>(
                 Asplode("Dictionary with key " + expectedKey, "No contained key");
             }
 
-            value.ShouldBeSameAs(expectedValue);
+            value.ShouldBe(expectedValue);
 
             return dictionary;
         }

AgileMapper.UnitTests.Net35/AgileMapper.UnitTests.Net35.csproj

@@ -37,8 +37,8 @@
     <Reference Include="AgileObjects.NetStandardPolyfills, Version=1.4.0.0, Culture=neutral, PublicKeyToken=06131ac1c008ad4e, processorArchitecture=MSIL">
       <HintPath>..\packages\AgileObjects.NetStandardPolyfills.1.4.0\lib\net35\AgileObjects.NetStandardPolyfills.dll</HintPath>
     </Reference>
-    <Reference Include="AgileObjects.ReadableExpressions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
-      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.0.0\lib\net35\AgileObjects.ReadableExpressions.dll</HintPath>
+    <Reference Include="AgileObjects.ReadableExpressions, Version=2.1.0.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
+      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.1.0\lib\net35\AgileObjects.ReadableExpressions.dll</HintPath>
     </Reference>
     <Reference Include="Microsoft.Dynamic, Version=1.1.2.22, Culture=neutral, PublicKeyToken=7f709c5b713576e1, processorArchitecture=MSIL">
       <HintPath>..\packages\DynamicLanguageRuntime.1.1.2\lib\Net35\Microsoft.Dynamic.dll</HintPath>

AgileMapper.UnitTests.Net35/packages.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="AgileObjects.NetStandardPolyfills" version="1.4.0" targetFramework="net35" />
-  <package id="AgileObjects.ReadableExpressions" version="2.0.0" targetFramework="net35" />
+  <package id="AgileObjects.ReadableExpressions" version="2.1.0" targetFramework="net35" />
   <package id="DynamicLanguageRuntime" version="1.1.2" targetFramework="net35" />
   <package id="NUnit" version="3.6.1" targetFramework="net35" />
   <package id="NUnit3TestAdapter" version="3.10.0" targetFramework="net35" />

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

@@ -42,8 +42,8 @@
     <Reference Include="AgileObjects.NetStandardPolyfills, Version=1.4.0.0, Culture=neutral, PublicKeyToken=06131ac1c008ad4e, processorArchitecture=MSIL">
       <HintPath>..\packages\AgileObjects.NetStandardPolyfills.1.4.0\lib\net40\AgileObjects.NetStandardPolyfills.dll</HintPath>
     </Reference>
-    <Reference Include="AgileObjects.ReadableExpressions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
-      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.0.0\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
+    <Reference Include="AgileObjects.ReadableExpressions, Version=2.1.0.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
+      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.1.0\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -75,6 +75,7 @@
       <Link>VersionInfo.cs</Link>
     </Compile>
     <Compile Include="Configuration\Inline\WhenConfiguringDataSourcesInline.cs" />
+    <Compile Include="Configuration\Inline\WhenConfiguringDerivedTypesInline.cs" />
     <Compile Include="Configuration\WhenApplyingMapperConfigurations.cs" />
     <Compile Include="Configuration\WhenApplyingMapperConfigurationsIncorrectly.cs" />
     <Compile Include="Configuration\WhenConfiguringDataSources.cs" />

AgileMapper.UnitTests.NonParallel/Configuration/Inline/WhenConfiguringDerivedTypesInline.cs

@@ -0,0 +1,26 @@
+namespace AgileObjects.AgileMapper.UnitTests.NonParallel.Configuration.Inline
+{
+    using Common;
+    using MoreTestClasses;
+    using NetStandardPolyfills;
+    using TestClasses;
+    using Xunit;
+
+    public class WhenConfiguringDerivedTypesInline : NonParallelTestsBase
+    {
+        [Fact]
+        public void ShouldScanConfiguredAssembliesInline()
+        {
+            TestThenReset(() =>
+            {
+                var result = Mapper
+                    .Map(new { NumberOfLegs = 100, SlitherNoise = "ththtth" })
+                    .Over(new Earthworm() as AnimalBase, cgf => cgf
+                        .LookForDerivedTypesIn(typeof(Dog).GetAssembly(), typeof(Earthworm).GetAssembly()));
+
+                result.NumberOfLegs.ShouldBe(100);
+                ((Earthworm)result).SlitherNoise.ShouldBe("ththtth");
+            });
+        }
+    }
+}

AgileMapper.UnitTests.NonParallel/Configuration/WhenConfiguringDerivedTypes.cs

@@ -2,13 +2,14 @@
 {
     using Common;
     using MoreTestClasses;
+    using NetStandardPolyfills;
     using TestClasses;
     using Xunit;
 
     public class WhenConfiguringDerivedTypes : NonParallelTestsBase
     {
         [Fact]
-        public void ShouldScanConfiguredAssemblies()
+        public void ShouldScanConfiguredAssembliesViaTheStaticApi()
         {
             TestThenReset(() =>
             {
@@ -30,5 +31,57 @@ public void ShouldScanConfiguredAssemblies()
                 ((Earthworm)wormResult).SlitherNoise.ShouldBe("sssSSS");
             });
         }
+
+        [Fact]
+        public void ShouldScanConfiguredAssembliesViaTheInstanceApi()
+        {
+            TestThenReset(() =>
+            {
+                using (var mapper = Mapper.CreateNew())
+                {
+                    mapper.WhenMapping
+                        .LookForDerivedTypesIn(typeof(Dog).GetAssembly(), typeof(Earthworm).GetAssembly());
+
+                    var result = mapper
+                        .Map(new { NumberOfLegs = 1000, SlitherNoise = "thththtth" })
+                        .Over(new Earthworm() as AnimalBase);
+
+                    result.NumberOfLegs.ShouldBe(1000);
+                    ((Earthworm)result).SlitherNoise.ShouldBe("thththtth");
+                }
+            });
+        }
+
+        [Fact]
+        public void ShouldSetAssembliesToScanGlobally()
+        {
+            TestThenReset(() =>
+            {
+                using (var mapper1 = Mapper.CreateNew())
+                using (var mapper2 = Mapper.CreateNew())
+                {
+                    // Set assembly scanning on mapper1...
+                    mapper1.WhenMapping
+                        .LookForDerivedTypesIn(typeof(Dog).GetAssembly(), typeof(Earthworm).GetAssembly());
+
+                    // ...use mapper2 to cache the assembly scan results... 
+                    var result1 = mapper2
+                        .Map(new { NumberOfLegs = 4, WoofSound = "AWESOME" })
+                        .OnTo(new Dog() as AnimalBase);
+
+                    result1.NumberOfLegs.ShouldBe(4);
+                    ((Dog)result1).WoofSound.ShouldBe("AWESOME");
+
+                    // ...use mapper1 with a type outside the base type's assembly;
+                    // assemblies are cached globally, so the scan settings should be too:
+                    var result2 = mapper1
+                        .Map(new { NumberOfLegs = 100, SlitherNoise = "SLITHERRR" })
+                        .OnTo(new Earthworm() as AnimalBase);
+
+                    result2.NumberOfLegs.ShouldBe(100);
+                    ((Earthworm)result2).SlitherNoise.ShouldBe("SLITHERRR");
+                }
+            });
+        }
     }
 }

AgileMapper.UnitTests.NonParallel/packages.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="AgileObjects.NetStandardPolyfills" version="1.4.0" targetFramework="net461" />
-  <package id="AgileObjects.ReadableExpressions" version="2.0.0" targetFramework="net461" />
+  <package id="AgileObjects.ReadableExpressions" version="2.1.0" targetFramework="net461" />
   <package id="xunit" version="2.4.1" targetFramework="net461" />
   <package id="xunit.abstractions" version="2.0.3" targetFramework="net461" />
   <package id="xunit.analyzers" version="0.10.0" targetFramework="net461" />

AgileMapper.UnitTests/AgileMapper.UnitTests.csproj

@@ -44,8 +44,8 @@
     <Reference Include="AgileObjects.NetStandardPolyfills, Version=1.4.0.0, Culture=neutral, PublicKeyToken=06131ac1c008ad4e, processorArchitecture=MSIL">
       <HintPath>..\packages\AgileObjects.NetStandardPolyfills.1.4.0\lib\net40\AgileObjects.NetStandardPolyfills.dll</HintPath>
     </Reference>
-    <Reference Include="AgileObjects.ReadableExpressions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
-      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.0.0\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
+    <Reference Include="AgileObjects.ReadableExpressions, Version=2.1.0.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
+      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.1.0\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
     </Reference>
     <Reference Include="Microsoft.Extensions.Primitives, Version=2.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.Extensions.Primitives.2.0.0\lib\netstandard2.0\Microsoft.Extensions.Primitives.dll</HintPath>

AgileMapper.UnitTests/Configuration/Inline/WhenConfiguringDataSourcesInlineIncorrectly.cs

@@ -28,7 +28,7 @@ public void ShouldErrorIfUnconvertibleConstantSpecifiedInline()
                 }
             });
 
-            inlineConfigEx.Message.ShouldContain("Unable to convert configured decimal? ");
+            inlineConfigEx.Message.ShouldContain("Unable to convert configured 'decimal?' ");
         }
 
         [Fact]

AgileMapper.UnitTests/Configuration/Inline/WhenConfiguringDerivedTypesInline.cs

@@ -2,8 +2,6 @@
 {
     using System.Linq;
     using Common;
-    using MoreTestClasses;
-    using NetStandardPolyfills;
     using TestClasses;
 #if !NET35
     using Xunit;
@@ -112,20 +110,5 @@ public void ShouldMapACustomTypePairInACollectionInline()
                 mapper.InlineContexts().Count.ShouldBe(2);
             }
         }
-
-        [Fact]
-        public void ShouldScanConfiguredAssembliesInline()
-        {
-            using (var mapper = Mapper.CreateNew())
-            {
-                var result = mapper
-                    .Map(new { NumberOfLegs = 100, SlitherNoise = "ththtth" })
-                    .Over(new Earthworm() as AnimalBase, cgf => cgf
-                        .LookForDerivedTypesIn(typeof(Dog).GetAssembly(), typeof(Earthworm).GetAssembly()));
-
-                result.NumberOfLegs.ShouldBe(100);
-                ((Earthworm)result).SlitherNoise.ShouldBe("ththtth");
-            }
-        }
     }
 }

AgileMapper.UnitTests/Configuration/WhenConfiguringDataSources.cs

@@ -148,6 +148,92 @@ public void ShouldApplyMultipleConfiguredMembersBySourceType()
             }
         }
 
+        // See https://github.com/agileobjects/AgileMapper/issues/111
+        [Fact]
+        public void ShouldConditionallyApplyAToTargetConfiguredSimpleTypeConstant()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<string>().ToANew<string>()
+                    .If(ctx => string.IsNullOrEmpty(ctx.Source))
+                    .Map(default(string)).ToTarget();
+
+                var source = new Address { Line1 = "Here", Line2 = string.Empty };
+                var result = mapper.Map(source).ToANew<Address>();
+
+                result.Line1.ShouldBe("Here");
+                result.Line2.ShouldBeNull();
+            }
+        }
+
+        [Fact]
+        public void ShouldApplyAToTargetConfiguredSimpleTypeConstant()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<string>().ToANew<string>()
+                    .Map((s, t) => string.IsNullOrEmpty(s) ? null : s).ToTarget();
+
+                var source = new Address { Line1 = "There", Line2 = string.Empty };
+                var result = mapper.Map(source).ToANew<Address>();
+
+                result.Line1.ShouldBe("There");
+                result.Line2.ShouldBeNull();
+            }
+        }
+
+        [Fact]
+        public void ShouldConditionallyApplyAToTargetConfiguredNestedSimpleTypeExpression()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<int>().ToANew<int>()
+                    .If(ctx => ctx.Source % 2 == 0)
+                    .Map(ctx => ctx.Source * 2).ToTarget();
+
+                var nonMatchingSource = new { ValueValue = 3 };
+                var nonMatchingResult = mapper.Map(nonMatchingSource).ToANew<PublicField<PublicField<int>>>();
+
+                nonMatchingResult.Value.ShouldNotBeNull();
+                nonMatchingResult.Value.Value.ShouldBe(3);
+
+                var matchingSource = new { ValueValue = 4 };
+                var matchingResult = mapper.Map(matchingSource).ToANew<PublicField<PublicField<int>>>();
+
+                matchingResult.Value.ShouldNotBeNull();
+                matchingResult.Value.Value.ShouldBe(8);
+            }
+        }
+
+        [Fact]
+        public void ShouldConditionallyApplyAToTargetConfiguredSimpleTypeExpressionInAComplexTypeList()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<int>().ToANew<int>()
+                    .If((s, t) => s % 2 == 0)
+                    .Map(ctx => ctx.Source * 2).ToTarget();
+
+                var source = new PublicField<List<PublicField<int>>>
+                {
+                    Value = new List<PublicField<int>>
+                    {
+                        new PublicField<int> { Value = 1 },
+                        new PublicField<int> { Value = 2 },
+                        new PublicField<int> { Value = 3 }
+                    }
+                };
+                var result = mapper.Map(source).ToANew<PublicField<List<PublicField<int>>>>();
+
+                result.Value.ShouldNotBeNull();
+                result.Value.ShouldBe(pf => pf.Value, 1, 4, 3);
+            }
+        }
+
         [Fact]
         public void ShouldConditionallyApplyAConfiguredMember()
         {
@@ -740,6 +826,62 @@ public void ShouldApplyAConfiguredComplexTypeEnumerableConditionally()
             }
         }
 
+        // See https://github.com/agileobjects/AgileMapper/issues/113
+        [Fact]
+        public void ShouldApplyAConfiguredComplexToSimpleTypeEnumerableProjection()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<PublicField<PublicField<int>[]>>()
+                    .To<PublicField<int[]>>()
+                    .Map(
+                        pfpfi => pfpfi.Value.Select(v => v.Value),
+                        pfi => pfi.Value);
+
+                var source = new PublicField<PublicField<int>[]>
+                {
+                    Value = new[]
+                    {
+                        new PublicField<int> { Value = 1 },
+                        new PublicField<int> { Value = 2 },
+                        new PublicField<int> { Value = 3 }
+                    }
+                };
+
+                var result = mapper.Map(source).ToANew<PublicField<int[]>>();
+
+                result.Value.ShouldNotBeEmpty();
+                result.Value.ShouldBe(1, 2, 3);
+            }
+        }
+
+        // See https://github.com/agileobjects/AgileMapper/issues/113
+        [Fact]
+        public void ShouldApplyAConfiguredComplexToSimpleTypeEnumerableProjectionToTheRootTarget()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<PublicField<int>[]>()
+                    .To<int[]>()
+                    .Map(ctx => ctx.Source.Select(v => v.Value))
+                    .ToTarget();
+
+                var source = new[]
+                {
+                    new PublicField<int> { Value = 1 },
+                    new PublicField<int> { Value = 2 },
+                    new PublicField<int> { Value = 3 }
+                };
+
+                var result = mapper.Map(source).ToANew<int[]>();
+
+                result.ShouldNotBeEmpty();
+                result.ShouldBe(1, 2, 3);
+            }
+        }
+
         [Fact]
         public void ShouldApplyAConfiguredSourceAndTargetFunction()
         {