Allow customizing FluidParser construction

Author: lahma

src/NJsonSchema.CodeGeneration.Tests/TemplateFactoryTests.cs

@@ -0,0 +1,38 @@
+using System.Reflection;
+using Fluid;
+using NJsonSchema.CodeGeneration.CSharp;
+
+namespace NJsonSchema.CodeGeneration.Tests;
+
+public class TemplateFactoryTests
+{
+    [Fact]
+    public void Can_create_custom_factory_with_custom_liquid_parser()
+    {
+        var generatorSettings = new CSharpGeneratorSettings
+        {
+            TemplateDirectory = "Templates",
+        };
+
+        var factory = new CustomTemplateFactory(generatorSettings, [typeof(CSharpGeneratorSettings).Assembly]);
+        generatorSettings.TemplateFactory = factory;
+
+        var template = factory.CreateTemplate("csharp", "inline-liquid", new { });
+
+        var templateResult = template.Render();
+
+        Assert.Equal("WELCOME TO THE LIQUID TAG", templateResult);
+    }
+}
+
+public sealed class CustomTemplateFactory : DefaultTemplateFactory
+{
+    private readonly LiquidParser _parser;
+
+    public CustomTemplateFactory(CodeGeneratorSettingsBase settings, Assembly[] assemblies) : base(settings, assemblies)
+    {
+        _parser = new LiquidParser(new FluidParserOptions { AllowLiquidTag = true });
+    }
+
+    protected override FluidParser CreateParser() => _parser;
+}

src/NJsonSchema.CodeGeneration.Tests/Templates/inline-liquid.liquid

@@ -0,0 +1,7 @@
+{%
+    liquid
+    echo
+    'welcome ' | upcase
+   echo 'to the liquid tag' 
+    | upcase 
+%}

src/NJsonSchema.CodeGeneration/DefaultTemplateFactory.cs

@@ -10,18 +10,19 @@
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
-using System.Text.Encodings.Web;
 using System.Text.RegularExpressions;
 using Fluid;
-using Fluid.Ast;
 using Fluid.Values;
-using Parlot.Fluent;
 
 namespace NJsonSchema.CodeGeneration
 {
     /// <summary>The default template factory which loads templates from embedded resources.</summary>
     public partial class DefaultTemplateFactory : ITemplateFactory
     {
+        internal const string TemplateTagName = "template";
+
+        private static readonly LiquidParser LiquidParser = new(new FluidParserOptions());
+
         private readonly CodeGeneratorSettingsBase _settings;
         private readonly Assembly[] _assemblies;
         private readonly Func<string, string, string, string> _templateContentLoader;
@@ -44,13 +45,15 @@ public DefaultTemplateFactory(CodeGeneratorSettingsBase settings, Assembly[] ass
         /// <exception cref="InvalidOperationException">Could not load template.</exception>
         public ITemplate CreateTemplate(string language, string template, object model)
         {
-            return new LiquidTemplate(
-                language,
-                template,
-                _templateContentLoader,
-                model,
-                GetToolchainVersion(),
-                _settings);
+            return new LiquidTemplate(CreateParser(), language, template, _templateContentLoader, model, GetToolchainVersion(), _settings);
+        }
+
+        /// <summary>
+        /// Returns an instance of <see cref="FluidParser"/> that will be used when parsing template content.
+        /// </summary>
+        protected virtual FluidParser CreateParser()
+        {
+            return LiquidParser;
         }
 
         /// <summary>Gets the current toolchain version.</summary>
@@ -115,13 +118,10 @@ private sealed partial class LiquidTemplate : ITemplate
         {
             private readonly record struct TemplateKey(string Language, string Template, string TemplateDirectory);
 
-            internal const string TemplateTagName = "template";
             private static readonly ConcurrentDictionary<TemplateKey, IFluidTemplate> Templates = new();
 
             static LiquidTemplate()
             {
-                // thread-safe
-                _parser = new LiquidParser();
                 _templateOptions = new TemplateOptions
                 {
                     MemberAccessStrategy = new UnsafeMemberAccessStrategy(),
@@ -135,14 +135,14 @@ static LiquidTemplate()
                 _templateOptions.Filters.AddFilter("literal", LiquidFilters.Literal);
             }
 
+            private readonly FluidParser _parser;
             private readonly string _language;
             private readonly string _template;
             private readonly Func<string, string, string, string> _templateContentLoader;
             private readonly object _model;
             private readonly string _toolchainVersion;
             private readonly CodeGeneratorSettingsBase _settings;
 
-            private static readonly LiquidParser _parser;
             private static readonly TemplateOptions _templateOptions;
 
             private const string TabCountRegexString = @"(\s*)?\{%(-)?\s+template\s+([a-zA-Z0-9_.]+)(\s*?.*?)\s(-)?%}";
@@ -163,13 +163,15 @@ static LiquidTemplate()
 #endif
 
             public LiquidTemplate(
+                FluidParser parser,
                 string language,
                 string template,
                 Func<string, string, string, string> templateContentLoader,
                 object model,
                 string toolchainVersion,
                 CodeGeneratorSettingsBase settings)
             {
+                _parser = parser;
                 _language = language;
                 _template = template;
                 _templateContentLoader = templateContentLoader;
@@ -323,58 +325,6 @@ public static ValueTask<FluidValue> Literal(FluidValue input, FilterArguments ar
             }
         }
 
-        private sealed class LiquidParser : FluidParser
-        {
-            internal const string LanguageKey = "__language";
-            internal const string TemplateKey = "__template";
-            internal const string SettingsKey = "__settings";
-
-            public LiquidParser()
-            {
-                RegisterParserTag(LiquidTemplate.TemplateTagName, Parsers.OneOrMany(Primary), RenderTemplate);
-            }
-
-            private static ValueTask<Completion> RenderTemplate(
-                IReadOnlyList<Expression> arguments,
-                TextWriter writer,
-                TextEncoder encoder,
-                TemplateContext context)
-            {
-                var templateName = ((LiteralExpression) arguments[0]).Value.ToStringValue();
-
-                var tabCount = -1;
-                if (arguments.Count > 1 && arguments[1] is LiteralExpression literalExpression)
-                {
-                    tabCount = (int) literalExpression.Value.ToNumberValue();
-                }
-
-                var settings = (CodeGeneratorSettingsBase) context.AmbientValues[SettingsKey];
-                var language = (string) context.AmbientValues[LanguageKey];
-                templateName = !string.IsNullOrEmpty(templateName)
-                    ? templateName
-                    : (string) context.AmbientValues[TemplateKey] + "!";
-
-                var template = settings.TemplateFactory.CreateTemplate(language, templateName, context);
-                var output = template.Render();
-
-                if (string.IsNullOrWhiteSpace(output))
-                {
-                    // signal cleanup
-                    writer.Write("__EMPTY-TEMPLATE__");
-                }
-                else if (tabCount > 0)
-                {
-                    ConversionUtilities.Tab(output, tabCount, writer);
-                }
-                else
-                {
-                    writer.Write(output);
-                }
-
-                return new ValueTask<Completion>(Completion.Normal);
-            }
-        }
-
         /// <summary>
         /// Version that allows all access, safe as models are handled by NJsonSchema.
         /// </summary>

src/NJsonSchema.CodeGeneration/LiquidParser.cs

@@ -0,0 +1,65 @@
+using System.Text.Encodings.Web;
+using Fluid;
+using Fluid.Ast;
+using Parlot.Fluent;
+
+namespace NJsonSchema.CodeGeneration;
+
+/// <summary>
+/// A custom Fluid parser that can handle NJsonSchema Fluid extensions and customizations.
+/// </summary>
+public sealed class LiquidParser : FluidParser
+{
+    internal const string LanguageKey = "__language";
+    internal const string TemplateKey = "__template";
+    internal const string SettingsKey = "__settings";
+
+    /// <summary>
+    /// Creates a new instance of custom Liquid parser that can handle NJsonSchema templates.
+    /// </summary>
+    /// <param name="options"></param>
+    public LiquidParser(FluidParserOptions options) : base(options)
+    {
+        RegisterParserTag(DefaultTemplateFactory.TemplateTagName, Parsers.OneOrMany(Primary), RenderTemplate);
+    }
+
+    private static ValueTask<Completion> RenderTemplate(
+        IReadOnlyList<Expression> arguments,
+        TextWriter writer,
+        TextEncoder encoder,
+        TemplateContext context)
+    {
+        var templateName = ((LiteralExpression)arguments[0]).Value.ToStringValue();
+
+        var tabCount = -1;
+        if (arguments.Count > 1 && arguments[1] is LiteralExpression literalExpression)
+        {
+            tabCount = (int)literalExpression.Value.ToNumberValue();
+        }
+
+        var settings = (CodeGeneratorSettingsBase)context.AmbientValues[SettingsKey];
+        var language = (string)context.AmbientValues[LanguageKey];
+        templateName = !string.IsNullOrEmpty(templateName)
+            ? templateName
+            : (string)context.AmbientValues[TemplateKey] + "!";
+
+        var template = settings.TemplateFactory.CreateTemplate(language, templateName, context);
+        var output = template.Render();
+
+        if (string.IsNullOrWhiteSpace(output))
+        {
+            // signal cleanup
+            writer.Write("__EMPTY-TEMPLATE__");
+        }
+        else if (tabCount > 0)
+        {
+            ConversionUtilities.Tab(output, tabCount, writer);
+        }
+        else
+        {
+            writer.Write(output);
+        }
+
+        return new ValueTask<Completion>(Completion.Normal);
+    }
+}