Add RegisterPopulator AutoMapping API

Author: mythz

src/ServiceStack.Text/AutoMappingUtils.cs

@@ -44,13 +44,22 @@ public static void IgnoreMapping(Type fromType, Type toType)
             JsConfig.InitStatics();
             AutoMappingUtils.ignoreMappings[Tuple.Create(fromType, toType)] = true;
         }
+
+        public static void RegisterPopulator<Target, Source>(Action<Target, Source> populator)
+        {
+            JsConfig.InitStatics();
+            AutoMappingUtils.populators[Tuple.Create(typeof(Target), typeof(Source))] = (a,b) => populator((Target)a,(Source)b);
+        }
     }
 
     public static class AutoMappingUtils
     {
         internal static readonly ConcurrentDictionary<Tuple<Type, Type>, GetMemberDelegate> converters
             = new ConcurrentDictionary<Tuple<Type, Type>, GetMemberDelegate>();
 
+        internal static readonly ConcurrentDictionary<Tuple<Type, Type>, PopulateMemberDelegate> populators
+            = new ConcurrentDictionary<Tuple<Type, Type>, PopulateMemberDelegate>();
+
         internal static readonly ConcurrentDictionary<Tuple<Type, Type>,bool> ignoreMappings
             = new ConcurrentDictionary<Tuple<Type, Type>,bool>();
 
@@ -60,9 +69,6 @@ public static void Reset()
             ignoreMappings.Clear();
             AssignmentDefinitionCache.Clear();
         }
-        
-        [Obsolete("Use AutoMapping.RegisterConverter")]
-        public static void RegisterConverter<From, To>(Func<From, To> converter) => throw new NotSupportedException("Deprecated: Use AutoMapping.RegisterConverter");
 
         public static bool ShouldIgnoreMapping(Type fromType, Type toType) =>
             ignoreMappings.ContainsKey(Tuple.Create(fromType, toType));
@@ -78,6 +84,17 @@ public static GetMemberDelegate GetConverter(Type fromType, Type toType)
                 : null;
         }
 
+        public static PopulateMemberDelegate GetPopulator(Type targetType, Type sourceType)
+        {
+            if (populators.IsEmpty)
+                return null;
+
+            var key = Tuple.Create(targetType, sourceType);
+            return populators.TryGetValue(key, out var populator)
+                ? populator
+                : null;
+        }
+
         public static T ConvertTo<T>(this object from, T defaultValue) =>
             from == null || (from is string s && s == string.Empty)
                 ? defaultValue
@@ -1175,12 +1192,17 @@ public void Populate(object to, object from,
                         ToType.FullName, toType.Name, ex);
                 }
             }
+
+            var populator = AutoMappingUtils.GetPopulator(to.GetType(), from.GetType());
+            populator?.Invoke(to, from);
         }
     }
 
     public delegate object GetMemberDelegate(object instance);
     public delegate object GetMemberDelegate<T>(T instance);
 
+    public delegate void PopulateMemberDelegate(object target, object source);
+
     public delegate void SetMemberDelegate(object instance, object value);
     public delegate void SetMemberDelegate<T>(T instance, object value);
     public delegate void SetMemberRefDelegate(ref object instance, object propertyValue);

src/ServiceStack.Text/Common/JsWriter.cs

@@ -42,7 +42,7 @@ static JsWriter()
             {
                 EscapeCharFlags[escapeChar] = true;
             }
-            var loadConfig = JsConfig.EmitCamelCaseNames; //force load
+            var loadConfig = JsConfig.TextCase; //force load
         }
 
         public static void WriteDynamic(Action callback)

tests/ServiceStack.Text.Tests/AutoMappingPopulatorTests.cs

@@ -0,0 +1,77 @@
+using NUnit.Framework;
+
+namespace ServiceStack.Text.Tests
+{
+    public class AutoMappingPopulatorTests
+    {
+        private static User CreateUser() =>
+            new User {
+                FirstName = "John",
+                LastName = "Doe",
+                Car = new Car {Name = "BMW X6", Age = 3}
+            };
+
+        private static UsersData CreateUserData()
+        {
+            var user = CreateUser();
+            return new UsersData {
+                Id = 1,
+                User = user,
+                UsersList = {user},
+                UsersMap = {{1, user}}
+            };
+        }
+
+        [Test]
+        public void Does_call_populator_for_PopulateWith()
+        {
+            AutoMapping.RegisterPopulator((UserDto target, User source) => 
+                target.LastName += "?!");
+
+            var user = CreateUser();
+            var dtoUser = new UserDto().PopulateWith(user);
+            
+            Assert.That(dtoUser.FirstName, Is.EqualTo(user.FirstName));
+            Assert.That(dtoUser.LastName, Is.EqualTo(user.LastName + "?!"));
+        }
+
+        [Test]
+        public void Does_call_populator_for_PopulateWithNonDefaultValues()
+        {
+            AutoMapping.RegisterPopulator((UserDto target, User source) => 
+                target.LastName += "?!");
+
+            var user = CreateUser();
+            var dtoUser = new UserDto().PopulateWithNonDefaultValues(user);
+            
+            Assert.That(dtoUser.FirstName, Is.EqualTo(user.FirstName));
+            Assert.That(dtoUser.LastName, Is.EqualTo(user.LastName + "?!"));
+        }
+
+        [Test]
+        public void Does_call_populator_for_PopulateFromPropertiesWithoutAttribute()
+        {
+            AutoMapping.RegisterPopulator((UserDto target, User source) => 
+                target.LastName += "?!");
+
+            var user = CreateUser();
+            var dtoUser = new UserDto().PopulateFromPropertiesWithoutAttribute(user, typeof(IgnoreAttribute));
+            
+            Assert.That(dtoUser.FirstName, Is.EqualTo(user.FirstName));
+            Assert.That(dtoUser.LastName, Is.EqualTo(user.LastName + "?!"));
+        }
+
+        [Test]
+        public void Does_call_populator_for_ConvertTo()
+        {
+            AutoMapping.RegisterPopulator((UserDto target, User source) => 
+                target.LastName += "?!");
+
+            var user = CreateUser();
+            var dtoUser = user.ConvertTo<UserDto>();
+            
+            Assert.That(dtoUser.FirstName, Is.EqualTo(user.FirstName));
+            Assert.That(dtoUser.LastName, Is.EqualTo(user.LastName + "?!"));
+        }
+    }
+}