Added basic DIY templating support

and removed the ill-conceived LazyNode

Author: resc

src/Cubist.Helium.Tests/HeTests.cs

@@ -37,6 +37,59 @@ public void CanRenderJsonNode()
         _output.WriteLine(html);
         Assert.Equal("{\"text\":\"some text\",\"bool\":true}", html);
     }
+
+    [Fact]
+    public void CanRenderTemplateNode()
+    {
+        var tt = new TextTemplate();
+        var link = A("#text", tt);
+
+
+        var html = link.ToString();
+        _output.WriteLine(html);
+        Assert.Equal("<a href=\"#text\"></a>", html);
+
+        tt.Text = "Some Text";
+        var html2 = link.ToString();
+        _output.WriteLine(html2);
+        Assert.Equal("<a href=\"#text\">Some Text</a>", html2);
+    }
+
+    [Fact]
+    public void CanRenderTemplateNodeAsAttributeValue()
+    {
+        var tt = new TextTemplate();
+        var link = Div(("class", tt));
+
+
+        var html = link.ToString();
+        _output.WriteLine(html);
+        Assert.Equal("<div class=\"\"></div>", html);
+
+        tt.Text = "myClass";
+        var html2 = link.ToString();
+        _output.WriteLine(html2);
+        Assert.Equal("<div class=\"myClass\"></div>", html2);
+    }
+
+    private class TextTemplate : ITemplate
+    {
+        private string _text = "";
+        private Text _cachedNode = Text("");
+
+        public string Text
+        {
+            get => _text;
+            set
+            {
+                _text = value;
+                _cachedNode = Text(value);
+            }
+        }
+
+        public Node Render() => _cachedNode;
+    }
+
     [Fact]
     public void CanRenderImportMap()
     {

src/Cubist.Helium/He.cs

@@ -52,7 +52,11 @@ public He Attr(string name, object? value = null)
             throw new ArgumentException("name cannot be null or empty.", nameof(name));
 
         _attrs ??= new();
-        _attrs.Add((name, value));
+        _attrs.Add((name, value switch
+        {
+            ITemplate t => new Template(t),
+            _ => value
+        }));
         return this;
     }
 
@@ -165,6 +169,7 @@ public He Add(IEnumerable content)
         Node n => Add(n),
         string s => Add(s),
         ITuple { Length: 2 } tuple => Attr(tuple[0] as string ?? $"{tuple[0]}", tuple[1]),
+        ITemplate t => Add(new Template(t)),
         JsonNode json => Add(Json(json)),
         IEnumerable nodes => AddRange(nodes),
         bool boolValue => Add(boolValue.ToString()),

src/Cubist.Helium/ITemplate.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Cubist.Helium
+{
+    /// <summary>
+    /// You can implement the <see cref="ITemplate"/> interface to implement your own template engine.
+    /// <see cref="ITemplate"/> instances will be wrapped by a <see cref="Template"/> instance,
+    /// which will invoke <see cref="ITemplate.Render"/> every time <see cref="Node.WriteTo"/> or <see cref="Node.PrettyPrintTo"/> is called.
+    /// </summary>
+    public interface ITemplate
+    {
+        /// <summary> Renders the template to a <see cref="Node"/> </summary>
+        Node Render();
+    }
+}

src/Cubist.Helium/LazyNode.cs

@@ -0,0 +1,31 @@
+namespace Cubist.Helium;
+
+/// <summary> Node that renders the supplied <see cref="ITemplate"/> implementation </summary>
+public class Template : Node
+{
+    private readonly ITemplate _template;
+
+    /// <summary> Creates a new <see cref="Template"/> instance </summary>
+    public Template(ITemplate template)
+    {
+        _template = template;
+    }
+
+    /// <inheritdoc cref="Node.WriteTo"/>>
+    public override void WriteTo(TextWriter w)
+    {
+        _template.Render().WriteTo(w);
+    }
+
+    /// <inheritdoc cref="Node.PrettyPrintTo"/>>
+    public override void PrettyPrintTo(IndentWriter w)
+    {
+        _template.Render().PrettyPrintTo(w);
+    }
+
+    /// <inheritdoc cref="Node.ToString"/>>
+    public override string ToString()
+    {
+        return _template.Render().ToString();
+    }
+}