Refactor Transformer (add Scriban) (#562)

Directory.Build.props

@@ -4,7 +4,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <VersionPrefix>1.4.0</VersionPrefix>
+    <VersionPrefix>1.4.1</VersionPrefix>
     <PackageReleaseNotes>See CHANGELOG.md</PackageReleaseNotes>
     <PackageIconUrl>https://raw.githubusercontent.com/WireMock-Net/WireMock.Net/master/WireMock.Net-Logo.png</PackageIconUrl>
     <PackageProjectUrl>https://github.com/WireMock-Net/WireMock.Net</PackageProjectUrl>

examples/WireMock.Net.Console.Net452.Classic/MainApp.cs

@@ -13,6 +13,7 @@ using WireMock.Server;
 using WireMock.Settings;
 using WireMock.Util;
 using System.Threading.Tasks;
+using WireMock.Types;
 
 namespace WireMock.Net.ConsoleApplication
 {
@@ -346,7 +347,7 @@ namespace WireMock.Net.ConsoleApplication
                     .WithHeader("Transformed-Postman-Token", "token is {{request.headers.Postman-Token}}")
                     .WithHeader("xyz_{{request.headers.Postman-Token}}", "token is {{request.headers.Postman-Token}}")
                     .WithBody(@"{""msg"": ""Hello world CATCH-ALL on /*, {{request.path}}, add={{Math.Add request.query.start.[0] 42}} bykey={{request.query.start}}, bykey={{request.query.stop}}, byidx0={{request.query.stop.[0]}}, byidx1={{request.query.stop.[1]}}"" }")
-                    .WithTransformer()
+                    .WithTransformer(TransformerType.Handlebars)
                     .WithDelay(TimeSpan.FromMilliseconds(100))
                 );
 

src/WireMock.Net.Abstractions/Admin/Mappings/ResponseModel.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using WireMock.Types;
 
 namespace WireMock.Admin.Mappings
 {
@@ -53,10 +54,15 @@ namespace WireMock.Admin.Mappings
         public EncodingModel BodyEncoding { get; set; }
 
         /// <summary>
-        /// Use Handlebars transformer.
+        /// Use ResponseMessage Transformer.
         /// </summary>
         public bool? UseTransformer { get; set; }
 
+        /// <summary>
+        /// Gets the type of the transformer.
+        /// </summary>
+        public string TransformerType { get; set; }
+
         /// <summary>
         /// Use the Handlerbars transformer for the content from the referenced BodyAsFile.
         /// </summary>

src/WireMock.Net.Abstractions/Types/TransformerType.cs

@@ -0,0 +1,23 @@
+namespace WireMock.Types
+{
+    /// <summary>
+    /// The ResponseMessage Transformers
+    /// </summary>
+    public enum TransformerType
+    {
+        /// <summary>
+        /// https://github.com/Handlebars-Net/Handlebars.Net
+        /// </summary>
+        Handlebars,
+
+        /// <summary>
+        /// https://github.com/scriban/scriban : default
+        /// </summary>
+        Scriban,
+
+        /// <summary>
+        /// https://github.com/scriban/scriban : DotLiquid
+        /// </summary>
+        ScribanDotLiquid
+    }
+}

src/WireMock.Net/ResponseBuilders/ITransformResponseBuilder.cs

@@ -1,4 +1,6 @@
-namespace WireMock.ResponseBuilders
+using WireMock.Types;
+
+namespace WireMock.ResponseBuilders
 {
     /// <summary>
     /// The TransformResponseBuilder interface.
@@ -6,11 +8,19 @@
     public interface ITransformResponseBuilder : IDelayResponseBuilder
     {
         /// <summary>
-        /// The with transformer.
+        /// Use the Handlebars.Net ResponseMessage transformer.
         /// </summary>
         /// <returns>
         /// The <see cref="IResponseBuilder"/>.
         /// </returns>
         IResponseBuilder WithTransformer(bool transformContentFromBodyAsFile = false);
+
+        /// <summary>
+        /// Use a specific ResponseMessage transformer.
+        /// </summary>
+        /// <returns>
+        /// The <see cref="IResponseBuilder"/>.
+        /// </returns>
+        IResponseBuilder WithTransformer(TransformerType transformerType, bool transformContentFromBodyAsFile = false);
     }
 }

src/WireMock.Net/ResponseBuilders/Response.cs

@@ -11,6 +11,8 @@ using WireMock.Proxy;
 using WireMock.ResponseProviders;
 using WireMock.Settings;
 using WireMock.Transformers;
+using WireMock.Transformers.Handlebars;
+using WireMock.Transformers.Scriban;
 using WireMock.Types;
 using WireMock.Util;
 using WireMock.Validation;
@@ -32,6 +34,11 @@ namespace WireMock.ResponseBuilders
         /// </summary>
         public bool UseTransformer { get; private set; }
 
+        /// <summary>
+        /// Gets the type of the transformer.
+        /// </summary>
+        public TransformerType TransformerType { get; private set; }
+
         /// <summary>
         /// Gets a value indicating whether to use the Handlerbars transformer for the content from the referenced BodyAsFile.
         /// </summary>
@@ -282,6 +289,16 @@ namespace WireMock.ResponseBuilders
         public IResponseBuilder WithTransformer(bool transformContentFromBodyAsFile = false)
         {
             UseTransformer = true;
+            TransformerType = TransformerType.Handlebars;
+            UseTransformerForBodyAsFile = transformContentFromBodyAsFile;
+            return this;
+        }
+
+        /// <inheritdoc cref="ITransformResponseBuilder.WithTransformer(TransformerType, bool)"/>
+        public IResponseBuilder WithTransformer(TransformerType transformerType, bool transformContentFromBodyAsFile = false)
+        {
+            UseTransformer = true;
+            TransformerType = transformerType;
             UseTransformerForBodyAsFile = transformContentFromBodyAsFile;
             return this;
         }
@@ -328,7 +345,7 @@ namespace WireMock.ResponseBuilders
 
                 var proxyHelper = new ProxyHelper(settings);
 
-                var (proxyResponseMessage, mapping) = await proxyHelper.SendAsync(
+                var (proxyResponseMessage, _) = await proxyHelper.SendAsync(
                     ProxyAndRecordSettings,
                     _httpClientForProxy,
                     requestMessage,
@@ -369,8 +386,24 @@ namespace WireMock.ResponseBuilders
 
             if (UseTransformer)
             {
-                var factory = new HandlebarsContextFactory(settings.FileSystemHandler, settings.HandlebarsRegistrationCallback);
-                var responseMessageTransformer = new ResponseMessageTransformer(factory);
+                ITransformer responseMessageTransformer;
+                switch (TransformerType)
+                {
+                    case TransformerType.Handlebars:
+                        var factoryHandlebars = new HandlebarsContextFactory(settings.FileSystemHandler, settings.HandlebarsRegistrationCallback);
+                        responseMessageTransformer = new Transformer(factoryHandlebars);
+                        break;
+
+                    case TransformerType.Scriban:
+                    case TransformerType.ScribanDotLiquid:
+                        var factoryDotLiquid = new ScribanContextFactory(settings.FileSystemHandler, TransformerType);
+                        responseMessageTransformer = new Transformer(factoryDotLiquid);
+                        break;
+
+                    default:
+                        throw new NotImplementedException($"TransformerType '{TransformerType}' is not supported.");
+                }
+
                 return responseMessageTransformer.Transform(requestMessage, responseMessage, UseTransformerForBodyAsFile);
             }
 

src/WireMock.Net/Serialization/MappingConverter.cs

@@ -113,6 +113,7 @@ namespace WireMock.Serialization
                 mappingModel.Response.BodyAsFile = null;
                 mappingModel.Response.BodyAsFileIsCached = null;
                 mappingModel.Response.UseTransformer = null;
+                mappingModel.Response.TransformerType = null;
                 mappingModel.Response.UseTransformerForBodyAsFile = null;
                 mappingModel.Response.BodyEncoding = null;
                 mappingModel.Response.ProxyUrl = response.ProxyAndRecordSettings.Url;
@@ -133,6 +134,7 @@ namespace WireMock.Serialization
                 if (response.UseTransformer)
                 {
                     mappingModel.Response.UseTransformer = response.UseTransformer;
+                    mappingModel.Response.TransformerType = response.TransformerType.ToString();
                 }
 
                 if (response.UseTransformerForBodyAsFile)

src/WireMock.Net/Server/WireMockServer.Admin.cs

@@ -770,7 +770,11 @@ namespace WireMock.Server
 
             if (responseModel.UseTransformer == true)
             {
-                responseBuilder = responseBuilder.WithTransformer(responseModel.UseTransformerForBodyAsFile == true);
+                if (!Enum.TryParse<TransformerType>(responseModel.TransformerType, out var transformerType))
+                {
+                    transformerType = TransformerType.Handlebars;
+                }
+                responseBuilder = responseBuilder.WithTransformer(transformerType, responseModel.UseTransformerForBodyAsFile == true);
             }
 
             if (!string.IsNullOrEmpty(responseModel.ProxyUrl))

src/WireMock.Net/Transformers/Handlebars/HandlebarsContext.cs

@@ -1,11 +1,19 @@
 using HandlebarsDotNet;
 using WireMock.Handlers;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal class HandlebarsContext : IHandlebarsContext
     {
         public IHandlebars Handlebars { get; set; }
+
         public IFileSystemHandler FileSystemHandler { get; set; }
+
+        public string ParseAndRender(string text, object model)
+        {
+            var template = Handlebars.Compile(text);
+
+            return template(model);
+        }
     }
 }

src/WireMock.Net/Transformers/Handlebars/HandlebarsContextFactory.cs

@@ -1,10 +1,11 @@
 using System;
 using HandlebarsDotNet;
+using JetBrains.Annotations;
 using WireMock.Handlers;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
-    internal class HandlebarsContextFactory : IHandlebarsContextFactory
+    internal class HandlebarsContextFactory : ITransformerContextFactory
     {
         private static readonly HandlebarsConfiguration HandlebarsConfiguration = new HandlebarsConfiguration
         {
@@ -14,15 +15,15 @@ namespace WireMock.Transformers
         private readonly IFileSystemHandler _fileSystemHandler;
         private readonly Action<IHandlebars, IFileSystemHandler> _action;
 
-        public HandlebarsContextFactory(IFileSystemHandler fileSystemHandler, Action<IHandlebars, IFileSystemHandler> action)
+        public HandlebarsContextFactory([NotNull] IFileSystemHandler fileSystemHandler, [CanBeNull] Action<IHandlebars, IFileSystemHandler> action)
         {
-            _fileSystemHandler = fileSystemHandler;
+            _fileSystemHandler = fileSystemHandler ?? throw new ArgumentNullException(nameof(fileSystemHandler));
             _action = action;
         }
 
-        public IHandlebarsContext Create()
+        public ITransformerContext Create()
         {
-            var handlebars = Handlebars.Create(HandlebarsConfiguration);
+            var handlebars = HandlebarsDotNet.Handlebars.Create(HandlebarsConfiguration);
 
             WireMockHandlebarsHelpers.Register(handlebars, _fileSystemHandler);
 

src/WireMock.Net/Transformers/Handlebars/HandlebarsFile.cs

@@ -3,7 +3,7 @@ using System;
 using WireMock.Handlers;
 using WireMock.Validation;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsFile
     {

src/WireMock.Net/Transformers/Handlebars/HandlebarsJsonPath.cs

@@ -7,7 +7,7 @@ using System.Linq;
 using WireMock.Util;
 using WireMock.Validation;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsJsonPath
     {

src/WireMock.Net/Transformers/Handlebars/HandlebarsLinq.cs

@@ -7,7 +7,7 @@ using Newtonsoft.Json.Linq;
 using WireMock.Util;
 using WireMock.Validation;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsLinq
     {

src/WireMock.Net/Transformers/Handlebars/HandlebarsRandom.cs

@@ -9,7 +9,7 @@ using RandomDataGenerator.FieldOptions;
 using RandomDataGenerator.Randomizers;
 using WireMock.Validation;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsRandom
     {

src/WireMock.Net/Transformers/Handlebars/HandlebarsRegex.cs

@@ -5,7 +5,7 @@ using HandlebarsDotNet;
 using WireMock.Util;
 using WireMock.Validation;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsRegex
     {

src/WireMock.Net/Transformers/Handlebars/HandlebarsXPath.cs

@@ -8,7 +8,7 @@ using WireMock.Validation;
 using Wmhelp.XPath2;
 #endif
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsXPath
     {

src/WireMock.Net/Transformers/Handlebars/HandlebarsXeger.cs

@@ -3,7 +3,7 @@ using Fare;
 using HandlebarsDotNet;
 using WireMock.Validation;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsXeger
     {

src/WireMock.Net/Transformers/Handlebars/IHandlebarsContext.cs

@@ -0,0 +1,9 @@
+using HandlebarsDotNet;
+
+namespace WireMock.Transformers.Handlebars
+{
+    interface IHandlebarsContext : ITransformerContext
+    {
+        IHandlebars Handlebars { get; set; }
+    }
+}

src/WireMock.Net/Transformers/Handlebars/WireMockHandlebarsHelpers.cs

@@ -2,7 +2,7 @@
 using HandlebarsDotNet.Helpers;
 using WireMock.Handlers;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class WireMockHandlebarsHelpers
     {

src/WireMock.Net/Transformers/IHandlebarsContext.cs

@@ -1,12 +0,0 @@
-using HandlebarsDotNet;
-using WireMock.Handlers;
-
-namespace WireMock.Transformers
-{
-    interface IHandlebarsContext
-    {
-        IHandlebars Handlebars { get; set; }
-
-        IFileSystemHandler FileSystemHandler { get; set; }
-    }
-}

src/WireMock.Net/Transformers/IHandlebarsContextFactory.cs

@@ -1,7 +0,0 @@
-namespace WireMock.Transformers
-{
-    interface IHandlebarsContextFactory
-    {
-        IHandlebarsContext Create();
-    }
-}

src/WireMock.Net/Transformers/ITransformer.cs

@@ -0,0 +1,7 @@
+namespace WireMock.Transformers
+{
+    interface ITransformer
+    {
+        ResponseMessage Transform(RequestMessage requestMessage, ResponseMessage original, bool useTransformerForBodyAsFile);
+    }
+}

src/WireMock.Net/Transformers/ITransformerContext.cs

@@ -0,0 +1,11 @@
+using WireMock.Handlers;
+
+namespace WireMock.Transformers
+{
+    interface ITransformerContext
+    {
+        IFileSystemHandler FileSystemHandler { get; set; }
+
+        string ParseAndRender(string text, object model);
+    }
+}

src/WireMock.Net/Transformers/ITransformerContextFactory.cs

@@ -0,0 +1,7 @@
+namespace WireMock.Transformers
+{
+    interface ITransformerContextFactory
+    {
+        ITransformerContext Create();
+    }
+}

src/WireMock.Net/Transformers/Scriban/ScribanContext.cs

@@ -0,0 +1,27 @@
+using System;
+using Scriban;
+using WireMock.Handlers;
+using WireMock.Types;
+
+namespace WireMock.Transformers.Scriban
+{
+    internal class ScribanContext : ITransformerContext
+    {
+        private readonly TransformerType _transformerType;
+
+        public IFileSystemHandler FileSystemHandler { get; set; }
+
+        public ScribanContext(IFileSystemHandler fileSystemHandler, TransformerType transformerType)
+        {
+            FileSystemHandler = fileSystemHandler ?? throw new ArgumentNullException(nameof(fileSystemHandler));
+            _transformerType = transformerType;
+        }
+
+        public string ParseAndRender(string text, object model)
+        {
+            var template = _transformerType == TransformerType.ScribanDotLiquid ? Template.ParseLiquid(text) : Template.Parse(text);
+
+            return template.Render(model, member => member.Name);
+        }
+    }
+}

src/WireMock.Net/Transformers/Scriban/ScribanContextFactory.cs

@@ -0,0 +1,26 @@
+using WireMock.Handlers;
+using WireMock.Types;
+using WireMock.Validation;
+
+namespace WireMock.Transformers.Scriban
+{
+    internal class ScribanContextFactory : ITransformerContextFactory
+    {
+        private readonly IFileSystemHandler _fileSystemHandler;
+        private readonly TransformerType _transformerType;
+
+        public ScribanContextFactory(IFileSystemHandler fileSystemHandler, TransformerType transformerType)
+        {
+            Check.NotNull(fileSystemHandler, nameof(fileSystemHandler));
+            Check.Condition(transformerType, t => t == TransformerType.Scriban || t == TransformerType.ScribanDotLiquid, nameof(transformerType));
+
+            _fileSystemHandler = fileSystemHandler;
+            _transformerType = transformerType;
+        }
+
+        public ITransformerContext Create()
+        {
+            return new ScribanContext(_fileSystemHandler, _transformerType);
+        }
+    }
+}

src/WireMock.Net/Transformers/Scriban/WireMockListAccessor.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using Scriban;
+using Scriban.Parsing;
+using Scriban.Runtime;
+
+namespace WireMock.Transformers.Scriban
+{
+    internal class WireMockListAccessor : IListAccessor, IObjectAccessor
+    {
+        #region IListAccessor
+        public int GetLength(TemplateContext context, SourceSpan span, object target)
+        {
+            throw new NotImplementedException();
+        }
+
+        public object GetValue(TemplateContext context, SourceSpan span, object target, int index)
+        {
+            return target.ToString();
+        }
+
+        public void SetValue(TemplateContext context, SourceSpan span, object target, int index, object value)
+        {
+            throw new NotImplementedException();
+        }
+        #endregion
+
+        #region IObjectAccessor
+        public int GetMemberCount(TemplateContext context, SourceSpan span, object target)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerable<string> GetMembers(TemplateContext context, SourceSpan span, object target)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool HasMember(TemplateContext context, SourceSpan span, object target, string member)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool TryGetValue(TemplateContext context, SourceSpan span, object target, string member, out object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool TrySetValue(TemplateContext context, SourceSpan span, object target, string member, object value)
+        {
+            throw new NotImplementedException();
+        }
+        #endregion
+    }
+}

src/WireMock.Net/Transformers/Scriban/WireMockTemplateContext.cs

@@ -0,0 +1,19 @@
+using Scriban;
+using Scriban.Runtime;
+using WireMock.Types;
+
+namespace WireMock.Transformers.Scriban
+{
+    internal class WireMockTemplateContext: TemplateContext
+    {
+        protected override IObjectAccessor GetMemberAccessorImpl(object target)
+        {
+            if (target?.GetType().GetGenericTypeDefinition() == typeof(WireMockList<>))
+            {
+                return new WireMockListAccessor();
+            }
+
+            return base.GetMemberAccessorImpl(target);
+        }
+    }
+}

src/WireMock.Net/Transformers/Transformer.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using HandlebarsDotNet;
 using JetBrains.Annotations;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
@@ -9,13 +8,13 @@ using WireMock.Types;
 using WireMock.Util;
 using WireMock.Validation;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
-    internal class ResponseMessageTransformer
+    internal class Transformer : ITransformer
     {
-        private readonly IHandlebarsContextFactory _factory;
+        private readonly ITransformerContextFactory _factory;
 
-        public ResponseMessageTransformer([NotNull] IHandlebarsContextFactory factory)
+        public Transformer([NotNull] ITransformerContextFactory factory)
         {
             Check.NotNull(factory, nameof(factory));
 
@@ -28,21 +27,21 @@ namespace WireMock.Transformers
 
             var responseMessage = new ResponseMessage();
 
-            var template = new { request = requestMessage };
+            var model = new { request = requestMessage };
 
             switch (original.BodyData?.DetectedBodyType)
             {
                 case BodyType.Json:
-                    TransformBodyAsJson(handlebarsContext.Handlebars, template, original, responseMessage);
+                    TransformBodyAsJson(handlebarsContext, model, original, responseMessage);
                     break;
 
                 case BodyType.File:
-                    TransformBodyAsFile(handlebarsContext, template, original, responseMessage, useTransformerForBodyAsFile);
+                    TransformBodyAsFile(handlebarsContext, model, original, responseMessage, useTransformerForBodyAsFile);
                     break;
 
                 case BodyType.String:
                     responseMessage.BodyOriginal = original.BodyData.BodyAsString;
-                    TransformBodyAsString(handlebarsContext.Handlebars, template, original, responseMessage);
+                    TransformBodyAsString(handlebarsContext, model, original, responseMessage);
                     break;
             }
 
@@ -53,13 +52,12 @@ namespace WireMock.Transformers
             var newHeaders = new Dictionary<string, WireMockList<string>>();
             foreach (var header in original.Headers)
             {
-                var templateHeaderKey = handlebarsContext.Handlebars.Compile(header.Key);
+                var headerKey = handlebarsContext.ParseAndRender(header.Key, model);
                 var templateHeaderValues = header.Value
-                    .Select(handlebarsContext.Handlebars.Compile)
-                    .Select(func => func(template))
+                    .Select(text => handlebarsContext.ParseAndRender(text, model))
                     .ToArray();
 
-                newHeaders.Add(templateHeaderKey(template), new WireMockList<string>(templateHeaderValues));
+                newHeaders.Add(headerKey, new WireMockList<string>(templateHeaderValues));
             }
 
             responseMessage.Headers = newHeaders;
@@ -71,36 +69,35 @@ namespace WireMock.Transformers
                     break;
 
                 case string statusCodeAsString:
-                    var templateForStatusCode = handlebarsContext.Handlebars.Compile(statusCodeAsString);
-                    responseMessage.StatusCode = templateForStatusCode(template);
+                    responseMessage.StatusCode = handlebarsContext.ParseAndRender(statusCodeAsString, model);
                     break;
             }
 
             return responseMessage;
         }
 
-        private static void TransformBodyAsJson(IHandlebars handlebarsContext, object template, ResponseMessage original, ResponseMessage responseMessage)
+        private static void TransformBodyAsJson(ITransformerContext handlebarsContext, object model, ResponseMessage original, ResponseMessage responseMessage)
         {
             JToken jToken;
             switch (original.BodyData.BodyAsJson)
             {
                 case JObject bodyAsJObject:
                     jToken = bodyAsJObject.DeepClone();
-                    WalkNode(handlebarsContext, jToken, template);
+                    WalkNode(handlebarsContext, jToken, model);
                     break;
 
                 case Array bodyAsArray:
                     jToken = JArray.FromObject(bodyAsArray);
-                    WalkNode(handlebarsContext, jToken, template);
+                    WalkNode(handlebarsContext, jToken, model);
                     break;
 
                 case string bodyAsString:
-                    jToken = ReplaceSingleNode(handlebarsContext, bodyAsString, template);
+                    jToken = ReplaceSingleNode(handlebarsContext, bodyAsString, model);
                     break;
 
                 default:
                     jToken = JObject.FromObject(original.BodyData.BodyAsJson);
-                    WalkNode(handlebarsContext, jToken, template);
+                    WalkNode(handlebarsContext, jToken, model);
                     break;
             }
 
@@ -113,10 +110,10 @@ namespace WireMock.Transformers
             };
         }
 
-        private static JToken ReplaceSingleNode(IHandlebars handlebarsContext, string stringValue, object context)
+        private static JToken ReplaceSingleNode(ITransformerContext handlebarsContext, string stringValue, object model)
         {
-            var templateForStringValue = handlebarsContext.Compile(stringValue);
-            string transformedString = templateForStringValue(context);
+            string transformedString = handlebarsContext.ParseAndRender(stringValue, model);
+
             if (!string.Equals(stringValue, transformedString))
             {
                 const string property = "_";
@@ -131,14 +128,14 @@ namespace WireMock.Transformers
             return stringValue;
         }
 
-        private static void WalkNode(IHandlebars handlebarsContext, JToken node, object context)
+        private static void WalkNode(ITransformerContext handlebarsContext, JToken node, object model)
         {
             if (node.Type == JTokenType.Object)
             {
                 // In case of Object, loop all children. Do a ToArray() to avoid `Collection was modified` exceptions.
                 foreach (JProperty child in node.Children<JProperty>().ToArray())
                 {
-                    WalkNode(handlebarsContext, child.Value, context);
+                    WalkNode(handlebarsContext, child.Value, model);
                 }
             }
             else if (node.Type == JTokenType.Array)
@@ -146,7 +143,7 @@ namespace WireMock.Transformers
                 // In case of Array, loop all items. Do a ToArray() to avoid `Collection was modified` exceptions.
                 foreach (JToken child in node.Children().ToArray())
                 {
-                    WalkNode(handlebarsContext, child, context);
+                    WalkNode(handlebarsContext, child, model);
                 }
             }
             else if (node.Type == JTokenType.String)
@@ -158,8 +155,7 @@ namespace WireMock.Transformers
                     return;
                 }
 
-                var templateForStringValue = handlebarsContext.Compile(stringValue);
-                string transformedString = templateForStringValue(context);
+                string transformedString = handlebarsContext.ParseAndRender(stringValue, model);
                 if (!string.Equals(stringValue, transformedString))
                 {
                     ReplaceNodeValue(node, transformedString);
@@ -190,23 +186,20 @@ namespace WireMock.Transformers
             node.Replace(value);
         }
 
-        private static void TransformBodyAsString(IHandlebars handlebarsContext, object template, ResponseMessage original, ResponseMessage responseMessage)
+        private static void TransformBodyAsString(ITransformerContext handlebarsContext, object model, ResponseMessage original, ResponseMessage responseMessage)
         {
-            var templateBodyAsString = handlebarsContext.Compile(original.BodyData.BodyAsString);
-
             responseMessage.BodyData = new BodyData
             {
                 Encoding = original.BodyData.Encoding,
                 DetectedBodyType = original.BodyData.DetectedBodyType,
                 DetectedBodyTypeFromContentType = original.BodyData.DetectedBodyTypeFromContentType,
-                BodyAsString = templateBodyAsString(template)
+                BodyAsString = handlebarsContext.ParseAndRender(original.BodyData.BodyAsString, model)
             };
         }
 
-        private void TransformBodyAsFile(IHandlebarsContext handlebarsContext, object template, ResponseMessage original, ResponseMessage responseMessage, bool useTransformerForBodyAsFile)
+        private void TransformBodyAsFile(ITransformerContext handlebarsContext, object model, ResponseMessage original, ResponseMessage responseMessage, bool useTransformerForBodyAsFile)
         {
-            var templateBodyAsFile = handlebarsContext.Handlebars.Compile(original.BodyData.BodyAsFile);
-            string transformedBodyAsFilename = templateBodyAsFile(template);
+            string transformedBodyAsFilename = handlebarsContext.ParseAndRender(original.BodyData.BodyAsFile, model);
 
             if (!useTransformerForBodyAsFile)
             {
@@ -220,13 +213,12 @@ namespace WireMock.Transformers
             else
             {
                 string text = handlebarsContext.FileSystemHandler.ReadResponseBodyAsString(transformedBodyAsFilename);
-                var templateBodyAsString = handlebarsContext.Handlebars.Compile(text);
 
                 responseMessage.BodyData = new BodyData
                 {
                     DetectedBodyType = BodyType.String,
                     DetectedBodyTypeFromContentType = original.BodyData.DetectedBodyTypeFromContentType,
-                    BodyAsString = templateBodyAsString(template),
+                    BodyAsString = handlebarsContext.ParseAndRender(text, model),
                     BodyAsFile = transformedBodyAsFilename
                 };
             }

src/WireMock.Net/WireMock.Net.csproj

@@ -50,6 +50,12 @@
     <DefineConstants>USE_ASPNETCORE;NET46</DefineConstants>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Remove="Transformers\Scriban\ScribanTransformer.cs" />
+    <Compile Remove="Transformers\Scriban\WireMockListAccessor.cs" />
+    <Compile Remove="Transformers\Scriban\WireMockTemplateContext.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="JetBrains.Annotations" Version="2020.1.0" PrivateAssets="All" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
@@ -59,6 +65,7 @@
     <PackageReference Include="RandomDataGenerator.Net" Version="1.0.12" />
     <PackageReference Include="JmesPath.Net" Version="1.0.125" />
     <PackageReference Include="Handlebars.Net.Helpers" Version="1.1.0" />
+	  <!--<PackageReference Include="DotLiquid" Version="2.0.366" />-->
   </ItemGroup>
 
   <ItemGroup Condition="'$(Configuration)' == 'Debug - Sonar'">
@@ -78,6 +85,7 @@
 
     <PackageReference Include="Microsoft.AspNet.WebApi.OwinSelfHost" Version="5.2.6" />
     <PackageReference Include="System.ValueTuple" Version="4.5.0" />
+    <PackageReference Include="Scriban.Signed" Version="2.1.4" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net46' ">
@@ -87,9 +95,11 @@
     <PackageReference Include="Microsoft.Owin.Hosting" Version="4.0.0" />
     <PackageReference Include="System.Net.Http" Version="4.3.3" />
     <PackageReference Include="System.ValueTuple" Version="4.5.0" />
+    <PackageReference Include="Scriban.Signed" Version="2.1.4" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net461' ">
+    <PackageReference Include="Scriban.Signed" Version="2.1.4" />
     <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
 
     <!-- https://github.com/WireMock-Net/WireMock.Net/issues/507 -->
@@ -102,9 +112,11 @@
     <PackageReference Include="System.Xml.XmlDocument" Version="4.3.0" />
     <PackageReference Include="System.Xml.XPath.XmlDocument" Version="4.3.0" />
     <PackageReference Include="System.ValueTuple" Version="4.5.0" />
+    <PackageReference Include="Scriban.Signed" Version="2.1.4" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'netstandard2.1' ">
+    <PackageReference Include="Scriban.Signed" Version="3.3.2" />
     <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
 
     <!-- https://github.com/WireMock-Net/WireMock.Net/issues/507 -->
@@ -113,6 +125,7 @@
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp3.1' or '$(TargetFramework)' == 'net5.0'">
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
+    <PackageReference Include="Scriban.Signed" Version="3.3.2" />
   </ItemGroup>
 
   <ItemGroup>

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithBodyTests.cs

@@ -1,8 +1,10 @@
 using System;
 using System.Text;
 using System.Threading.Tasks;
+using Moq;
 using Newtonsoft.Json.Linq;
 using NFluent;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -14,9 +16,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithBodyTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithBodyTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponse_WithBody_Bytes_Encoding_Destination_String()
         {

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithCallbackTests.cs

@@ -1,5 +1,7 @@
 using System.Threading.Tasks;
 using FluentAssertions;
+using Moq;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -11,8 +13,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithCallbackTests
     {
+        private const string ClientIp = "::1";
+
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
         private readonly WireMockServerSettings _settings = new WireMockServerSettings();
 
+        public ResponseWithCallbackTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_WithCallbackAsync()
         {

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsHelpersTests.cs

@@ -1,5 +1,7 @@
 using System.Threading.Tasks;
+using Moq;
 using NFluent;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -11,9 +13,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsHelpersTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithHandlebarsHelpersTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponseAsync_HandlebarsHelpers_String_Uppercase()
         {

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsJsonPathTests.cs

@@ -1,7 +1,11 @@
 using System;
+using System.Text;
 using System.Threading.Tasks;
+using Moq;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using NFluent;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -13,9 +17,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsJsonPathTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithHandlebarsJsonPathTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponse_Handlebars_JsonPath_SelectToken_Object_ResponseBodyAsJson()
         {
@@ -333,5 +347,32 @@ namespace WireMock.Net.Tests.ResponseBuilders
             // Act
             Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<ArgumentNullException>();
         }
+
+        [Fact]
+        public async Task Response_ProvideResponse_Transformer_WithBodyAsFile_JsonPath()
+        {
+            // Assign
+            string jsonString = "{ \"MyUniqueNumber\": \"1\" }";
+            var bodyData = new BodyData
+            {
+                BodyAsString = jsonString,
+                BodyAsJson = JsonConvert.DeserializeObject(jsonString),
+                DetectedBodyType = BodyType.Json,
+                DetectedBodyTypeFromContentType = BodyType.Json,
+                Encoding = Encoding.UTF8
+            };
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, bodyData);
+
+            string jsonPath = "\"$.MyUniqueNumber\"";
+            var response = Response.Create()
+                .WithTransformer()
+                .WithBodyFromFile(@"c:\\{{JsonPath.SelectToken request.body " + jsonPath + "}}\\test.json"); // why use a \\ here ?
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request, _settings);
+
+            // Assert
+            Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.json");
+        }
     }
 }

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsLinqTests.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Threading.Tasks;
+using Moq;
 using Newtonsoft.Json.Linq;
 using NFluent;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -13,8 +15,17 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsLinqTests
     {
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
         private readonly WireMockServerSettings _settings = new WireMockServerSettings();
 
+        public ResponseWithHandlebarsLinqTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponse_Handlebars_Linq1_String0()
         {

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsRandomTests.cs

@@ -1,7 +1,9 @@
 using System.Linq;
 using System.Threading.Tasks;
+using Moq;
 using Newtonsoft.Json.Linq;
 using NFluent;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -11,9 +13,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsRandomTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithHandlebarsRandomTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponseAsync_Handlebars_Random1()
         {

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsRegexTests.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Threading.Tasks;
+using Moq;
 using NFluent;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -12,9 +14,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsRegexTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithHandlebarsRegexTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponseAsync_Handlebars_RegexMatch()
         {

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsXPathTests.cs

@@ -7,6 +7,8 @@ using WireMock.Settings;
 using WireMock.Types;
 using WireMock.Util;
 using Xunit;
+using Moq;
+using WireMock.Handlers;
 #if !NETSTANDARD1_3
 using Wmhelp.XPath2;
 #endif
@@ -15,9 +17,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsXPathTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithHandlebarsXPathTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponse_Handlebars_XPath_SelectSingleNode_Request_BodyAsString()
         {

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsXegerTests.cs

@@ -2,6 +2,7 @@
 using Newtonsoft.Json.Linq;
 using NFluent;
 using System.Threading.Tasks;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -11,9 +12,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsXegerTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithHandlebarsXegerTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponseAsync_Handlebars_Xeger1()
         {

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithScribanTests.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Threading.Tasks;
+using FluentAssertions;
+using NFluent;
+using WireMock.Models;
+using WireMock.ResponseBuilders;
+using WireMock.Settings;
+using WireMock.Types;
+using WireMock.Util;
+using Xunit;
+using WireMock.Handlers;
+using Moq;
+#if NET452
+using Microsoft.Owin;
+#else
+using Microsoft.AspNetCore.Http;
+#endif
+
+namespace WireMock.Net.Tests.ResponseBuilders
+{
+    public class ResponseWithScribanTests
+    {
+        private const string ClientIp = "::1";
+
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithScribanTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_DotLiquid_WithNullBody_ShouldNotThrowException()
+        {
+            // Assign
+            var urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
+            var request = new RequestMessage(urlDetails, "GET", ClientIp);
+
+            var response = Response.Create().WithTransformer(TransformerType.ScribanDotLiquid);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request, _settings);
+
+            // Assert
+            responseMessage.BodyData.Should().BeNull();
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_DotLiquid_UrlPathVerb()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsString = "whatever",
+                DetectedBodyType = BodyType.String
+            };
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POSt", ClientIp, body);
+
+            var response = Response.Create()
+                .WithBody("test {{request.Url}} {{request.Path}} {{request.Method}}")
+                .WithTransformer(TransformerType.Scriban);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request, _settings);
+
+            // Assert
+            Check.That(responseMessage.BodyData.BodyAsString).Equals("test http://localhost/foo /foo POSt");
+        }
+    }
+}

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithTransformerTests.cs

@@ -21,20 +21,32 @@ using Microsoft.AspNetCore.Http;
 
 namespace WireMock.Net.Tests.ResponseBuilders
 {
-    public class ResponseWithHandlebarsTests
+    public class ResponseWithTransformerTests
     {
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
         private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
         private const string ClientIp = "::1";
 
-        [Fact]
-        public async Task Response_ProvideResponse_Handlebars_WithNullBody_ShouldNotThrowException()
+        public ResponseWithTransformerTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
+        [Theory]
+        [InlineData(TransformerType.Handlebars)]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Transformer_WithNullBody_ShouldNotThrowException(TransformerType transformerType)
         {
             // Assign
             var urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
             var request = new RequestMessage(urlDetails, "GET", ClientIp);
 
-            var response = Response.Create()
-                .WithTransformer();
+            var response = Response.Create().WithTransformer(transformerType);
 
             // Act
             var responseMessage = await response.ProvideResponseAsync(request, _settings);
@@ -43,8 +55,11 @@ namespace WireMock.Net.Tests.ResponseBuilders
             responseMessage.BodyData.Should().BeNull();
         }
 
-        [Fact]
-        public async Task Response_ProvideResponse_Handlebars_UrlPathVerb()
+        [Theory]
+        [InlineData(TransformerType.Handlebars)]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Transformer_UrlPathVerb(TransformerType transformerType)
         {
             // Assign
             var body = new BodyData
@@ -55,8 +70,8 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POSt", ClientIp, body);
 
             var response = Response.Create()
-                .WithBody("test {{request.url}} {{request.path}} {{request.method}}")
-                .WithTransformer();
+                .WithBody("test {{request.Url}} {{request.Path}} {{request.Method}}")
+                .WithTransformer(transformerType);
 
             // Act
             var responseMessage = await response.ProvideResponseAsync(request, _settings);
@@ -66,23 +81,27 @@ namespace WireMock.Net.Tests.ResponseBuilders
         }
 
         [Theory]
-        [InlineData("Get")]
-        [InlineData("Post")]
-        public async Task Response_ProvideResponse_Handlebars_UrlPath(string httpMethod)
+        [InlineData(TransformerType.Handlebars, "Get")]
+        [InlineData(TransformerType.Handlebars, "Post")]
+        [InlineData(TransformerType.Scriban, "Get")]
+        [InlineData(TransformerType.Scriban, "Post")]
+        [InlineData(TransformerType.ScribanDotLiquid, "Get")]
+        [InlineData(TransformerType.ScribanDotLiquid, "Post")]
+        public async Task Response_ProvideResponse_Transformer_UrlPath(TransformerType transformerType, string httpMethod)
         {
             // Assign
             var urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
             var request = new RequestMessage(urlDetails, httpMethod, ClientIp);
 
             var response = Response.Create()
-                .WithBody("{{request.url}} {{request.absoluteurl}} {{request.path}} {{request.absolutepath}}")
-                .WithTransformer();
+                .WithBody("url={{request.Url}} absoluteurl={{request.AbsoluteUrl}} path={{request.Path}} absolutepath={{request.AbsolutePath}}")
+                .WithTransformer(transformerType);
 
             // Act
             var responseMessage = await response.ProvideResponseAsync(request, _settings);
 
             // Assert
-            Check.That(responseMessage.BodyData.BodyAsString).Equals("http://localhost/a/b http://localhost/wiremock/a/b /a/b /wiremock/a/b");
+            Check.That(responseMessage.BodyData.BodyAsString).Equals("url=http://localhost/a/b absoluteurl=http://localhost/wiremock/a/b path=/a/b absolutepath=/wiremock/a/b");
         }
 
         [Fact]
@@ -93,7 +112,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var request = new RequestMessage(urlDetails, "POST", ClientIp);
 
             var response = Response.Create()
-                .WithBody("{{request.pathsegments.[0]}} {{request.absolutepathsegments.[0]}}")
+                .WithBody("{{request.PathSegments.[0]}} {{request.AbsolutePathSegments.[0]}}")
                 .WithTransformer();
 
             // Act
@@ -103,6 +122,26 @@ namespace WireMock.Net.Tests.ResponseBuilders
             Check.That(responseMessage.BodyData.BodyAsString).Equals("a wiremock");
         }
 
+        [Theory(Skip = "Invalid token `OpenBracket`")]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Scriban_PathSegments(TransformerType transformerType)
+        {
+            // Assign
+            var urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
+            var request = new RequestMessage(urlDetails, "POST", ClientIp);
+
+            var response = Response.Create()
+                .WithBody("{{request.PathSegments.[0]}} {{request.AbsolutePathSegments.[0]}}")
+                .WithTransformer(transformerType);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request, _settings);
+
+            // Assert
+            Check.That(responseMessage.BodyData.BodyAsString).Equals("a wiremock");
+        }
+
         [Fact]
         public async Task Response_ProvideResponse_Handlebars_Query()
         {
@@ -125,6 +164,30 @@ namespace WireMock.Net.Tests.ResponseBuilders
             Check.That(responseMessage.BodyData.BodyAsString).Equals("test keya=1 idx=1 idx=2 keyb=5");
         }
 
+        [Theory(Skip = "Invalid token `OpenBracket`")]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Scriban_Query(TransformerType transformerType)
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsString = "abc",
+                DetectedBodyType = BodyType.String
+            };
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo?a=1&a=2&b=5"), "POST", ClientIp, body);
+
+            var response = Response.Create()
+                .WithBody("test keya={{request.query.a}} idx={{request.query.a.[0]}} idx={{request.query.a.[1]}} keyb={{request.query.b}}")
+                .WithTransformer(transformerType);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request, _settings);
+
+            // Assert
+            Check.That(responseMessage.BodyData.BodyAsString).Equals("test keya=1 idx=1 idx=2 keyb=5");
+        }
+
         [Fact]
         public async Task Response_ProvideResponse_Handlebars_StatusCode()
         {
@@ -149,8 +212,37 @@ namespace WireMock.Net.Tests.ResponseBuilders
             Check.That(responseMessage.StatusCode).Equals("400");
         }
 
-        [Fact]
-        public async Task Response_ProvideResponse_Handlebars_StatusCodeIsNull()
+        [Theory(Skip = "WireMockList is not supported by Scriban")]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Scriban_StatusCode(TransformerType transformerType)
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsString = "abc",
+                DetectedBodyType = BodyType.String
+            };
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo?a=400"), "POST", ClientIp, body);
+
+            var response = Response.Create()
+                .WithStatusCode("{{request.Query.a}}")
+                .WithBody("test")
+                .WithTransformer(transformerType);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request, _settings);
+
+            // Assert
+            Check.That(responseMessage.BodyData.BodyAsString).Equals("test");
+            Check.That(responseMessage.StatusCode).Equals("400");
+        }
+
+        [Theory]
+        [InlineData(TransformerType.Handlebars)]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Transformer_StatusCodeIsNull(TransformerType transformerType)
         {
             // Assign
             var body = new BodyData
@@ -162,7 +254,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 
             var response = Response.Create()
                 .WithBody("test")
-                .WithTransformer();
+                .WithTransformer(transformerType);
 
             // Act
             var responseMessage = await response.ProvideResponseAsync(request, _settings);
@@ -217,8 +309,36 @@ namespace WireMock.Net.Tests.ResponseBuilders
             Check.That(responseMessage.Headers["x"]).Contains("http://localhost/foo");
         }
 
-        [Fact]
-        public async Task Response_ProvideResponse_Handlebars_Origin_Port_Protocol_Host()
+        [Theory(Skip = "WireMockList is not supported by Scriban")]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Scriban_Headers(TransformerType transformerType)
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsString = "abc",
+                DetectedBodyType = BodyType.String
+            };
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body, new Dictionary<string, string[]> { { "Content-Type", new[] { "text/plain" } } });
+
+            var response = Response.Create().WithHeader("x", "{{request.Headers[\"Content-Type\"]}}", "{{request.Url}}").WithBody("test").WithTransformer(transformerType);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request, _settings);
+
+            // Assert
+            Check.That(responseMessage.BodyData.BodyAsString).Equals("test");
+            Check.That(responseMessage.Headers).ContainsKey("x");
+            Check.That(responseMessage.Headers["x"]).Contains("text/plain");
+            Check.That(responseMessage.Headers["x"]).Contains("http://localhost/foo");
+        }
+
+        [Theory]
+        [InlineData(TransformerType.Handlebars)]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Transformer_Origin_Port_Protocol_Host(TransformerType transformerType)
         {
             // Assign
             var body = new BodyData
@@ -229,8 +349,8 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
 
             var response = Response.Create()
-                .WithBody("test {{request.origin}} {{request.port}} {{request.protocol}} {{request.host}}")
-                .WithTransformer();
+                .WithBody("test {{request.Origin}} {{request.Port}} {{request.Protocol}} {{request.Host}}")
+                .WithTransformer(transformerType);
 
             // Act
             var responseMessage = await response.ProvideResponseAsync(request, _settings);
@@ -239,8 +359,11 @@ namespace WireMock.Net.Tests.ResponseBuilders
             Check.That(responseMessage.BodyData.BodyAsString).Equals("test http://localhost:1234 1234 http localhost");
         }
 
-        [Fact]
-        public async Task Response_ProvideResponse_Handlebars_WithBodyAsJson_ResultAsObject()
+        [Theory]
+        [InlineData(TransformerType.Handlebars)]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Transformer_WithBodyAsJson_ResultAsObject(TransformerType transformerType)
         {
             // Assign
             string jsonString = "{ \"things\": [ { \"name\": \"RequiredThing\" }, { \"name\": \"Wiremock\" } ] }";
@@ -253,8 +376,8 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData);
 
             var response = Response.Create()
-                .WithBodyAsJson(new { x = "test {{request.path}}" })
-                .WithTransformer();
+                .WithBodyAsJson(new { x = "test {{request.Path}}" })
+                .WithTransformer(transformerType);
 
             // Act
             var responseMessage = await response.ProvideResponseAsync(request, _settings);
@@ -263,8 +386,11 @@ namespace WireMock.Net.Tests.ResponseBuilders
             Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("{\"x\":\"test /foo_object\"}");
         }
 
-        [Fact]
-        public async Task Response_ProvideResponse_Handlebars_WithBodyAsJson_ResultAsArray()
+        [Theory]
+        [InlineData(TransformerType.Handlebars)]
+        //[InlineData(TransformerType.Scriban)] Scriban cannot access dynamic Json Objects
+        //[InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Transformer_WithBodyAsJson_ResultAsArray(TransformerType transformerType)
         {
             // Assign
             string jsonString = "{ \"a\": \"test 1\", \"b\": \"test 2\" }";
@@ -278,7 +404,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 
             var response = Response.Create()
                 .WithBodyAsJson(new[] { "first", "{{request.path}}", "{{request.bodyAsJson.a}}", "{{request.bodyAsJson.b}}", "last" })
-                .WithTransformer();
+                .WithTransformer(transformerType);
 
             // Act
             var responseMessage = await response.ProvideResponseAsync(request, _settings);
@@ -304,8 +430,30 @@ namespace WireMock.Net.Tests.ResponseBuilders
             Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.xml");
         }
 
-        [Fact]
-        public async Task Response_ProvideResponse_Handlebars_WithBodyAsFile_And_TransformContentFromBodyAsFile()
+        [Theory(Skip = @"Does not work in Scriban --> c:\\[""1""]\\test.xml")]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Scriban_WithBodyAsFile(TransformerType transformerType)
+        {
+            // Assign
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp);
+
+            var response = Response.Create()
+                .WithTransformer(transformerType)
+                .WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml");
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request, _settings);
+
+            // Assert
+            Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.xml");
+        }
+
+        [Theory]
+        [InlineData(TransformerType.Handlebars)]
+        //[InlineData(TransformerType.Scriban)] ["c:\\["1"]\\test.xml"]
+        //[InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Transformer_WithBodyAsFile_And_TransformContentFromBodyAsFile(TransformerType transformerType)
         {
             // Assign
             var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
@@ -316,7 +464,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp);
 
             var response = Response.Create()
-                .WithTransformer(true)
+                .WithTransformer(transformerType, true)
                 .WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml");
 
             // Act
@@ -328,35 +476,11 @@ namespace WireMock.Net.Tests.ResponseBuilders
             Check.That(responseMessage.BodyData.BodyAsString).Equals("<xml MyUniqueNumber=\"1\"></xml>");
         }
 
-        [Fact]
-        public async Task Response_ProvideResponse_Handlebars_WithBodyAsFile_JsonPath()
-        {
-            // Assign
-            string jsonString = "{ \"MyUniqueNumber\": \"1\" }";
-            var bodyData = new BodyData
-            {
-                BodyAsString = jsonString,
-                BodyAsJson = JsonConvert.DeserializeObject(jsonString),
-                DetectedBodyType = BodyType.Json,
-                DetectedBodyTypeFromContentType = BodyType.Json,
-                Encoding = Encoding.UTF8
-            };
-            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, bodyData);
-
-            string jsonPath = "\"$.MyUniqueNumber\"";
-            var response = Response.Create()
-                .WithTransformer()
-                .WithBodyFromFile(@"c:\\{{JsonPath.SelectToken request.body " + jsonPath + "}}\\test.json"); // why use a \\ here ?
-
-            // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _settings);
-
-            // Assert
-            Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.json");
-        }
-
-        [Fact]
-        public async Task Response_ProvideResponse_Handlebars_WithBodyAsJson_ResultAsNormalString()
+        [Theory]
+        [InlineData(TransformerType.Handlebars)]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Transformer_WithBodyAsJson_ResultAsNormalString(TransformerType transformerType)
         {
             // Assign
             string jsonString = "{ \"name\": \"WireMock\" }";
@@ -370,7 +494,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 
             var response = Response.Create()
                 .WithBodyAsJson("test")
-                .WithTransformer();
+                .WithTransformer(transformerType);
 
             // Act
             var responseMessage = await response.ProvideResponseAsync(request, _settings);
@@ -380,7 +504,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
         }
 
         [Fact]
-        public async Task Response_ProvideResponse_Handlebars_WithBodyAsJson_ResultAsHandlebarsString()
+        public async Task Response_ProvideResponse_Handlebars_WithBodyAsJson_ResultAsTemplatedString()
         {
             // Assign
             string jsonString = "{ \"name\": \"WireMock\" }";
@@ -393,7 +517,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData);
 
             var response = Response.Create()
-                .WithBodyAsJson("{{{request.bodyAsJson}}}")
+                .WithBodyAsJson("{{{request.BodyAsJson}}}")
                 .WithTransformer();
 
             // Act
@@ -403,8 +527,37 @@ namespace WireMock.Net.Tests.ResponseBuilders
             Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("{\"name\":\"WireMock\"}");
         }
 
-        [Fact]
-        public async Task Response_ProvideResponse_Handlebars_WithBodyAsString_KeepsEncoding()
+        [Theory(Skip = "{{{ }}} Does not work in Scriban")]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Scriban_WithBodyAsJson_ResultAsTemplatedString(TransformerType transformerType)
+        {
+            // Assign
+            string jsonString = "{ \"name\": \"WireMock\" }";
+            var bodyData = new BodyData
+            {
+                BodyAsJson = JsonConvert.DeserializeObject(jsonString),
+                DetectedBodyType = BodyType.Json,
+                Encoding = Encoding.UTF8
+            };
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData);
+
+            var response = Response.Create()
+                .WithBodyAsJson("{{{request.BodyAsJson}}}")
+                .WithTransformer(transformerType);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request, _settings);
+
+            // Assert
+            Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("{\"name\":\"WireMock\"}");
+        }
+
+        [Theory]
+        [InlineData(TransformerType.Handlebars)]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public async Task Response_ProvideResponse_Transformer_WithBodyAsString_KeepsEncoding(TransformerType transformerType)
         {
             // Assign
             const string text = "my-text";
@@ -418,8 +571,8 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData);
 
             var response = Response.Create()
-                .WithBody("{{request.body}}", BodyDestinationFormat.SameAsSource, enc)
-                .WithTransformer();
+                .WithBody("{{request.Body}}", BodyDestinationFormat.SameAsSource, enc)
+                .WithTransformer(transformerType);
 
             // Act
             var responseMessage = await response.ProvideResponseAsync(request, _settings);

test/WireMock.Net.Tests/Transformers/Handlebars/HandlebarsContextFactoryTests.cs

@@ -3,10 +3,10 @@ using HandlebarsDotNet;
 using Moq;
 using System;
 using WireMock.Handlers;
-using WireMock.Transformers;
+using WireMock.Transformers.Handlebars;
 using Xunit;
 
-namespace WireMock.Net.Tests.Transformers
+namespace WireMock.Net.Tests.Transformers.Handlebars
 {
     public class HandlebarsContextFactoryTests
     {

test/WireMock.Net.Tests/Transformers/Scriban/ScribanContextFactoryTests.cs

@@ -0,0 +1,40 @@
+using System;
+using FluentAssertions;
+using Moq;
+using WireMock.Handlers;
+using WireMock.Transformers.Scriban;
+using WireMock.Types;
+using Xunit;
+
+namespace WireMock.Net.Tests.Transformers.Scriban
+{
+    public class ScribanContextFactoryTests
+    {
+        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+
+        [Theory]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public void Create_With_Scriban_TransformerType_Creates_ITransformerContext(TransformerType transformerType)
+        {
+            // Arrange
+            var sut = new ScribanContextFactory(_fileSystemHandlerMock.Object, transformerType);
+
+            // Act
+            var result = sut.Create();
+
+            // Assert
+            result.Should().NotBeNull();
+        }
+
+        [Fact]
+        public void Create_With_Invalid_TransformerType_Throws_Exception()
+        {
+            // Act
+            Action action = () => new ScribanContextFactory(_fileSystemHandlerMock.Object, TransformerType.Handlebars);
+
+            // Assert
+            action.Should().Throw<Exception>();
+        }
+    }
+}