Replace JsonWriterOptions with JsonSerializationOptions (#847)

Author: sebastienros

Fluid.Tests/Domain/Person.cs

@@ -16,8 +16,8 @@ public class Address
 
     public enum Colors
     {
-        Blue,
-        Red,
-        Yellow
+        Blue = 0,
+        Red = 1,
+        Yellow = 2
     }
 }

Fluid.Tests/FunctionTests.cs

@@ -35,7 +35,7 @@ public async Task FunctionCallsAreInvoked()
             Assert.True(template != null, error);
             var context = new TemplateContext();
             context.SetValue("a", new FunctionValue((args, c) => new StringValue("hello")));
-            context.SetValue("b", new FunctionValue((args, c) => new ValueTask<FluidValue>(new StringValue("world"))));
+            context.SetValue("b", new FunctionValue((args, c) => new StringValue("world")));
 
             // Use a loop to exercise the arguments cache
             for (var i = 0; i < 10; i++)

Fluid.Tests/MiscFiltersTests.cs

@@ -1,11 +1,13 @@
 using Fluid.Filters;
+using Fluid.Tests.Domain;
 using Fluid.Values;
 using Newtonsoft.Json.Linq;
 using System;
 using System.Globalization;
 using System.Linq;
 using System.Text.Encodings.Web;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 using System.Threading.Tasks;
 using TimeZoneConverter;
 using Xunit;
@@ -693,59 +695,6 @@ public async Task Json(object value, string expected)
             Assert.Equal(expected, result.ToStringValue());
         }
 
-        [Fact]
-        public async Task JsonShouldHideMembers()
-        {
-            var inputObject = new JsonAccessStrategy();
-            var templateOptions = new TemplateOptions();
-            templateOptions.MemberAccessStrategy.Register<JsonAccessStrategy, FluidValue>((obj, name, context) =>
-            {
-                return name switch
-                {
-                    nameof(JsonAccessStrategy.Visible) => new StringValue(obj.Visible),
-                    nameof(JsonAccessStrategy.Null) => new StringValue(obj.Null),
-                    _ => NilValue.Instance
-                };
-            });
-
-            var input = FluidValue.Create(inputObject, templateOptions);
-            var expected = "{\"Visible\":\"Visible\",\"Null\":\"\"}";
-
-            var arguments = new FilterArguments();
-            var context = new TemplateContext(templateOptions);
-
-            var result = await MiscFilters.Json(input, arguments, context);
-
-            Assert.Equal(expected, result.ToStringValue());
-        }
-
-        [Fact]
-        public async Task JsonShouldHandleCircularReferences()
-        {
-            var model = TestObjects.RecursiveReferenceObject;
-            var input = FluidValue.Create(model, TemplateOptions.Default);
-            var to = new TemplateOptions();
-            to.MemberAccessStrategy.Register<TestObjects.Node>();
-
-            var result = await MiscFilters.Json(input, new FilterArguments(), new TemplateContext(to));
-
-            Assert.Equal("{\"Name\":\"Object1\",\"NodeRef\":{\"Name\":\"Child1\",\"NodeRef\":\"Circular reference has been detected.\"}}", result.ToStringValue());
-        }
-
-        [Fact]
-        public async Task JsonShouldHandleCircularReferencesOnSiblingPropertiesSeparately()
-        {
-            var model = TestObjects.SiblingPropertiesHaveSameReferenceObject;
-            var input = FluidValue.Create(model, TemplateOptions.Default);
-            var to = new TemplateOptions();
-            to.MemberAccessStrategy.Register<TestObjects.Node>();
-            to.MemberAccessStrategy.Register<TestObjects.MultipleNode>();
-
-            var result = await MiscFilters.Json(input, new FilterArguments(), new TemplateContext(to));
-
-            Assert.Equal("{\"Name\":\"MultipleNode1\",\"Node1\":{\"Name\":\"Object1\",\"NodeRef\":{\"Name\":\"Child1\",\"NodeRef\":\"Circular reference has been detected.\"}},\"Node2\":{\"Name\":\"Object1\",\"NodeRef\":{\"Name\":\"Child1\",\"NodeRef\":\"Circular reference has been detected.\"}}}", result.ToStringValue());
-        }
-
         [Fact]
         public async Task JsonShouldIgnoreStaticMembers()
         {
@@ -771,7 +720,7 @@ public async Task JsonShouldWriteNullIfDictionaryNotReturnFluidIndexable()
             options.MemberAccessStrategy.Register(model.GetType());
             var input = FluidValue.Create(model, options);
             var result = await MiscFilters.Json(input, new FilterArguments(), new TemplateContext(options));
-            Assert.Equal("{\"Id\":1,\"WithoutIndexable\":null,\"Bool\":true}", result.ToStringValue());
+            Assert.Equal("{\"Id\":1,\"WithoutIndexable\":{\"Type\":5,\"Value\":{}},\"Bool\":true}", result.ToStringValue());
         }
 
         [Fact]
@@ -815,7 +764,10 @@ public async Task JsonShouldUseJsonSerializerOption()
         {
             var options = new TemplateOptions
             {
-                JavaScriptEncoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
+                JsonSerializerOptions = new JsonSerializerOptions
+                {
+                    Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
+                }
             };
 
             var input = FluidValue.Create("你好，这是一条短信", options);
@@ -825,57 +777,37 @@ public async Task JsonShouldUseJsonSerializerOption()
         }
 
         [Fact]
-        public async Task JsonShouldUseJsonWriterOptionsFromTemplateOptions()
+        public async Task JsonShouldSerializeEnumsAsNumbers()
         {
-            var options = new TemplateOptions
-            {
-                JsonWriterOptions = new JsonWriterOptions
-                {
-                    Indented = true
-                }
-            };
+            var options = new TemplateOptions();
+            options.MemberAccessStrategy.Register<Domain.Colors>();
 
-            var input = FluidValue.Create(new { name = "test", value = 123 }, options);
-            options.MemberAccessStrategy.Register(input.ToObjectValue().GetType());
+            var input = FluidValue.Create(Domain.Colors.Red, options);
             var context = new TemplateContext(options);
             var result = await MiscFilters.Json(input, new FilterArguments(), context);
 
-            // Indented JSON should have newlines
-            Assert.Contains("\n", result.ToStringValue());
+            // Enum should be serialized as number (1 for Red)
+            Assert.Equal("1", result.ToStringValue());
         }
-
+        
         [Fact]
-        public async Task JsonShouldUseJsonWriterOptionsFromTemplateContext()
+        public async Task JsonShouldSerializeEnumsAsStrings()
         {
-            var options = new TemplateOptions();
-            var context = new TemplateContext(options)
+            var options = new TemplateOptions
             {
-                JsonWriterOptions = new JsonWriterOptions
+                JsonSerializerOptions = new JsonSerializerOptions
                 {
-                    Indented = true
+                    Converters = { new JsonStringEnumConverter() }
                 }
             };
+            options.MemberAccessStrategy.Register<Person>();
 
-            var input = FluidValue.Create(new { name = "test", value = 123 }, options);
-            options.MemberAccessStrategy.Register(input.ToObjectValue().GetType());
-            var result = await MiscFilters.Json(input, new FilterArguments(), context);
-
-            // Indented JSON should have newlines
-            Assert.Contains("\n", result.ToStringValue());
-        }
-
-        [Fact]
-        public async Task JsonShouldSerializeEnumsAsNumbers()
-        {
-            var options = new TemplateOptions();
-            options.MemberAccessStrategy.Register<TestEnum>();
-            
-            var input = FluidValue.Create(TestEnum.Value2, options);
+            var input = FluidValue.Create(new Person { EyesColor = Colors.Red }, options);
             var context = new TemplateContext(options);
             var result = await MiscFilters.Json(input, new FilterArguments(), context);
 
-            // Enum should be serialized as number (1 for Value2)
-            Assert.Equal("1", result.ToStringValue());
+            // Enum should be serialized as string ("Red")
+            Assert.Equal("{\"Firstname\":null,\"Lastname\":null,\"EyesColor\":\"Red\",\"Address\":null}", result.ToStringValue());
         }
 
         [Theory]
@@ -1084,12 +1016,5 @@ public DictionaryWithoutIndexableTestObjects(object value) : base(value)
 
             }
         }
-
-        private enum TestEnum
-        {
-            Value1 = 0,
-            Value2 = 1,
-            Value3 = 2
-        }
     }
 }

Fluid.Tests/TemplateTests.cs

@@ -121,7 +121,7 @@ public async Task ShouldNotEncodeCaptures(string source, string expected)
         public async Task ShouldCustomizeCaptures()
         {
             _parser.TryParse("{% capture foo %}hello <br /> world{% endcapture %}{{ foo }}", out var template, out var error);
-            var result = await template.RenderAsync(new TemplateContext { Captured = (identifier, captured, context) => new ValueTask<FluidValue>(new StringValue(captured.ToStringValue().ToUpper(), false)) }, HtmlEncoder.Default);
+            var result = await template.RenderAsync(new TemplateContext { Captured = (identifier, captured, context) => new StringValue(captured.ToStringValue().ToUpper(), false) }, HtmlEncoder.Default);
             Assert.Equal("HELLO <BR /> WORLD", result);
         }
 

Fluid/Ast/IfStatement.cs

@@ -131,7 +131,7 @@ private async ValueTask<Completion> Awaited(
             }
             else
             {
-                await AwaitedElseBranch(null, new ValueTask<FluidValue>(BooleanValue.False), new ValueTask<Completion>(), writer, encoder, context, startIndex: 0);
+                await AwaitedElseBranch(null, BooleanValue.False, new ValueTask<Completion>(), writer, encoder, context, startIndex: 0);
             }
 
             return Completion.Normal;

Fluid/Ast/LiteralExpression.cs

@@ -13,7 +13,7 @@ public LiteralExpression(FluidValue value)
 
         public override ValueTask<FluidValue> EvaluateAsync(TemplateContext context)
         {
-            return new ValueTask<FluidValue>(Value);
+            return Value;
         }
 
         protected internal override Expression Accept(AstVisitor visitor) => visitor.VisitLiteralExpression(this);

Fluid/Ast/MemberExpression.cs

@@ -44,7 +44,7 @@ public override ValueTask<FluidValue> EvaluateAsync(TemplateContext context)
             {
                 if (context.Model == null)
                 {
-                    return new ValueTask<FluidValue>(value);
+                    return value;
                 }
 
                 start = 0;
@@ -66,11 +66,11 @@ public override ValueTask<FluidValue> EvaluateAsync(TemplateContext context)
                 // Stop processing as soon as a member returns nothing
                 if (value.IsNil())
                 {
-                    return new ValueTask<FluidValue>(value);
+                    return value;
                 }
             }
 
-            return new ValueTask<FluidValue>(value);
+            return value;
         }
 
         private static async ValueTask<FluidValue> Awaited(