Merge pull request #28 from tgiachi/feature/templating-include

feat(templating): support {{ include }} in Scriban templates

Author: tgiachi

src/SquidStd.Templating/Internal/NamedTemplateLoader.cs

@@ -0,0 +1,35 @@
+using Scriban;
+using Scriban.Parsing;
+using Scriban.Runtime;
+
+namespace SquidStd.Templating.Internal;
+
+/// <summary>
+/// Scriban <see cref="ITemplateLoader" /> that resolves <c>{{ include }}</c> names from the renderer's
+/// registered template sources.
+/// </summary>
+internal sealed class NamedTemplateLoader : ITemplateLoader
+{
+    private readonly IReadOnlyDictionary<string, string> _sources;
+
+    public NamedTemplateLoader(IReadOnlyDictionary<string, string> sources)
+    {
+        _sources = sources;
+    }
+
+    public string GetPath(TemplateContext context, SourceSpan callerSpan, string templateName)
+        => templateName;
+
+    public string Load(TemplateContext context, SourceSpan callerSpan, string templatePath)
+    {
+        if (!_sources.TryGetValue(templatePath, out var source))
+        {
+            throw new TemplateException($"Template '{templatePath}' is not registered (include).");
+        }
+
+        return source;
+    }
+
+    public ValueTask<string> LoadAsync(TemplateContext context, SourceSpan callerSpan, string templatePath)
+        => new(Load(context, callerSpan, templatePath));
+}

src/SquidStd.Templating/Services/ScribanTemplateRenderer.cs

@@ -1,9 +1,11 @@
 using System.Collections.Concurrent;
 using Scriban;
+using Scriban.Runtime;
 using Scriban.Syntax;
 using SquidStd.Abstractions.Interfaces.Services;
 using SquidStd.Core.Directories;
 using SquidStd.Templating.Interfaces;
+using SquidStd.Templating.Internal;
 
 namespace SquidStd.Templating.Services;
 
@@ -17,10 +19,13 @@ public sealed class ScribanTemplateRenderer : ITemplateRenderer, ISquidStdServic
 
     private readonly DirectoriesConfig _directories;
     private readonly ConcurrentDictionary<string, Template> _named = new(StringComparer.Ordinal);
+    private readonly ConcurrentDictionary<string, string> _sources = new(StringComparer.Ordinal);
+    private readonly NamedTemplateLoader _loader;
 
     public ScribanTemplateRenderer(DirectoriesConfig directories)
     {
         _directories = directories;
+        _loader = new NamedTemplateLoader(_sources);
     }
 
     /// <inheritdoc />
@@ -54,6 +59,7 @@ public void Register(string name, string template)
         ArgumentException.ThrowIfNullOrWhiteSpace(template);
 
         _named[name] = Parse(template, name);
+        _sources[name] = template;
     }
 
     /// <inheritdoc />
@@ -93,11 +99,21 @@ private static Template Parse(string text, string name)
         return template;
     }
 
-    private static async ValueTask<string> RenderCompiledAsync(Template template, object? model, string name)
+    private async ValueTask<string> RenderCompiledAsync(Template template, object? model, string name)
     {
+        var context = new TemplateContext { TemplateLoader = _loader };
+        var scriptObject = new ScriptObject();
+
+        if (model is not null)
+        {
+            scriptObject.Import(model);
+        }
+
+        context.PushGlobal(scriptObject);
+
         try
         {
-            return await template.RenderAsync(model);
+            return await template.RenderAsync(context);
         }
         catch (ScriptRuntimeException ex)
         {

tests/SquidStd.Tests/Templating/ScribanTemplateRendererTests.cs

@@ -81,6 +81,75 @@ public async Task StartAsync_AutoLoadsTemplatesFromDirectory()
         Assert.Equal("Welcome squid", result);
     }
 
+    [Fact]
+    public async Task Include_ResolvesRegisteredTemplate()
+    {
+        using var temp = new TempDirectory();
+        var renderer = NewRenderer(temp.Path);
+        renderer.Register("partials/header", "HEADER");
+        renderer.Register("page", "{{ include 'partials/header' }} BODY");
+
+        var result = await renderer.RenderByNameAsync("page", null);
+
+        Assert.Equal("HEADER BODY", result);
+    }
+
+    [Fact]
+    public async Task Include_FromInlineTemplate_Works()
+    {
+        using var temp = new TempDirectory();
+        var renderer = NewRenderer(temp.Path);
+        renderer.Register("partials/header", "HEADER");
+
+        var result = await renderer.RenderAsync("{{ include 'partials/header' }}!", null);
+
+        Assert.Equal("HEADER!", result);
+    }
+
+    [Fact]
+    public async Task Include_WithModel_BindsModel()
+    {
+        using var temp = new TempDirectory();
+        var renderer = NewRenderer(temp.Path);
+        renderer.Register("partials/hello", "Hi {{ user.name }}");
+        renderer.Register("page", "{{ include 'partials/hello' }}");
+
+        var result = await renderer.RenderByNameAsync("page", new { User = new { Name = "squid" } });
+
+        Assert.Equal("Hi squid", result);
+    }
+
+    [Fact]
+    public async Task Include_MissingTemplate_Throws()
+    {
+        using var temp = new TempDirectory();
+        var renderer = NewRenderer(temp.Path);
+
+        await Assert.ThrowsAsync<TemplateException>(
+            async () => await renderer.RenderAsync("{{ include 'nope' }}", null)
+        );
+    }
+
+    [Fact]
+    public async Task Include_AutoLoadedFromDisk_Works()
+    {
+        using var temp = new TempDirectory();
+        var templatesDir = Path.Combine(temp.Path, "templates");
+        Directory.CreateDirectory(Path.Combine(templatesDir, "partials"));
+        await File.WriteAllTextAsync(Path.Combine(templatesDir, "partials", "header.tmpl"), "HEADER");
+        await File.WriteAllTextAsync(
+            Path.Combine(templatesDir, "page.tmpl"),
+            "{{ include 'partials/header' }} BODY"
+        );
+
+        var renderer = NewRenderer(temp.Path);
+        await renderer.StartAsync();
+
+        var result = await renderer.RenderByNameAsync("page", null);
+
+        Assert.Equal("HEADER BODY", result);
+    }
+
     private static ScribanTemplateRenderer NewRenderer(string root)
         => new(new(root, []));
 }