- checkpoint: Move converter registration to mapping module

Author: NinjaRocks

README.md

@@ -81,7 +81,7 @@ Please see [Release Roadmap](https://github.com/CodeShayk/TurboMapper/blob/maste
 - **Performance Improvements**: Significant performance enhancements (2x+) through compiled expression trees and metadata caching
 - **Enhanced Collection Mapping**: Simplified API with Map method now supporting both single objects and collections
 - **Ignored Properties Option**: Added Ignore method to IMappingExpression to skip properties during mapping
-- **Custom Type Converters Registration**: Added RegisterConverter method to IMapper for custom type conversion functions
+- **Custom Type Converters Registration**: Added RegisterConverter method to MappingModule for custom type conversion functions that can be registered with type mappings
 - **Improved Nullable Type Handling**: Enhanced ConvertValue method to handle nullable types properly
 - **Conditional Mapping**: Added When method to IMappingExpression for conditional property mapping
 - **Mapping Transformations**: Added MapWith method for transformation functions during mapping

src/TurboMapper/IMapper.cs

@@ -7,7 +7,6 @@ public interface IMapper
     {
         TTarget Map<TSource, TTarget>(TSource source);
         IEnumerable<TDestination> Map<TSource, TDestination>(IEnumerable<TSource> source);
-        void RegisterConverter<TSource, TDestination>(Func<TSource, TDestination> converter);
         bool ValidateMapping<TSource, TTarget>();
         string[] GetMappingErrors<TSource, TTarget>();
     }

src/TurboMapper/IObjectMap.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 
 namespace TurboMapper
@@ -7,5 +8,7 @@ internal interface IObjectMap
         void CreateMap<TSource, TTarget>(List<PropertyMapping> mappings = null);
 
         void CreateMap<TSource, TTarget>(List<PropertyMapping> mappings, bool enableDefaultMapping);
+        
+        void RegisterConverter<TSource, TDestination>(Func<TSource, TDestination> converter);
     }
 }

src/TurboMapper/Impl/Mapper.cs

@@ -157,6 +157,12 @@ internal void ApplyCustomMappingsWithDefaultDisabled<TSource, TTarget>(
             }
         }
 
+        public void RegisterConverter<TSource, TDestination>(Func<TSource, TDestination> converter)
+        {
+            var key = $"{typeof(TSource).FullName}_{typeof(TDestination).FullName}";
+            _converters[key] = converter;
+        }
+
         private void ApplyDefaultNameBasedMapping<TSource, TTarget>(
             TSource source,
             TTarget target,
@@ -195,12 +201,6 @@ private bool IsIgnoredInCustomMappings(string targetPropertyName, List<PropertyM
         // Custom converter system
         private readonly Dictionary<string, Delegate> _converters = new Dictionary<string, Delegate>();
 
-        public void RegisterConverter<TSource, TDestination>(Func<TSource, TDestination> converter)
-        {
-            var key = $"{typeof(TSource).FullName}_{typeof(TDestination).FullName}";
-            _converters[key] = converter;
-        }
-
         public bool ValidateMapping<TSource, TTarget>()
         {
             var errors = GetMappingErrors<TSource, TTarget>();

src/TurboMapper/MappingModule.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 
 namespace TurboMapper
@@ -7,11 +8,13 @@ public abstract class MappingModule<TSource, TTarget> : IMappingModule
     {
         private readonly Action<MappingExpression<TSource, TTarget>> _configAction;
         private readonly bool _enableDefaultMapping;
+        private readonly Dictionary<string, Delegate> _converters;
 
         public MappingModule(bool enableDefaultMapping = true)
         {
             _configAction = CreateMappings();
             _enableDefaultMapping = enableDefaultMapping;
+            _converters = new Dictionary<string, Delegate>();
         }
 
         void IMappingModule.CreateMap(IObjectMap mapper)
@@ -51,8 +54,59 @@ void IMappingModule.CreateMap(IObjectMap mapper)
             }
 
             mapper.CreateMap<TSource, TTarget>(expression.Mappings, _enableDefaultMapping);
+
+            // Register converters with the mapper if any were defined in this module
+            RegisterConverters(mapper);
         }
 
         public abstract Action<IMappingExpression<TSource, TTarget>> CreateMappings();
+
+        /// <summary>
+        /// Registers a custom converter for type mappings within this module
+        /// </summary>
+        /// <typeparam name="TSourceConverter">Source type</typeparam>
+        /// <typeparam name="TDestination">Destination type</typeparam>
+        /// <param name="converter">Function to perform the conversion</param>
+        protected void RegisterConverter<TSourceConverter, TDestination>(Func<TSourceConverter, TDestination> converter)
+        {
+            var key = $"{typeof(TSourceConverter).FullName}_{typeof(TDestination).FullName}";
+            _converters[key] = converter;
+        }
+
+        private void RegisterConverters(IObjectMap mapper)
+        {
+            foreach (var kvp in _converters)
+            {
+                var converter = kvp.Value as Delegate;
+                if (converter != null)
+                {
+                    var sourceType = converter.Method.GetParameters()[0].ParameterType;
+                    var destType = converter.Method.ReturnType;
+                    
+                    // Find and invoke the RegisterConverter method with proper type parameters
+                    var method = mapper.GetType().GetMethod("RegisterConverter", 
+                        System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance,
+                        null, 
+                        new Type[] { converter.GetType() }, 
+                        null);
+                    
+                    if (method == null)
+                    {
+                        // Try to get the generic method and make it specific
+                        var genericMethod = mapper.GetType().GetMethod("RegisterConverter",
+                            System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
+                        if (genericMethod != null && genericMethod.IsGenericMethod)
+                        {
+                            var specificMethod = genericMethod.MakeGenericMethod(sourceType, destType);
+                            specificMethod.Invoke(mapper, new object[] { converter });
+                        }
+                    }
+                    else
+                    {
+                        method.Invoke(mapper, new object[] { converter });
+                    }
+                }
+            }
+        }
     }
 }

tests/TurboMapper.Tests/Release120_Tests.cs

@@ -141,17 +141,43 @@ public void Task3_4_IgnoredPropertiesOption()
         [Test]
         public void Task5_1_CustomTypeConvertersRegistration()
         {
+            // Create a mapping from string to int using converter registered in module
+            var converterModule = new StringToIntConverterModule();
             var mapper = new Mapper();
-
-            // Register a custom converter
-            mapper.RegisterConverter<string, int>(s => int.Parse(s));
-            mapper.RegisterConverter<int, string>(i => i.ToString());
-
-            // Verify the converter is registered by trying a simple conversion
-            // Note: This test may need adjustment based on how the converter system is fully implemented
-            var convertersExist = true; // Placeholder - actual test would check internal state
-
-            Assert.IsTrue(convertersExist);
+            
+            // Register the module which will register the string to int converter
+            ((IMappingModule)converterModule).CreateMap(mapper);
+            
+            // Test that a string value can be converted to int through the registered converter
+            var source = new StringValueClass { Number = "42" };
+            var result = mapper.Map<StringValueClass, IntValueClass>(source);
+            
+            Assert.AreEqual(42, result.Number);
+        }
+        
+        // Test module for converter registration
+        public class StringToIntConverterModule : MappingModule<StringValueClass, IntValueClass>
+        {
+            public StringToIntConverterModule() : base(true) // Enable default mapping for this test
+            {
+                // Register converter within the module
+                RegisterConverter<string, int>(s => int.Parse(s));
+            }
+            
+            public override Action<IMappingExpression<StringValueClass, IntValueClass>> CreateMappings()
+            {
+                return expression => { };
+            }
+        }
+        
+        public class StringValueClass
+        {
+            public string Number { get; set; }
+        }
+        
+        public class IntValueClass
+        {
+            public int Number { get; set; }
         }
 
         [Test]