Todo cleanup (#28)

* Increasing test coverage, re: invalid source member specification / Removing completed TODO

* Replacing uses of Linq Concat

* Test coverage for specifying an un-string-formatable source type

* Increasing test coverage, re: ICollection.ToArray extension method

* Moving class to a dedicated file

* Support for mapping from complex type members to matching-type dictionary entries / Supplying capacities for Expression replacement dictionaries

Author: SteveWilkes

AgileMapper.UnitTests/Configuration/WhenConfiguringStringFormatting.cs

@@ -68,5 +68,20 @@ public void ShouldErrorIfNoFormatSpecified()
 
             noFormatEx.Message.ShouldContain("No format string specified");
         }
+
+        [Fact]
+        public void ShouldErrorIfUnformattableTypeSpecified()
+        {
+            var noFormatEx = Should.Throw<MappingConfigurationException>(() =>
+            {
+                using (var mapper = Mapper.CreateNew())
+                {
+                    mapper.WhenMapping
+                        .StringsFrom<PublicField<string>>(c => c.FormatUsing("xxx"));
+                }
+            });
+
+            noFormatEx.Message.ShouldContain("No ToString method");
+        }
     }
 }

AgileMapper.UnitTests/Dictionaries/Configuration/WhenConfiguringDictionaryMappingIncorrectly.cs

@@ -1,5 +1,6 @@
 namespace AgileObjects.AgileMapper.UnitTests.Dictionaries.Configuration
 {
+    using System;
     using AgileMapper.Configuration;
     using Shouldly;
     using TestClasses;
@@ -131,6 +132,32 @@ public void ShouldErrorIfCustomDataSourceMemberIsGivenCustomMemberName()
             configEx.Message.ShouldContain("has a configured data source");
         }
 
+        [Fact]
+        public void ShouldErrorIfAnInvalidSourceMemberIsSpecified()
+        {
+            var configEx = Should.Throw<NotSupportedException>(() =>
+                Mapper.WhenMapping
+                    .From<PublicField<string>>()
+                    .ToDictionaries
+                    .MapMember(pf => pf.Value + "!")
+                    .ToFullKey("That won't work"));
+
+            configEx.Message.ShouldContain("Unable to get member access");
+        }
+
+        [Fact]
+        public void ShouldErrorIfAnUnreadableSourceMemberIsSpecified()
+        {
+            var configEx = Should.Throw<MappingConfigurationException>(() =>
+                Mapper.WhenMapping
+                    .From<PublicWriteOnlyProperty<string>>()
+                    .ToDictionaries
+                    .MapMember(pf => pf.Value)
+                    .ToFullKey("That won't work"));
+
+            configEx.Message.ShouldContain("is not readable");
+        }
+
         [Fact]
         public void ShouldErrorIfMemberNamesAreFlattenedAndSeparatedGlobally()
         {

AgileMapper.UnitTests/Dictionaries/WhenMappingToNewDictionaries.cs

@@ -28,6 +28,16 @@ public void ShouldMapASimpleTypeMemberToATypedDictionary()
             result["Value"].ShouldBe(int.MaxValue);
         }
 
+        [Fact]
+        public void ShouldMapAComplexTypeMemberToATypedDictionary()
+        {
+            var source = new PublicProperty<Product> { Value = new Product { ProductId = "xxx" } };
+            var result = Mapper.Map(source).ToANew<Dictionary<string, Product>>();
+
+            result.ContainsKey("Value").ShouldBeTrue();
+            result["Value"].ShouldBeOfType<Product>();
+        }
+
         [Fact]
         public void ShouldMapASimpleTypeMemberToAConvertibleTypedDictionary()
         {

AgileMapper.UnitTests/WhenMappingOverEnumerableMembers.cs

@@ -54,7 +54,7 @@ public void ShouldOverwriteAnArray()
         [Fact]
         public void ShouldOverwriteAReadOnlyCollection()
         {
-            var source = new PublicProperty<IEnumerable<decimal>>
+            var source = new PublicProperty<ICollection<decimal>>
             {
                 Value = new[] { MinValue, MaxValue }
             };

AgileMapper/Api/Configuration/Dictionaries/DictionaryMappingConfigContinuation.cs

@@ -16,7 +16,6 @@ public DictionaryMappingConfigContinuation(MappingConfigInfo configInfo)
         ISourceDictionaryMappingConfigurator<TFirst, TSecond> ISourceDictionaryMappingConfigContinuation<TFirst, TSecond>.And
             => new SourceDictionaryMappingConfigurator<TFirst, TSecond>(_configInfo.Clone());
 
-        // TODO: Code coverage
         ITargetDictionaryMappingConfigurator<TFirst, TSecond> ITargetDictionaryMappingConfigContinuation<TFirst, TSecond>.And
             => new TargetDictionaryMappingConfigurator<TFirst, TSecond>(_configInfo.Clone());
     }

AgileMapper/Api/Configuration/Dictionaries/TargetDictionaryMappingConfigurator.cs

@@ -58,7 +58,6 @@ private QualifiedMember GetSourceMemberOrThrow(LambdaExpression lambda)
                 return sourceMember;
             }
 
-            // TODO: test coverage - invalid source member expression
             throw new MappingConfigurationException(
                 $"Source member {lambda.Body.ToReadableString()} is not readable.");
         }

AgileMapper/Configuration/DerivedTypePairSet.cs

@@ -13,7 +13,7 @@
     internal class DerivedTypePairSet
     {
         private static readonly object _lookupSync = new object();
-        private static readonly DerivedTypePair[] _noPairs = Enumerable<DerivedTypePair>.EmptyArray;
+
         private readonly Dictionary<Type, List<DerivedTypePair>> _typePairsByTargetType;
         private readonly List<SourceAndTargetTypesKey> _autoCheckedTypes;
 
@@ -64,23 +64,23 @@ private static void RemoveConflictingPairIfAppropriate(
             }
         }
 
-        public ICollection<DerivedTypePair> GetDerivedTypePairsFor(
+        public IList<DerivedTypePair> GetDerivedTypePairsFor(
             IBasicMapperData mapperData,
             MapperContext mapperContext)
         {
             LookForDerivedTypePairs(mapperData, mapperContext);
 
             if (_typePairsByTargetType.None())
             {
-                return _noPairs;
+                return Enumerable<DerivedTypePair>.EmptyArray;
             }
 
             if (_typePairsByTargetType.TryGetValue(mapperData.TargetType, out var typePairs))
             {
                 return typePairs.Where(tp => tp.AppliesTo(mapperData)).ToArray();
             }
 
-            return _noPairs;
+            return Enumerable<DerivedTypePair>.EmptyArray;
         }
 
         #region Auto-Registration

AgileMapper/Configuration/ParametersSwapper.cs

@@ -97,7 +97,7 @@ private static Expression SwapForContextParameter(SwapArgs swapArgs)
             var indexProperty = memberContextType.GetPublicInstanceProperty("EnumerableIndex");
             var parentProperty = memberContextType.GetPublicInstanceProperty("Parent");
 
-            var replacementsByTarget = new ExpressionReplacementDictionary
+            var replacementsByTarget = new ExpressionReplacementDictionary(5)
             {
                 [Expression.Property(contextParameter, sourceProperty)] = contextInfo.SourceAccess,
                 [Expression.Property(contextParameter, targetProperty)] = contextInfo.TargetAccess,

AgileMapper/Constants.cs

@@ -13,8 +13,6 @@ internal static class Constants
     {
         public static readonly bool ReflectionNotPermitted = ReflectionExtensions.ReflectionNotPermitted;
 
-        public static readonly string[] EmptyStringArray = Enumerable<string>.EmptyArray;
-
         public static readonly string EnumerableElementName = "[i]";
 
         public static readonly Type[] NoTypeArguments = Enumerable<Type>.EmptyArray;
@@ -54,8 +52,7 @@ internal static class Constants
         };
 
         public static readonly Type[] NumericTypes = WholeNumberNumericTypes
-            .Concat(typeof(float), typeof(decimal), typeof(double))
-            .ToArray();
+            .Append(typeof(float), typeof(decimal), typeof(double));
 
         public static readonly IDictionary<Type, double> NumericTypeMaxValuesByType = GetValuesByType("MaxValue");
         public static readonly IDictionary<Type, double> NumericTypeMinValuesByType = GetValuesByType("MinValue");

AgileMapper/DataSources/DataSourceBase.cs

@@ -44,8 +44,8 @@ protected DataSourceBase(
             ProcessMemberAccesses(
                 mapperData,
                 ref value,
-                out IList<Expression> nestedAccesses,
-                out ICollection<ParameterExpression> variables);
+                out var nestedAccesses,
+                out var variables);
 
             Condition = nestedAccesses.GetIsNotDefaultComparisonsOrNull();
             Variables = variables;
@@ -58,7 +58,7 @@ private static void ProcessMemberAccesses(
             IMemberMapperData mapperData,
             ref Expression value,
             out IList<Expression> nestedAccesses,
-            out ICollection<ParameterExpression> variables)
+            out IList<ParameterExpression> variables)
         {
             var valueInfo = mapperData.GetExpressionInfoFor(value, targetCanBeNull: false);
             nestedAccesses = valueInfo.NestedAccesses;
@@ -69,22 +69,24 @@ private static void ProcessMemberAccesses(
                 return;
             }
 
-            variables = new List<ParameterExpression>();
-            var cacheVariablesByValue = new Dictionary<Expression, Expression>();
-            var valueExpressions = new List<Expression>(valueInfo.MultiInvocations.Count + 1);
+            var numberOfInvocations = valueInfo.MultiInvocations.Count;
+            variables = new ParameterExpression[numberOfInvocations];
+            var cacheVariablesByValue = new Dictionary<Expression, Expression>(numberOfInvocations);
+            var valueExpressions = new Expression[numberOfInvocations + 1];
 
-            foreach (var invocation in valueInfo.MultiInvocations)
+            for (var i = 0; i < numberOfInvocations; i++)
             {
+                var invocation = valueInfo.MultiInvocations[i];
                 var valueVariableName = invocation.Type.GetFriendlyName().ToCamelCase() + "Value";
                 var valueVariable = Expression.Variable(invocation.Type, valueVariableName);
                 var valueVariableValue = invocation.Replace(cacheVariablesByValue);
 
                 cacheVariablesByValue.Add(invocation, valueVariable);
-                variables.Add(valueVariable);
-                valueExpressions.Add(valueVariable.AssignTo(valueVariableValue));
+                variables[i] = valueVariable;
+                valueExpressions[i] = valueVariable.AssignTo(valueVariableValue);
             }
 
-            valueExpressions.Add(value.Replace(cacheVariablesByValue));
+            valueExpressions[numberOfInvocations] = value.Replace(cacheVariablesByValue);
             value = Expression.Block(valueExpressions);
         }