Merge pull request #54 from mikebridge/error_syntax

Add error-handling syntactic sugar

Author: mikebridge

Liquid.NET.Tests/Examples/ExampleTests.cs

@@ -1,6 +1,9 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.Remoting;
 using Liquid.NET.Constants;
+using Liquid.NET.Filters;
 using Liquid.NET.Utils;
 using NUnit.Framework;
 
@@ -141,5 +144,116 @@ public class MyPoco
         }
 
 
+
+        public class MyUpCaseFilter : FilterExpression<LiquidString, LiquidString>
+        {
+            public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, LiquidString liquidExpression)
+            {
+                return LiquidExpressionResult.Success(liquidExpression.ToString().ToUpper());
+            }
+        }
+
+        [Test]
+        public void It_Should_Render_In_Upper_Case()
+        {
+            // Arrange
+            var ctx = new TemplateContext()
+                .WithFilter<MyUpCaseFilter>("myupcase");
+            var parsingResult = LiquidTemplate.Create("Result : {{ \"test\" | myupcase }}");
+
+            // Act
+            var renderingResult = parsingResult.LiquidTemplate.Render(ctx);
+           
+            // Assert
+            Assert.That(renderingResult.Result, Is.EqualTo("Result : TEST"));
+        }
+
+        [Test]
+        public void Test_Introductory_Example()
+        {
+            // create a template context that knows about the standard filters,
+            // and define a string variable "myvariable"
+            ITemplateContext ctx = new TemplateContext()
+                .WithAllFilters()
+                .DefineLocalVariable("myvariable", LiquidString.Create("Hello World"));
+
+            // parse the template and check for errors
+            var parsingResult = LiquidTemplate.Create("<div>{{myvariable}}</div>");
+
+            if (parsingResult.HasParsingErrors)
+            {
+                HandleErrors(parsingResult.ParsingErrors);
+                return;
+            }
+
+            // merge the variables from the context into the template and check for errors
+            var renderingResult = parsingResult.LiquidTemplate.Render(ctx);
+            if (renderingResult.HasParsingErrors)
+            {
+                HandleErrors(renderingResult.ParsingErrors);
+                return;
+            }
+            if (renderingResult.HasRenderingErrors)
+            {
+                HandleErrors(renderingResult.RenderingErrors);
+                return;
+            }
+
+            Assert.That(renderingResult.Result, Is.EqualTo("<div>Hello World</div>"));
+
+        }
+
+        [Test]
+        public void Test_Introductory_Example_With_Syntactic_Sugar()
+        {
+            // create a place to accumulate parsing and rendering errors.
+            var errors = new List<LiquidError>();
+
+            // Note that you will still get a best-guess LiquidTemplate, even if you encounter errors.
+            var liquidTemplate = LiquidTemplate.Create("<div>{{myvariable}}</div>")
+                .OnParsingError(errors.Add)
+                .LiquidTemplate;
+
+            // [add code here to handle the parsing errors, return]
+            Assert.That(errors.Any(), Is.False);
+
+            var ctx = new TemplateContext()
+                .WithAllFilters()
+                .DefineLocalVariable("myvariable", LiquidString.Create("Hello World"));
+
+
+            // The final String output will still be available in .Result, 
+            // even when parsing or rendering errors are encountered.
+            var result = liquidTemplate.Render(ctx)
+                .OnAnyError(errors.Add) // also available: .OnParsingError, .OnRenderingError
+                .Result;
+
+            // [add code here to handle the parsing and rendering errors]
+            Assert.That(errors.Any(), Is.False);
+
+            Console.WriteLine(result);
+            Assert.That(result, Is.EqualTo("<div>Hello World</div>"));
+
+        }
+
+//        [Test]
+//        public void It_Should_Throw_An_Error()
+//        {
+//            LiquidHash hash = new LiquidHash();
+//            ITemplateContext ctx = new TemplateContext()
+//                .ErrorWhenValueMissing()
+//                .DefineLocalVariable("myvariable", hash);
+//
+//            var parsingResult = LiquidTemplate.Create("<div>{{myvariable.ss}}</div>");
+//            var renderingResult = parsingResult.LiquidTemplate.Render(ctx);
+//            
+//            Console.WriteLine("ERROR: " + String.Join("; ", renderingResult.RenderingErrors.Select(x => x.Message)));
+//            Console.WriteLine(renderingResult.Result, "<div>ui</div>");
+//        }
+
+        private void HandleErrors(IList<LiquidError> errors)
+        {
+            // ...
+        }
     }
 }

Liquid.NET.Tests/Liquid.NET.Tests.csproj

@@ -144,6 +144,8 @@
     <Compile Include="LiquidASTExpressionParsingTests.cs" />
     <Compile Include="LiquidASTGeneratorTests.cs" />
     <Compile Include="LiquidASTRendererTests.cs" />
+    <Compile Include="LiquidParsingResultTests.cs" />
+    <Compile Include="LiquidRenderingResultTests.cs" />
     <Compile Include="Logger.cs" />
     <Compile Include="Parser\ErrorTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

Liquid.NET.Tests/LiquidParsingResultTests.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+
+namespace Liquid.NET.Tests
+{
+    [TestFixture]
+    public class LiquidParsingResultTests
+    {
+        [Test]
+        public void It_Should_Call_An_Error_Function()
+        {
+            // Arrange
+            IList<LiquidError> errors = new List<LiquidError>{ new LiquidError { Message = "Hello" } };
+            var parsingResult = LiquidParsingResult.Create(new LiquidTemplate(new LiquidAST()), errors);
+
+            // Act
+            IList<LiquidError> heardErrors = new List<LiquidError>();
+            parsingResult.OnParsingError(heardErrors.Add);
+
+            // Assert
+            Assert.That(heardErrors.Any());
+
+        }
+
+
+    }
+}

Liquid.NET.Tests/LiquidRenderingResultTests.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+
+namespace Liquid.NET.Tests
+{
+    [TestFixture]
+    public class LiquidRenderingResultTests
+    {
+
+        [Test]
+        public void It_Should_Call_An_Error_Function()
+        {
+            // Arrange
+            IList<LiquidError> renderingErrors = new List<LiquidError> { new LiquidError { Message = "Rendering" } };
+            IList<LiquidError> parsingErrors = new List<LiquidError> { new LiquidError { Message = "Parsing" } };
+            var parsingResult = LiquidRenderingResult.Create("result", renderingErrors, parsingErrors);
+
+            // Act
+            IList<LiquidError> heardParsingErrors = new List<LiquidError>();
+            IList<LiquidError> heardRenderingErrors = new List<LiquidError>();
+            IList<LiquidError> heardAllErrors = new List<LiquidError>();
+            parsingResult.OnParsingError(heardParsingErrors.Add);
+            parsingResult.OnRenderingError(heardRenderingErrors.Add);
+            parsingResult.OnAnyError(heardAllErrors.Add);
+
+            // Assert
+            Assert.That(heardParsingErrors.Count, Is.EqualTo(1));
+            Assert.That(heardRenderingErrors.Count, Is.EqualTo(1));
+            Assert.That(heardAllErrors.Count, Is.EqualTo(2));
+
+        }
+
+    }
+}

Liquid.NET/src/LiquidParsingResult.cs

@@ -1,10 +1,12 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 
 namespace Liquid.NET
 {
     public class LiquidParsingResult
     {
+
         public static LiquidParsingResult Create(LiquidTemplate liquidTemplate, IList<LiquidError> parsingErrors)
         {
             return new LiquidParsingResult
@@ -29,6 +31,24 @@ private LiquidParsingResult()
 
         public IList<LiquidError> ParsingErrors { get; private set; }
 
+        /// <summary>
+        /// This function will be called once for each error encountered
+        /// during parsing
+        /// </summary>
+        /// <param name="onErrorFn"></param>
+        /// <returns></returns>
+        public LiquidParsingResult OnParsingError(Action<LiquidError> onErrorFn)
+        {
+            if (onErrorFn != null)
+            {
+                foreach (var err in ParsingErrors)
+                {
+                    onErrorFn(err);
+                }
+            }
+            return this;
+        }
+
 
     }
 }

Liquid.NET/src/LiquidRenderingResult.cs

@@ -8,6 +8,12 @@ namespace Liquid.NET
 {
     public class LiquidRenderingResult
     {
+        private Action<LiquidError> _onParsingError;
+        private Action<LiquidError> _onRenderingError;
+        private Action<LiquidError> _onAnyError = err => { };
+
+        private Action<LiquidError> AnyError { get { return _onAnyError;} }
+
         public static LiquidRenderingResult Create(
             String result, 
             IList<LiquidError> renderingErrors,
@@ -26,7 +32,8 @@ IList<LiquidError> parsingErrors
 
         private LiquidRenderingResult()
         {
-            
+            _onParsingError = AnyError;
+            _onRenderingError = AnyError;
         }
 
         public String Result { get; private set; }
@@ -45,5 +52,35 @@ public bool HasRenderingErrors
             get { return RenderingErrors.Any(); }
         }
 
+        public LiquidRenderingResult OnParsingError(Action<LiquidError> onErrorFn)
+        {
+            EvalWithErrors(onErrorFn, ParsingErrors);
+            return this;
+        }
+
+        public LiquidRenderingResult OnRenderingError(Action<LiquidError> onErrorFn)
+        {
+            EvalWithErrors(onErrorFn, RenderingErrors);
+            return this;
+        }
+
+        public LiquidRenderingResult OnAnyError(Action<LiquidError> onErrorFn)
+        {
+            EvalWithErrors(onErrorFn, RenderingErrors);
+            EvalWithErrors(onErrorFn, ParsingErrors);
+            return this;
+        }
+
+        private void EvalWithErrors(Action<LiquidError> onErrorFn, IList<LiquidError> parsingErrors)
+        {
+            if (onErrorFn != null)
+            {
+                foreach (var err in parsingErrors)
+                {
+                    onErrorFn(err);
+                }
+            }
+          
+        }
     }
 }