Removing mapping plan enum mismatch warnings if enum pairs are configured

Author: SteveWilkes

AgileMapper.UnitTests/Configuration/WhenConfiguringEnumMapping.cs

@@ -28,6 +28,22 @@ public void ShouldPairEnumMembers()
             }
         }
 
+        [Fact]
+        public void ShouldRemovePairedEnumsFromEnumMismatchWarnings()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .PairEnum(PaymentTypeUk.Cheque).With(PaymentTypeUs.Check);
+
+                var plan = mapper
+                    .GetPlanFor<PublicTwoFields<PaymentTypeUk, PaymentTypeUs>>()
+                    .OnTo<PublicTwoFields<PaymentTypeUs, PaymentTypeUk>>();
+
+                plan.ShouldNotContain("WARNING");
+            }
+        }
+
         [Fact]
         public void ShouldErrorIfSourceValueIsNotAnEnum()
         {

AgileMapper/Api/Configuration/EnumPairSpecifier.cs

@@ -55,8 +55,14 @@ public MappingConfigContinuation<object, object> With<TSecondEnum>(TSecondEnum s
             ThrowIfNotEnumType<TSecondEnum>();
             ThrowIfSameTypes<TSecondEnum>();
 
-            var enumPairing = EnumMemberPair.For(_configInfo, _firstEnumMember, secondEnumMember);
-            _configInfo.MapperContext.UserConfigurations.Add(enumPairing);
+            var firstToSecondPairing = EnumMemberPair.For(_firstEnumMember, secondEnumMember);
+            var secondToFirstPairing = EnumMemberPair.For(secondEnumMember, _firstEnumMember);
+
+            _configInfo.MapperContext.ValueConverters.Add(firstToSecondPairing.ValueConverter);
+            _configInfo.MapperContext.ValueConverters.Add(secondToFirstPairing.ValueConverter);
+
+            _configInfo.MapperContext.UserConfigurations.Add(firstToSecondPairing);
+            _configInfo.MapperContext.UserConfigurations.Add(secondToFirstPairing);
 
             return new MappingConfigContinuation<object, object>(_configInfo);
         }

AgileMapper/Configuration/EnumMemberPair.cs

@@ -1,45 +1,55 @@
 namespace AgileObjects.AgileMapper.Configuration
 {
+    using System;
     using System.Linq.Expressions;
     using TypeConversion;
 
-    internal class EnumMemberPair : UserConfiguredItemBase
+    internal class EnumMemberPair
     {
-        private readonly object _firstEnumMember;
-        private readonly object _secondEnumMember;
+        private readonly Type _firstEnumType;
+        private readonly Type _secondEnumType;
 
         public EnumMemberPair(
-            MappingConfigInfo configInfo,
-            object firstEnumMember,
-            object secondEnumMember)
-            : base(configInfo)
+            Type firstEnumType,
+            string firstEnumMemberName,
+            Type secondEnumType,
+            string secondEnumMemberName,
+            IValueConverter valueConverter)
         {
-            _firstEnumMember = firstEnumMember;
-            _secondEnumMember = secondEnumMember;
+            FirstEnumMemberName = firstEnumMemberName;
+            SecondEnumMemberName = secondEnumMemberName;
+            ValueConverter = valueConverter;
+            _firstEnumType = firstEnumType;
+            _secondEnumType = secondEnumType;
         }
 
         public static EnumMemberPair For<TFirstEnum, TSecondEnum>(
-            MappingConfigInfo configInfo,
             TFirstEnum firstEnumMember,
             TSecondEnum secondEnumMember)
         {
             var firstValue = Expression.Constant(firstEnumMember, typeof(TFirstEnum));
             var secondValue = Expression.Constant(secondEnumMember, typeof(TSecondEnum));
 
-            var firstToSecondValueConverter = new ConfiguredValueConverter(
+            var valueConverter = new ConfiguredValueConverter(
                 firstValue.Type,
                 secondValue,
                 (sourceValue, targetType) => Expression.Equal(sourceValue, firstValue));
 
-            var secondToFirstValueConverter = new ConfiguredValueConverter(
+            return new EnumMemberPair(
+                firstValue.Type,
+                firstEnumMember.ToString(),
                 secondValue.Type,
-                firstValue,
-                (sourceValue, targetType) => Expression.Equal(sourceValue, secondValue));
+                secondEnumMember.ToString(),
+                valueConverter);
+        }
 
-            configInfo.MapperContext.ValueConverters.Add(firstToSecondValueConverter);
-            configInfo.MapperContext.ValueConverters.Add(secondToFirstValueConverter);
+        public string FirstEnumMemberName { get; }
 
-            return new EnumMemberPair(configInfo, firstEnumMember, secondEnumMember);
-        }
+        public string SecondEnumMemberName { get; }
+
+        public IValueConverter ValueConverter { get; }
+
+        public bool IsFor(Type sourceEnumType, Type targetEnumType)
+            => (_firstEnumType == sourceEnumType) && (_secondEnumType == targetEnumType);
     }
 }

AgileMapper/Configuration/UserConfigurationSet.cs

@@ -14,6 +14,7 @@ internal class UserConfigurationSet
         private readonly ICollection<ObjectTrackingMode> _trackingModeSettings;
         private readonly ICollection<ConfiguredObjectFactory> _objectFactories;
         private readonly ICollection<ConfiguredIgnoredMember> _ignoredMembers;
+        private readonly ICollection<EnumMemberPair> _enumParings;
         private readonly ICollection<ConfiguredDataSourceFactory> _dataSourceFactories;
         private readonly ICollection<MappingCallbackFactory> _mappingCallbackFactories;
         private readonly ICollection<ObjectCreationCallbackFactory> _creationCallbackFactories;
@@ -25,6 +26,7 @@ public UserConfigurationSet()
             _objectFactories = new List<ConfiguredObjectFactory>();
             Identifiers = new MemberIdentifierSet();
             _ignoredMembers = new List<ConfiguredIgnoredMember>();
+            _enumParings = new List<EnumMemberPair>();
             _dataSourceFactories = new List<ConfiguredDataSourceFactory>();
             _mappingCallbackFactories = new List<MappingCallbackFactory>();
             _creationCallbackFactories = new List<ObjectCreationCallbackFactory>();
@@ -84,8 +86,11 @@ public ConfiguredIgnoredMember GetMemberIgnoreOrNull(IBasicMapperData mapperData
 
         public void Add(EnumMemberPair enumPairing)
         {
+            _enumParings.Add(enumPairing);
         }
 
+        public IEnumerable<EnumMemberPair> EnumParings => _enumParings;
+
         #endregion
 
         #region DataSources

AgileMapper/Plans/EnumMappingMismatchSet.cs

@@ -106,8 +106,9 @@ public static EnumMappingMismatch For(
             {
                 var mismatches = GetMappingMismatches(
                     sourceEnumType,
-                    targetEnumType.Name,
-                    targetEnumNames);
+                    targetEnumType,
+                    targetEnumNames,
+                    mapperData);
 
                 if (mismatches.None())
                 {
@@ -119,27 +120,54 @@ public static EnumMappingMismatch For(
 
             private static string[] GetMappingMismatches(
                 Type sourceEnumType,
-                string targetEnumTypeName,
-                string[] targetEnumNames)
+                Type targetEnumType,
+                string[] targetEnumNames,
+                IMemberMapperData mapperData)
             {
                 var sourceEnumNames = Enum.GetNames(sourceEnumType);
-                var unmatchedSourceValues = sourceEnumNames.Except(targetEnumNames).ToArray();
-                var unmatchedTargetValues = targetEnumNames.Except(sourceEnumNames).ToArray();
+                var unmatchedSourceValues = sourceEnumNames.Except(targetEnumNames).ToList();
+                var unmatchedTargetValues = targetEnumNames.Except(sourceEnumNames).ToList();
+
+                Filter(unmatchedSourceValues, unmatchedTargetValues, sourceEnumType, targetEnumType, mapperData);
 
                 if (unmatchedSourceValues.None() && unmatchedTargetValues.None())
                 {
                     return Constants.EmptyStringArray;
                 }
 
                 var unmatchedValues = unmatchedSourceValues
-                    .Select(value => $" - {sourceEnumType.Name}.{value} matches no {targetEnumTypeName}")
+                    .Select(value => $" - {sourceEnumType.Name}.{value} matches no {targetEnumType.Name}")
                     .Concat(unmatchedTargetValues
-                        .Select(value => $" - {targetEnumTypeName}.{value} is matched by no {sourceEnumType.Name}"))
+                        .Select(value => $" - {targetEnumType.Name}.{value} is matched by no {sourceEnumType.Name}"))
                     .ToArray();
 
                 return unmatchedValues;
             }
 
+            private static void Filter(
+                ICollection<string> unmatchedSourceValues,
+                ICollection<string> unmatchedTargetValues,
+                Type sourceEnumType,
+                Type targetEnumType,
+                IMemberMapperData mapperData)
+            {
+                var relevantEnumPairings = mapperData
+                    .MapperContext
+                    .UserConfigurations
+                    .EnumParings
+                    .Where(ep => ep.IsFor(sourceEnumType, targetEnumType));
+
+                foreach (var enumParing in relevantEnumPairings)
+                {
+                    if (unmatchedSourceValues.Contains(enumParing.FirstEnumMemberName) &&
+                        unmatchedTargetValues.Contains(enumParing.SecondEnumMemberName))
+                    {
+                        unmatchedSourceValues.Remove(enumParing.FirstEnumMemberName);
+                        unmatchedTargetValues.Remove(enumParing.SecondEnumMemberName);
+                    }
+                }
+            }
+
             #endregion
 
             public bool Any => Warning != null;