Updating implementation to use a configuration action rather than a supplied object / Tweaking documentation and naming / Adding test

SteveWilkes · SteveWilkes · commit 1147aefae021 · 2017-07-11T18:03:14.000+01:00
diff --git a/ReadableExpressions.UnitTests/WhenTranslatingMemberAccesses.cs b/ReadableExpressions.UnitTests/WhenTranslatingMemberAccesses.cs
@@ -278,6 +278,16 @@ public void ShouldTranslateAMethodCallWithoutGenericArgumentIncluded()
             Assert.AreEqual("ip.SetFirst(str)", translated);
         }
 
+        [TestMethod]
+        public void ShouldTranslateAMethodCallWithRequestedGenericArgumentsIncluded()
+        {
+            Expression<Action<IndexedProperty, string>> setFirstItem = (ip, str) => ip.SetFirst(str);
+
+            var translated = setFirstItem.Body.ToReadableString(c => c.UseExplicitGenericParameters);
+
+            Assert.AreEqual("ip.SetFirst<string>(str)", translated);
+        }
+
         [TestMethod]
         public void ShouldTranslateAnOutParameterMethodCallWithoutGenericArgumentIncluded()
         {
diff --git a/ReadableExpressions/ExpressionExtensions.cs b/ReadableExpressions/ExpressionExtensions.cs
@@ -1,5 +1,6 @@
 ﻿namespace AgileObjects.ReadableExpressions
 {
+    using System;
     using System.Linq.Expressions;
 
     /// <summary>
@@ -13,12 +14,14 @@ public static class ExpressionExtensions
         /// Translates the given <paramref name="expression"/> to source-code string.
         /// </summary>
         /// <param name="expression">The Expression to translate.</param>
-        /// <param name="settings">Configuration options for the translation</param>
+        /// <param name="configuration">The configuration to use for the translation, if required.</param>
         /// <returns>The translated <paramref name="expression"/>.</returns>
-        public static string ToReadableString(this Expression expression, ReadableStringSettings settings = null)
+        public static string ToReadableString(
+            this Expression expression, 
+            Func<TranslationSettings, TranslationSettings> configuration = null)
         {
             return _translatorRegistry
-                .Translate(expression, settings ?? new ReadableStringSettings())?
+                .Translate(expression, configuration)?
                 .WithoutUnindents();
         }
     }
diff --git a/ReadableExpressions/ExpressionTranslatorRegistry.cs b/ReadableExpressions/ExpressionTranslatorRegistry.cs
@@ -1,5 +1,6 @@
 ﻿namespace AgileObjects.ReadableExpressions
 {
+    using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Linq.Expressions;
@@ -61,10 +62,12 @@ public ExpressionTranslatorRegistry()
                 .ToDictionary(t => t.NodeType, t => t.Translator);
         }
 
-        public string Translate(Expression expression, ReadableStringSettings settings)
+        public string Translate(
+            Expression expression, 
+            Func<TranslationSettings, TranslationSettings> configuration)
         {
             var context = (expression != null)
-                ? TranslationContext.For(expression, Translate, settings)
+                ? TranslationContext.For(expression, Translate, configuration)
                 : null;
 
             return Translate(expression, context);
diff --git a/ReadableExpressions/ReadableStringSettings.cs b/ReadableExpressions/ReadableStringSettings.cs
diff --git a/ReadableExpressions/TranslationContext.cs b/ReadableExpressions/TranslationContext.cs
@@ -15,13 +15,15 @@ public class TranslationContext
     {
         private readonly ExpressionAnalysisVisitor _analyzer;
         private readonly Translator _globalTranslator;
-        private readonly ReadableStringSettings _settings;
 
-        private TranslationContext(ExpressionAnalysisVisitor analyzer, Translator globalTranslator, ReadableStringSettings settings)
+        private TranslationContext(
+            ExpressionAnalysisVisitor analyzer,
+            Translator globalTranslator,
+            TranslationSettings settings)
         {
             _analyzer = analyzer;
             _globalTranslator = globalTranslator;
-            _settings = settings;
+            Settings = settings;
         }
 
         /// <summary>
@@ -34,11 +36,23 @@ private TranslationContext(ExpressionAnalysisVisitor analyzer, Translator global
         /// <param name="globalTranslator">
         /// A global <see cref="Translator"/> delegate with which to perform translations.
         /// </param>
-        /// <param name="settings">Configuration for the translation</param>
+        /// <param name="configuration">The configuration to use for the translation, if required.</param>
         /// <returns>A <see cref="TranslationContext"/> for the given<paramref name="expression"/>.</returns>
-        public static TranslationContext For(Expression expression, Translator globalTranslator, ReadableStringSettings settings)
+        public static TranslationContext For(
+            Expression expression,
+            Translator globalTranslator,
+            Func<TranslationSettings, TranslationSettings> configuration = null)
         {
-            return new TranslationContext(ExpressionAnalysisVisitor.Analyse(expression), globalTranslator, settings);
+            var analyzer = ExpressionAnalysisVisitor.Analyse(expression);
+            var settings = GetTranslationSettings(configuration);
+
+            return new TranslationContext(analyzer, globalTranslator, settings);
+        }
+
+        private static TranslationSettings GetTranslationSettings(
+            Func<TranslationSettings, TranslationSettings> configuration)
+        {
+            return configuration?.Invoke(new TranslationSettings()) ?? TranslationSettings.Default;
         }
 
         /// <summary>
@@ -50,7 +64,7 @@ public static TranslationContext For(Expression expression, Translator globalTra
         /// <summary>
         /// Configuration for translation in this context
         /// </summary>
-        public ReadableStringSettings Settings { get => _settings; }
+        public TranslationSettings Settings { get; }
 
         /// <summary>
         /// Translates the given <paramref name="expression"/> to readable source code.
diff --git a/ReadableExpressions/TranslationSettings.cs b/ReadableExpressions/TranslationSettings.cs
@@ -0,0 +1,29 @@
+﻿namespace AgileObjects.ReadableExpressions
+{
+    /// <summary>
+    /// Provides configuration options to control aspects of source-code string generation.
+    /// </summary>
+    public class TranslationSettings
+    {
+        internal static readonly TranslationSettings Default = new TranslationSettings();
+
+        internal TranslationSettings()
+        {
+            UseImplicitGenericParameters = true;
+        }
+
+        /// <summary>
+        /// Always specify generic parameter arguments explicitly in &lt;pointy braces&gt;
+        /// </summary>
+        public TranslationSettings UseExplicitGenericParameters
+        {
+            get
+            {
+                UseImplicitGenericParameters = false;
+                return this;
+            }
+        }
+
+        internal bool UseImplicitGenericParameters { get; private set; }
+    }
+}
diff --git a/ReadableExpressions/Translators/MethodCallExpressionTranslator.cs b/ReadableExpressions/Translators/MethodCallExpressionTranslator.cs
@@ -120,12 +120,12 @@ internal string GetMethodCall(
             TranslationContext context)
         {
             var parametersString = context.TranslateParameters(arguments, method).WithParentheses();
-            var genericArguments = GetGenericArgumentsIfNecessary(method, context.Settings.AlwaysUseExplicitGenericParameters);
+            var genericArguments = GetGenericArgumentsIfNecessary(method, context);
 
             return method.Name + genericArguments + parametersString;
         }
 
-        private static string GetGenericArgumentsIfNecessary(IMethodInfo method, bool alwaysExplicit)
+        private static string GetGenericArgumentsIfNecessary(IMethodInfo method, TranslationContext context)
         {
             if (!method.IsGenericMethod)
             {
@@ -135,12 +135,12 @@ private static string GetGenericArgumentsIfNecessary(IMethodInfo method, bool al
             var methodGenericDefinition = method.GetGenericMethodDefinition();
             var genericParameterTypes = methodGenericDefinition.GetGenericArguments().ToList();
 
-			if (!alwaysExplicit)
-			{
-				RemoveSpecifiedGenericTypeParameters(
-					methodGenericDefinition.GetParameters().Select(p => p.ParameterType),
-					genericParameterTypes);
-			}
+            if (context.Settings.UseImplicitGenericParameters)
+            {
+                RemoveSuppliedGenericTypeParameters(
+                    methodGenericDefinition.GetParameters().Select(p => p.ParameterType),
+                    genericParameterTypes);
+            }
 
             if (!genericParameterTypes.Any())
             {
@@ -161,7 +161,7 @@ private static string GetGenericArgumentsIfNecessary(IMethodInfo method, bool al
             return $"<{string.Join(", ", argumentNames)}>";
         }
 
-        private static void RemoveSpecifiedGenericTypeParameters(
+        private static void RemoveSuppliedGenericTypeParameters(
             IEnumerable<Type> types,
             ICollection<Type> genericParameterTypes)
         {
@@ -174,7 +174,7 @@ private static void RemoveSpecifiedGenericTypeParameters(
 
                 if (type.IsGenericType())
                 {
-                    RemoveSpecifiedGenericTypeParameters(type.GetGenericArguments(), genericParameterTypes);
+                    RemoveSuppliedGenericTypeParameters(type.GetGenericArguments(), genericParameterTypes);
                 }
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`namespace AgileObjects.ReadableExpressions`
`2`	`2`	`{`
	`3`	`+ using System;`
`3`	`4`	`using System.Linq.Expressions;`
`4`	`5`
`5`	`6`	`/// <summary>`
`@@ -13,12 +14,14 @@ public static class ExpressionExtensions`
`13`	`14`	`/// Translates the given <paramref name="expression"/> to source-code string.`
`14`	`15`	`/// </summary>`
`15`	`16`	`/// <param name="expression">The Expression to translate.</param>`
`16`		`- /// <param name="settings">Configuration options for the translation</param>`
	`17`	`+ /// <param name="configuration">The configuration to use for the translation, if required.</param>`
`17`	`18`	`/// <returns>The translated <paramref name="expression"/>.</returns>`
`18`		`- public static string ToReadableString(this Expression expression, ReadableStringSettings settings = null)`
	`19`	`+ public static string ToReadableString(`
	`20`	`+ this Expression expression,`
	`21`	`+ Func<TranslationSettings, TranslationSettings> configuration = null)`
`19`	`22`	`{`
`20`	`23`	`return _translatorRegistry`
`21`		`- .Translate(expression, settings ?? new ReadableStringSettings())?`
	`24`	`+ .Translate(expression, configuration)?`
`22`	`25`	`.WithoutUnindents();`
`23`	`26`	`}`
`24`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,12 +120,12 @@ internal string GetMethodCall(`
`120`	`120`	`TranslationContext context)`
`121`	`121`	`{`
`122`	`122`	`var parametersString = context.TranslateParameters(arguments, method).WithParentheses();`
`123`		`- var genericArguments = GetGenericArgumentsIfNecessary(method, context.Settings.AlwaysUseExplicitGenericParameters);`
	`123`	`+ var genericArguments = GetGenericArgumentsIfNecessary(method, context);`
`124`	`124`
`125`	`125`	`return method.Name + genericArguments + parametersString;`
`126`	`126`	`}`
`127`	`127`
`128`		`- private static string GetGenericArgumentsIfNecessary(IMethodInfo method, bool alwaysExplicit)`
	`128`	`+ private static string GetGenericArgumentsIfNecessary(IMethodInfo method, TranslationContext context)`
`129`	`129`	`{`
`130`	`130`	`if (!method.IsGenericMethod)`
`131`	`131`	`{`
`@@ -135,12 +135,12 @@ private static string GetGenericArgumentsIfNecessary(IMethodInfo method, bool al`
`135`	`135`	`var methodGenericDefinition = method.GetGenericMethodDefinition();`
`136`	`136`	`var genericParameterTypes = methodGenericDefinition.GetGenericArguments().ToList();`
`137`	`137`
`138`		`- if (!alwaysExplicit)`
`139`		`- {`
`140`		`- RemoveSpecifiedGenericTypeParameters(`
`141`		`- methodGenericDefinition.GetParameters().Select(p => p.ParameterType),`
`142`		`- genericParameterTypes);`
`143`		`- }`
	`138`	`+ if (context.Settings.UseImplicitGenericParameters)`
	`139`	`+ {`
	`140`	`+ RemoveSuppliedGenericTypeParameters(`
	`141`	`+ methodGenericDefinition.GetParameters().Select(p => p.ParameterType),`
	`142`	`+ genericParameterTypes);`
	`143`	`+ }`
`144`	`144`
`145`	`145`	`if (!genericParameterTypes.Any())`
`146`	`146`	`{`
`@@ -161,7 +161,7 @@ private static string GetGenericArgumentsIfNecessary(IMethodInfo method, bool al`
`161`	`161`	`return $"<{string.Join(", ", argumentNames)}>";`
`162`	`162`	`}`
`163`	`163`
`164`		`- private static void RemoveSpecifiedGenericTypeParameters(`
	`164`	`+ private static void RemoveSuppliedGenericTypeParameters(`
`165`	`165`	`IEnumerable<Type> types,`
`166`	`166`	`ICollection<Type> genericParameterTypes)`
`167`	`167`	`{`
`@@ -174,7 +174,7 @@ private static void RemoveSpecifiedGenericTypeParameters(`
`174`	`174`
`175`	`175`	`if (type.IsGenericType())`
`176`	`176`	`{`
`177`		`- RemoveSpecifiedGenericTypeParameters(type.GetGenericArguments(), genericParameterTypes);`
	`177`	`+ RemoveSuppliedGenericTypeParameters(type.GetGenericArguments(), genericParameterTypes);`
`178`	`178`	`}`
`179`	`179`	`}`
`180`	`180`	`}`