CultureInfo support for rendering values. (#78)

impworks · Romanx · commit a63b3b198331 · 2019-11-22T12:05:32.000Z
* CultureInfo support for rendering values.

* Make compilation renderer work with culture setting

* Rename culture-info function and make non-virtual
diff --git a/src/Stubble.Compilation/Renderers/TokenRenderers/InterpolationTokenRenderer.cs b/src/Stubble.Compilation/Renderers/TokenRenderers/InterpolationTokenRenderer.cs
@@ -5,7 +5,6 @@
 
 using System;
 using System.Linq.Expressions;
-using System.Reflection;
 using System.Text;
 using System.Threading.Tasks;
 using Stubble.Compilation.Contexts;
@@ -20,6 +19,8 @@ namespace Stubble.Compilation.Renderers.TokenRenderers
     /// </summary>
     public class InterpolationTokenRenderer : ExpressionObjectRenderer<InterpolationToken>
     {
+        private static Type[] formatProviderTypeArgs = new[] { typeof(IFormatProvider) };
+
         /// <inheritdoc/>
         protected override void Write(CompilationRenderer renderer, InterpolationToken obj, CompilerContext context)
         {
@@ -29,13 +30,24 @@ protected override void Write(CompilationRenderer renderer, InterpolationToken o
 
             if (!context.CompilationSettings.SkipHtmlEncoding && obj.EscapeResult && expression != null)
             {
-                var isValueType = expression.Type.GetIsValueType();
+                Expression stringExpression;
+                if (expression.Type == typeof(string))
+                {
+                    stringExpression = expression;
+                }
+                else
+                {
+                    var formattedToString = expression.Type
+                        .GetMethod(nameof(object.ToString), formatProviderTypeArgs);
+
+                    var item = expression.Type.GetIsValueType()
+                        ? expression
+                        : Expression.Coalesce(expression, Expression.Constant(string.Empty));
 
-                var stringExpression = expression.Type == typeof(string)
-                    ? expression
-                    : Expression.Call(
-                        isValueType ? expression : Expression.Coalesce(expression, Expression.Constant(string.Empty)),
-                        expression.Type.GetMethod("ToString", Type.EmptyTypes));
+                    stringExpression = formattedToString is object
+                        ? Expression.Call(item, formattedToString, Expression.Constant(context.CompilationSettings.CultureInfo))
+                        : Expression.Call(item, expression.Type.GetMethod(nameof(object.ToString), Type.EmptyTypes));
+                }
 
                 expression = Expression.Invoke(context.CompilerSettings.EncodingFuction, stringExpression);
             }
diff --git a/src/Stubble.Compilation/Settings/CompilationSettings.cs b/src/Stubble.Compilation/Settings/CompilationSettings.cs
@@ -3,6 +3,8 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 // </copyright>
 
+using System.Globalization;
+
 namespace Stubble.Compilation.Settings
 {
     /// <summary>
@@ -27,6 +29,11 @@ public class CompilationSettings
         /// </summary>
         public bool SkipHtmlEncoding { get; set; }
 
+        /// <summary>
+        /// Gets or sets the CultureInfo to use for rendering format-dependent values (doubles, etc.).
+        /// </summary>
+        public CultureInfo CultureInfo { get; set; } = CultureInfo.InvariantCulture;
+
         /// <summary>
         /// Gets the default render settings
         /// </summary>
@@ -37,7 +44,8 @@ public static CompilationSettings GetDefaultRenderSettings()
             {
                 SkipRecursiveLookup = false,
                 ThrowOnDataMiss = false,
-                SkipHtmlEncoding = false
+                SkipHtmlEncoding = false,
+                CultureInfo = CultureInfo.InvariantCulture
             };
         }
     }
diff --git a/src/Stubble.Core/Renderers/StringRenderer/TokenRenderers/InterpolationTokenRenderer.cs b/src/Stubble.Core/Renderers/StringRenderer/TokenRenderers/InterpolationTokenRenderer.cs
@@ -4,7 +4,7 @@
 // </copyright>
 
 using System;
-using System.Net;
+using System.Globalization;
 using System.Threading.Tasks;
 using Stubble.Core.Contexts;
 using Stubble.Core.Tokens;
@@ -16,6 +16,22 @@ namespace Stubble.Core.Renderers.StringRenderer.TokenRenderers
     /// </summary>
     public class InterpolationTokenRenderer : StringObjectRenderer<InterpolationToken>
     {
+        /// <summary>
+        /// Renders the value to string using a locale.
+        /// </summary>
+        /// <param name="obj">The object to convert</param>
+        /// <param name="culture">The culture to use</param>
+        /// <returns>The object stringified into the locale</returns>
+        protected static string ConvertToStringInCulture(object obj, CultureInfo culture)
+        {
+            if (obj is null || obj is string)
+            {
+                return obj as string;
+            }
+
+            return Convert.ToString(obj, culture);
+        }
+
         /// <inheritdoc/>
         protected override void Write(StringRender renderer, InterpolationToken obj, Context context)
         {
@@ -27,7 +43,7 @@ protected override void Write(StringRender renderer, InterpolationToken obj, Con
             if (functionValueDynamic != null || functionValue != null)
             {
                 object functionResult = functionValueDynamic != null ? functionValueDynamic.Invoke(context.View) : functionValue.Invoke();
-                var resultString = functionResult.ToString();
+                var resultString = ConvertToStringInCulture(functionResult, context.RenderSettings.CultureInfo);
                 if (resultString.Contains("{{"))
                 {
                     renderer.Render(context.RendererSettings.Parser.Parse(resultString), context);
@@ -39,20 +55,20 @@ protected override void Write(StringRender renderer, InterpolationToken obj, Con
 
             if (!context.RenderSettings.SkipHtmlEncoding && obj.EscapeResult && value != null)
             {
-                value = context.RendererSettings.EncodingFuction(value.ToString());
+                value = context.RendererSettings.EncodingFuction(ConvertToStringInCulture(value, context.RenderSettings.CultureInfo));
             }
 
             if (obj.Indent > 0)
             {
                 renderer.Write(' ', obj.Indent);
             }
 
-            renderer.Write(value?.ToString());
+            renderer.Write(ConvertToStringInCulture(value, context.RenderSettings.CultureInfo));
         }
 
-        /// <inheritdoc/>
-        protected override async Task WriteAsync(StringRender renderer, InterpolationToken obj, Context context)
-        {
+        /// <inheritdoc/>
+        protected override async Task WriteAsync(StringRender renderer, InterpolationToken obj, Context context)
+        {
             var value = context.Lookup(obj.Content.ToString());
 
             var functionValueDynamic = value as Func<dynamic, object>;
@@ -61,7 +77,7 @@ protected override async Task WriteAsync(StringRender renderer, InterpolationTok
             if (functionValueDynamic != null || functionValue != null)
             {
                 object functionResult = functionValueDynamic != null ? functionValueDynamic.Invoke(context.View) : functionValue.Invoke();
-                var resultString = functionResult.ToString();
+                var resultString = ConvertToStringInCulture(functionResult, context.RenderSettings.CultureInfo);
                 if (resultString.Contains("{{"))
                 {
                     await renderer.RenderAsync(context.RendererSettings.Parser.Parse(resultString), context);
@@ -73,15 +89,15 @@ protected override async Task WriteAsync(StringRender renderer, InterpolationTok
 
             if (!context.RenderSettings.SkipHtmlEncoding && obj.EscapeResult && value != null)
             {
-                value = context.RendererSettings.EncodingFuction(value.ToString());
+                value = context.RendererSettings.EncodingFuction(ConvertToStringInCulture(value, context.RenderSettings.CultureInfo));
             }
 
             if (obj.Indent > 0)
             {
                 renderer.Write(' ', obj.Indent);
             }
 
-            renderer.Write(value?.ToString());
+            renderer.Write(ConvertToStringInCulture(value, context.RenderSettings.CultureInfo));
         }
     }
 }
diff --git a/src/Stubble.Core/Settings/RenderSettings.cs b/src/Stubble.Core/Settings/RenderSettings.cs
@@ -3,6 +3,8 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 // </copyright>
 
+using System.Globalization;
+
 namespace Stubble.Core.Settings
 {
     /// <summary>
@@ -27,6 +29,11 @@ public class RenderSettings
         /// </summary>
         public bool SkipHtmlEncoding { get; set; }
 
+        /// <summary>
+        /// Gets or sets the CultureInfo to use for rendering format-dependent values (doubles, etc.).
+        /// </summary>
+        public CultureInfo CultureInfo { get; set; } = CultureInfo.InvariantCulture;
+
         /// <summary>
         /// Gets the default render settings
         /// </summary>
@@ -38,6 +45,7 @@ public static RenderSettings GetDefaultRenderSettings()
                 SkipRecursiveLookup = false,
                 ThrowOnDataMiss = false,
                 SkipHtmlEncoding = false,
+                CultureInfo = CultureInfo.InvariantCulture
             };
         }
     }
diff --git a/test/Stubble.Compilation.Tests/SpecTests.cs b/test/Stubble.Compilation.Tests/SpecTests.cs
@@ -9,22 +9,22 @@ namespace Stubble.Compilation.Tests
     public class SpecTests
     {
         internal readonly ITestOutputHelper OutputStream;
-        internal readonly CompilerSettings Settings;
 
         public SpecTests(ITestOutputHelper output)
         {
             OutputStream = output;
-            Settings = new CompilerSettingsBuilder().BuildSettings();
         }
 
         [Theory]
         [MemberData(nameof(Specs.SpecTests), MemberType = typeof(Specs))]
         public void CompilationRendererSpecTest(SpecTest data)
         {
-            OutputStream.WriteLine(data.Name);
+            OutputStream.WriteLine(data.Name);
+            var settings = CompilationSettings.GetDefaultRenderSettings();
+            settings.CultureInfo = data.CultureInfo ?? settings.CultureInfo;
 
-            var stubble = new StubbleCompilationRenderer(Settings);
-            var output = data.Partials != null ? stubble.Compile(data.Template, data.Data, data.Partials) : stubble.Compile(data.Template, data.Data);
+            var stubble = new StubbleCompilationRenderer();
+            var output = data.Partials != null ? stubble.Compile(data.Template, data.Data, data.Partials, settings) : stubble.Compile(data.Template, data.Data, settings);
 
             var outputResult = output(data.Data);
 
@@ -36,10 +36,12 @@ public void CompilationRendererSpecTest(SpecTest data)
         [MemberData(nameof(Specs.SpecTests), MemberType = typeof(Specs))]
         public async Task CompilationRendererSpecTest_Async(SpecTest data)
         {
-            OutputStream.WriteLine(data.Name);
+            OutputStream.WriteLine(data.Name);
+            var settings = CompilationSettings.GetDefaultRenderSettings();
+            settings.CultureInfo = data.CultureInfo ?? settings.CultureInfo;
 
-            var stubble = new StubbleCompilationRenderer(Settings);
-            var output = await (data.Partials != null ? stubble.CompileAsync(data.Template, data.Data, data.Partials) : stubble.CompileAsync(data.Template, data.Data));
+            var stubble = new StubbleCompilationRenderer();
+            var output = await (data.Partials != null ? stubble.CompileAsync(data.Template, data.Data, data.Partials, settings) : stubble.CompileAsync(data.Template, data.Data, settings));
 
             var outputResult = output(data.Data);
 
diff --git a/test/Stubble.Core.Tests/SpecTests.cs b/test/Stubble.Core.Tests/SpecTests.cs
@@ -1,5 +1,6 @@
 ﻿using Stubble.Test.Shared.Spec;
 using System.Threading.Tasks;
+using Stubble.Core.Settings;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -18,9 +19,12 @@ public SpecTests(ITestOutputHelper output)
         [MemberData(nameof(Specs.SpecTestsWithLambda), MemberType = typeof(Specs))]
         public void StringRendererSpecTest(SpecTest data)
         {
+            var settings = RenderSettings.GetDefaultRenderSettings();
+            settings.CultureInfo = data.CultureInfo ?? settings.CultureInfo;
+
             OutputStream.WriteLine(data.Name);
-            var stubble = new StubbleVisitorRenderer();
-            var output = data.Partials != null ? stubble.Render(data.Template, data.Data, data.Partials) : stubble.Render(data.Template, data.Data);
+            var stubble = new StubbleVisitorRenderer();
+            var output = data.Partials != null ? stubble.Render(data.Template, data.Data, data.Partials, settings) : stubble.Render(data.Template, data.Data, settings);
 
             OutputStream.WriteLine("Expected \"{0}\", Actual \"{1}\"", data.Expected, output);
             Assert.Equal(data.Expected, output);
@@ -30,9 +34,12 @@ public void StringRendererSpecTest(SpecTest data)
         [MemberData(nameof(Specs.SpecTestsWithLambda), MemberType = typeof(Specs))]
         public async Task StringRendererSpecTest_Async(SpecTest data)
         {
+            var settings = RenderSettings.GetDefaultRenderSettings();
+            settings.CultureInfo = data.CultureInfo ?? settings.CultureInfo;
+
             OutputStream.WriteLine(data.Name);
             var stubble = new StubbleVisitorRenderer();
-            var output = await (data.Partials != null ? stubble.RenderAsync(data.Template, data.Data, data.Partials) : stubble.RenderAsync(data.Template, data.Data));
+            var output = await (data.Partials != null ? stubble.RenderAsync(data.Template, data.Data, data.Partials, settings) : stubble.RenderAsync(data.Template, data.Data, settings));
 
             OutputStream.WriteLine("Expected \"{0}\", Actual \"{1}\"", data.Expected, output);
             Assert.Equal(data.Expected, output);
diff --git a/test/Stubble.Test.Shared/Spec/Spec.Interpolation.cs b/test/Stubble.Test.Shared/Spec/Spec.Interpolation.cs
@@ -1,4 +1,5 @@
 ﻿using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 
 namespace Stubble.Test.Shared.Spec
@@ -94,6 +95,14 @@ public static partial class Specs
                 Template = @"""{{&power}} jiggawatts!""",
                 Expected = @"""1.21 jiggawatts!"""
             },
+            new SpecTest {
+                Name = @"Culture-specific Decimal Interpolation",
+                Desc = @"Decimals should interpolate seamlessly with proper significance.",
+                Data = new { power = 1.21, },
+                CultureInfo = CultureInfo.GetCultureInfo("ru-RU"),
+                Template = @"""{{power}} jiggawatts!""",
+                Expected = @"""1,21 jiggawatts!"""
+            },
             new SpecTest {
                 Name = @"Basic Context Miss Interpolation",
                 Desc = @"Failed context lookups should default to empty strings.",
diff --git a/test/Stubble.Test.Shared/Spec/SpecTest.cs b/test/Stubble.Test.Shared/Spec/SpecTest.cs
@@ -3,9 +3,10 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 // </copyright>
 
-using Newtonsoft.Json;
-using System;
+using Newtonsoft.Json;
+using System;
 using System.Collections.Generic;
+using System.Globalization;
 using Xunit.Abstractions;
 
 namespace Stubble.Test.Shared.Spec
@@ -26,6 +27,8 @@ public class SpecTest
 
         public IDictionary<string, string> Partials { get; set; }
 
-        public Exception ExpectedException { get; set; }
+        public Exception ExpectedException { get; set; }
+
+        public CultureInfo CultureInfo { get; set; }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`// </copyright>`
`5`	`5`
`6`	`6`	`using System;`
`7`		`-using System.Net;`
	`7`	`+using System.Globalization;`
`8`	`8`	`using System.Threading.Tasks;`
`9`	`9`	`using Stubble.Core.Contexts;`
`10`	`10`	`using Stubble.Core.Tokens;`
`@@ -16,6 +16,22 @@ namespace Stubble.Core.Renderers.StringRenderer.TokenRenderers`
`16`	`16`	`/// </summary>`
`17`	`17`	`public class InterpolationTokenRenderer : StringObjectRenderer<InterpolationToken>`
`18`	`18`	`{`
	`19`	`+ /// <summary>`
	`20`	`+ /// Renders the value to string using a locale.`
	`21`	`+ /// </summary>`
	`22`	`+ /// <param name="obj">The object to convert</param>`
	`23`	`+ /// <param name="culture">The culture to use</param>`
	`24`	`+ /// <returns>The object stringified into the locale</returns>`
	`25`	`+ protected static string ConvertToStringInCulture(object obj, CultureInfo culture)`
	`26`	`+ {`
	`27`	`+ if (obj is null \|\| obj is string)`
	`28`	`+ {`
	`29`	`+ return obj as string;`
	`30`	`+ }`
	`31`	`+`
	`32`	`+ return Convert.ToString(obj, culture);`
	`33`	`+ }`
	`34`	`+`
`19`	`35`	`/// <inheritdoc/>`
`20`	`36`	`protected override void Write(StringRender renderer, InterpolationToken obj, Context context)`
`21`	`37`	`{`
`@@ -27,7 +43,7 @@ protected override void Write(StringRender renderer, InterpolationToken obj, Con`
`27`	`43`	`if (functionValueDynamic != null \|\| functionValue != null)`
`28`	`44`	`{`
`29`	`45`	`object functionResult = functionValueDynamic != null ? functionValueDynamic.Invoke(context.View) : functionValue.Invoke();`
`30`		`- var resultString = functionResult.ToString();`
	`46`	`+ var resultString = ConvertToStringInCulture(functionResult, context.RenderSettings.CultureInfo);`
`31`	`47`	`if (resultString.Contains("{{"))`
`32`	`48`	`{`
`33`	`49`	`renderer.Render(context.RendererSettings.Parser.Parse(resultString), context);`
`@@ -39,20 +55,20 @@ protected override void Write(StringRender renderer, InterpolationToken obj, Con`
`39`	`55`
`40`	`56`	`if (!context.RenderSettings.SkipHtmlEncoding && obj.EscapeResult && value != null)`
`41`	`57`	`{`
`42`		`- value = context.RendererSettings.EncodingFuction(value.ToString());`
	`58`	`+ value = context.RendererSettings.EncodingFuction(ConvertToStringInCulture(value, context.RenderSettings.CultureInfo));`
`43`	`59`	`}`
`44`	`60`
`45`	`61`	`if (obj.Indent > 0)`
`46`	`62`	`{`
`47`	`63`	`renderer.Write(' ', obj.Indent);`
`48`	`64`	`}`
`49`	`65`
`50`		`- renderer.Write(value?.ToString());`
	`66`	`+ renderer.Write(ConvertToStringInCulture(value, context.RenderSettings.CultureInfo));`
`51`	`67`	`}`
`52`	`68`
`53`		`- /// <inheritdoc/>`
`54`		`- protected override async Task WriteAsync(StringRender renderer, InterpolationToken obj, Context context)`
`55`		`- {`
	`69`	`+ /// <inheritdoc/>`
	`70`	`+ protected override async Task WriteAsync(StringRender renderer, InterpolationToken obj, Context context)`
	`71`	`+ {`
`56`	`72`	`var value = context.Lookup(obj.Content.ToString());`
`57`	`73`
`58`	`74`	`var functionValueDynamic = value as Func<dynamic, object>;`
`@@ -61,7 +77,7 @@ protected override async Task WriteAsync(StringRender renderer, InterpolationTok`
`61`	`77`	`if (functionValueDynamic != null \|\| functionValue != null)`
`62`	`78`	`{`
`63`	`79`	`object functionResult = functionValueDynamic != null ? functionValueDynamic.Invoke(context.View) : functionValue.Invoke();`
`64`		`- var resultString = functionResult.ToString();`
	`80`	`+ var resultString = ConvertToStringInCulture(functionResult, context.RenderSettings.CultureInfo);`
`65`	`81`	`if (resultString.Contains("{{"))`
`66`	`82`	`{`
`67`	`83`	`await renderer.RenderAsync(context.RendererSettings.Parser.Parse(resultString), context);`
`@@ -73,15 +89,15 @@ protected override async Task WriteAsync(StringRender renderer, InterpolationTok`
`73`	`89`
`74`	`90`	`if (!context.RenderSettings.SkipHtmlEncoding && obj.EscapeResult && value != null)`
`75`	`91`	`{`
`76`		`- value = context.RendererSettings.EncodingFuction(value.ToString());`
	`92`	`+ value = context.RendererSettings.EncodingFuction(ConvertToStringInCulture(value, context.RenderSettings.CultureInfo));`
`77`	`93`	`}`
`78`	`94`
`79`	`95`	`if (obj.Indent > 0)`
`80`	`96`	`{`
`81`	`97`	`renderer.Write(' ', obj.Indent);`
`82`	`98`	`}`
`83`	`99`
`84`		`- renderer.Write(value?.ToString());`
	`100`	`+ renderer.Write(ConvertToStringInCulture(value, context.RenderSettings.CultureInfo));`
`85`	`101`	`}`
`86`	`102`	`}`
`87`	`103`	`}`