Add ScribanRegistrationCallback to register custom Scriban functions (#1515) (#1516)

- Add WireMockServerSettings.ScribanRegistrationCallback
  (Action<object, IFileSystemHandler>?) so code-configured servers can add
  functions, objects or variables to Scriban and Scriban-DotLiquid templates.
- Pass the settings to ScribanContextFactory, which invokes the callback with
  a new ScriptObject per transformer context.
- Push the custom globals beneath the template model in ScribanContext so
  request, response, mapping and data take precedence; keep the original
  Template.Render call when no callback is configured.
- Add the strongly typed WithScribanRegistration extension method.
- Add a Scriban example to the .NET 8 console app.
- Make the proxy tests use a local target server instead of www.google.com,
  and skip the IPv6 loopback test when the OS has no IPv6 support.

Co-authored-by: Mattias <13809209+Quattordici@users.noreply.github.com>

src/WireMock.Net.Minimal/Settings/WireMockServerSettingsExtensions.cs

@@ -0,0 +1,40 @@
+// Copyright © WireMock.Net
+
+using JetBrains.Annotations;
+using Scriban.Runtime;
+using Stef.Validation;
+using WireMock.Handlers;
+
+namespace WireMock.Settings;
+
+/// <summary>
+/// Extension methods for <see cref="WireMockServerSettings"/>.
+/// </summary>
+public static class WireMockServerSettingsExtensions
+{
+    /// <summary>
+    /// Adds a strongly typed Scriban registration to <see cref="WireMockServerSettings.ScribanRegistrationCallback"/>.
+    /// </summary>
+    /// <remarks>
+    /// Members added to the <see cref="ScriptObject"/> are available as globals in Scriban and Scriban-DotLiquid templates.
+    /// When a callback is already configured, it is kept and invoked before <paramref name="registrationCallback"/>.
+    /// </remarks>
+    /// <param name="settings">The settings.</param>
+    /// <param name="registrationCallback">The action which registers functions, objects or variables on the <see cref="ScriptObject"/>.</param>
+    /// <returns>The same <see cref="WireMockServerSettings"/> instance.</returns>
+    [PublicAPI]
+    public static WireMockServerSettings WithScribanRegistration(this WireMockServerSettings settings, Action<ScriptObject, IFileSystemHandler> registrationCallback)
+    {
+        Guard.NotNull(settings);
+        Guard.NotNull(registrationCallback);
+
+        var existingCallback = settings.ScribanRegistrationCallback;
+        settings.ScribanRegistrationCallback = (scriptObject, fileSystemHandler) =>
+        {
+            existingCallback?.Invoke(scriptObject, fileSystemHandler);
+            registrationCallback((ScriptObject)scriptObject, fileSystemHandler);
+        };
+
+        return settings;
+    }
+}

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

@@ -1,6 +1,7 @@
 // Copyright © WireMock.Net
 
 using Scriban;
+using Scriban.Runtime;
 using Stef.Validation;
 using WireMock.Handlers;
 using WireMock.Types;
@@ -9,21 +10,40 @@ namespace WireMock.Transformers.Scriban;
 
 internal class ScribanContext : ITransformerContext
 {
+    private static readonly MemberRenamerDelegate MemberRenamer = member => member.Name;
+
     private readonly TransformerType _transformerType;
+    private readonly ScriptObject? _customGlobals;
 
     public IFileSystemHandler FileSystemHandler { get; }
 
-    public ScribanContext(IFileSystemHandler fileSystemHandler, TransformerType transformerType)
+    public ScribanContext(IFileSystemHandler fileSystemHandler, TransformerType transformerType, ScriptObject? customGlobals = null)
     {
         FileSystemHandler = Guard.NotNull(fileSystemHandler);
         _transformerType = transformerType;
+        _customGlobals = customGlobals;
     }
 
     public string ParseAndRender(string text, object model)
     {
-        var template = _transformerType == TransformerType.ScribanDotLiquid ? Template.ParseLiquid(text) : Template.Parse(text);
+        var isLiquid = _transformerType == TransformerType.ScribanDotLiquid;
+        var template = isLiquid ? Template.ParseLiquid(text) : Template.Parse(text);
 
-        return template.Render(model, member => member.Name);
+        if (_customGlobals is null)
+        {
+            return template.Render(model, MemberRenamer);
+        }
+
+        // Same as Template.Render(model, MemberRenamer), but with the custom globals pushed beneath the model so that the model takes precedence.
+        var context = isLiquid ? new LiquidTemplateContext() : new TemplateContext();
+        context.MemberRenamer = MemberRenamer;
+        context.PushGlobal(_customGlobals);
+
+        var modelGlobals = new ScriptObject();
+        modelGlobals.Import(model, renamer: MemberRenamer);
+        context.PushGlobal(modelGlobals);
+
+        return template.Render(context);
     }
 
     public object? ParseAndEvaluate(string text, object model)

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

@@ -1,24 +1,32 @@
 // Copyright © WireMock.Net
 
-using WireMock.Handlers;
-using WireMock.Types;
+using Scriban.Runtime;
 using Stef.Validation;
+using WireMock.Settings;
+using WireMock.Types;
 
 namespace WireMock.Transformers.Scriban;
 
 internal class ScribanContextFactory : ITransformerContextFactory
 {
-    private readonly IFileSystemHandler _fileSystemHandler;
+    private readonly WireMockServerSettings _settings;
     private readonly TransformerType _transformerType;
 
-    public ScribanContextFactory(IFileSystemHandler fileSystemHandler, TransformerType transformerType)
+    public ScribanContextFactory(WireMockServerSettings settings, TransformerType transformerType)
     {
-        _fileSystemHandler = Guard.NotNull(fileSystemHandler);
+        _settings = Guard.NotNull(settings);
         _transformerType = Guard.Condition(transformerType, t => t is TransformerType.Scriban or TransformerType.ScribanDotLiquid);
     }
 
     public ITransformerContext Create()
     {
-        return new ScribanContext(_fileSystemHandler, _transformerType);
+        ScriptObject? customGlobals = null;
+        if (_settings.ScribanRegistrationCallback is { } registrationCallback)
+        {
+            customGlobals = new ScriptObject();
+            registrationCallback(customGlobals, _settings.FileSystemHandler);
+        }
+
+        return new ScribanContext(_settings.FileSystemHandler, _transformerType, customGlobals);
     }
 }

src/WireMock.Net.Minimal/Transformers/TransformerFactory.cs

@@ -19,8 +19,8 @@ internal static class TransformerFactory
                 
             case TransformerType.Scriban:
             case TransformerType.ScribanDotLiquid:
-                var factoryDotLiquid = new ScribanContextFactory(settings.FileSystemHandler, transformerType);
-                return new Transformer(settings, factoryDotLiquid);
+                var factoryScriban = new ScribanContextFactory(settings, transformerType);
+                return new Transformer(settings, factoryScriban);
 
             default:
                 throw new NotSupportedException($"{nameof(TransformerType)} '{transformerType}' is not supported.");

src/WireMock.Net.Shared/Settings/WireMockServerSettings.cs

@@ -194,6 +194,20 @@ public class WireMockServerSettings
     [JsonIgnore]
     public Action<IHandlebars, IFileSystemHandler>? HandlebarsRegistrationCallback { get; set; }
 
+    /// <summary>
+    /// Action which can be used to add additional Scriban registrations (functions, objects or variables). [Optional]
+    /// </summary>
+    /// <remarks>
+    /// The first argument is a <c>Scriban.Runtime.ScriptObject</c> from the <c>Scriban.Signed</c> package.
+    /// It is typed as <see cref="object"/> so that this package does not depend on Scriban.
+    /// Members added to it are available as globals in <see cref="TransformerType.Scriban"/> and <see cref="TransformerType.ScribanDotLiquid"/> templates.
+    /// On a name clash the template model (<c>request</c>, <c>response</c>, <c>mapping</c> and <c>data</c>) takes precedence.
+    /// The action is invoked each time a transformer context is created.
+    /// </remarks>
+    [PublicAPI]
+    [JsonIgnore]
+    public Action<object, IFileSystemHandler>? ScribanRegistrationCallback { get; set; }
+
     /// <summary>
     /// Allow the usage of CSharpCodeMatcher (default is not allowed).
     /// </summary>