Added He.List

Now you have an easy way to generate multiple top-level tags.
Usefull for generating partials.

Author: resc

src/Cubist.Helium.Tests/Cubist.Helium.Tests.csproj

@@ -6,6 +6,7 @@
     <Nullable>enable</Nullable>
 
     <IsPackable>false</IsPackable>
+		<LangVersion>11</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>

src/Cubist.Helium.Tests/HeTests.cs

@@ -13,6 +13,71 @@ public HeTests(ITestOutputHelper output)
         _output = output;
     }
 
+    [Fact]
+    public void CanConstructList()
+    {
+        var list = List(P("one"), P("two"), P("three"));
+        var html = list.ToString();
+        _output.WriteLine(html);
+        Assert.Equal("<p>one</p><p>two</p><p>three</p>", html);
+    }
+
+    [Fact]
+    public void CanConstructListPrettyPrinted()
+    {
+        var list = List(P("one"), P("two"), P("three"));
+        var html = list.PrettyPrint();
+        _output.WriteLine(html);
+        Assert.Equal("""
+        <p>one</p>
+        <p>two</p>
+        <p>three</p>
+
+        """, html);
+    }
+    [Fact]
+    public void CanConstructListInDivPrettyPrinted()
+    {
+        var list = Div(List(P("one"), P("two"), P("three")));
+        var html = list.PrettyPrint();
+        _output.WriteLine(html);
+        Assert.Equal("""
+        <div>
+          <p>one</p>
+          <p>two</p>
+          <p>three</p>
+        </div>
+        
+        """, html);
+    }
+
+    [Fact]
+    public void CanConstructListInSpanPrettyPrinted()
+    {
+        var list = Span(List(Span("one"), Span("two"), Span("three")));
+        var html = list.PrettyPrint();
+        _output.WriteLine(html);
+        Assert.Equal("""
+        <span><span>one</span><span>two</span><span>three</span></span>
+        """, html);
+    }
+
+    [Fact]
+    public void ListIgnoresAttributes()
+    {
+        var list = List(("id", "test"));
+        Assert.Equal(string.Empty, list.ToString());
+        Assert.Equal(string.Empty, list.PrettyPrint());
+    }
+
+    [Fact]
+    public void ListIgnoresAttributesWithChildTag()
+    {
+        var list = List(("id", "test"), P("test"));
+        Assert.Equal("<p>test</p>", list.ToString());
+        Assert.Equal("<p>test</p>\r\n", list.PrettyPrint());
+    }
+
     [Fact]
     public void CanConstructMetaElement()
     {
@@ -21,7 +86,6 @@ public void CanConstructMetaElement()
         var html = meta.ToString();
         _output.WriteLine(html);
         Assert.Equal("<meta name=\"keywords\" content=\"test, library\">", html);
-
     }
 
     [Fact]

src/Cubist.Helium/Cubist.Helium.csproj

@@ -24,6 +24,7 @@
 		<EnablePackageValidation>true</EnablePackageValidation>
 
 		<DebugType>portable</DebugType>
+		<LangVersion>11</LangVersion>
 	</PropertyGroup>
 
 	<PropertyGroup>

src/Cubist.Helium/He.Factory.cs

@@ -575,4 +575,7 @@ public static He Time(DateTime datetime, params object[] content) =>
 
     /// <inheritdoc cref="Tags.Wbr"/>
     public static He Wbr() => new(Tags.Wbr);
+
+    /// <summary> A container for nodes, only prints the contained nodes, ignores any added attributes. </summary>
+    public static He List(params object[] content) => new(Tag.Empty) { content };
 }

src/Cubist.Helium/He.cs

@@ -79,7 +79,10 @@ public He CAttr(bool condition, string name, object? value = null)
         return this;
     }
 
-    /// <summary> returns this element's attributes </summary>
+    /// <summary>  Returns the number of attributes on this element. </summary>
+    internal int AttrCount => _attrs?.Count ?? 0;
+
+    /// <summary> Returns this element's attributes </summary>
     public IEnumerable<(string, object?)> Attrs()
     {
         if (_attrs == null) yield break;
@@ -90,27 +93,15 @@ public He CAttr(bool condition, string name, object? value = null)
     /// <inheritdoc cref="Node.WriteTo"/>
     public override void WriteTo(TextWriter w)
     {
-        if (_attrs == null || _attrs.Count == 0)
-        {
-            Tag.WriteStart(w);
-        }
-        else
-        {
-            Tag.WriteStartBegin(w);
-            foreach (var attr in _attrs)
-                attr.WriteTo(w);
-
-            Tag.WriteStartEnd(w);
-        }
+        this.WriteStartTag(w);
 
         if (_nodes != null)
         {
             foreach (var node in _nodes)
                 node.WriteTo(w);
         }
 
-        if (!Tag.IsVoid())
-            Tag.WriteClose(w);
+        this.WriteCloseTag(w);
     }
 
     /// <inheritdoc cref="Node.PrettyPrintTo"/>>
@@ -121,23 +112,24 @@ public override void PrettyPrintTo(IndentWriter w)
         this.WriteStartTag(w);
 
         var allChildrenInline = this.All(n => n.IsInline());
-        using (w.Indent())
-        {
-            if (indent && !allChildrenInline)
-                w.WriteLine();
 
-            foreach (var child in this)
-                child.PrettyPrintTo(w);
+        bool isEmptyTag = Tag == Tag.Empty;
+        var indentBlock = isEmptyTag ? IndentWriter.IndentBlock.Empty : w.Indent();
 
-            if (indent && !allChildrenInline && this.Count > 0 && this.Last().IsInline())
-                w.WriteLine();
-        }
+        if (indent && !allChildrenInline && !isEmptyTag)
+            w.WriteLine();
+
+        foreach (var child in this)
+            child.PrettyPrintTo(w);
+
+        if (indent && !allChildrenInline && this.Count > 0 && this.Last().IsInline())
+            w.WriteLine();
 
+        indentBlock.Dispose();
 
-        if (!Tag.IsVoid())
-            this.WriteCloseTag(w);
+        this.WriteCloseTag(w);
 
-        if (indent)
+        if (indent && !isEmptyTag)
             w.WriteLine();
     }
 

src/Cubist.Helium/IndentWriter.cs

@@ -95,8 +95,18 @@ private void WriteIndent()
     /// <summary> Represent a indentation level </summary>
     public struct IndentBlock : IDisposable
     {
+
+        /// <summary> An empty <see cref="IndentBlock"/> value</summary>
+        public static  IndentBlock Empty { get; } = new();
+
         private IndentWriter? _w;
 
+        /// <summary> Creates an empty <see cref="IndentBlock"/> value</summary>
+        public IndentBlock()
+        {
+            _w = null;
+        }
+
         /// <summary> Creates a <see cref="IndentBlock"/> value</summary>
         public IndentBlock(IndentWriter w)
         {

src/Cubist.Helium/NodeExtensions.cs

@@ -49,15 +49,22 @@ public static void Apply(this Node start, Func<Node, bool> match, Action<Node> a
     /// <summary> Writes the node start tag </summary>
     public static void WriteStartTag(this He he, TextWriter w)
     {
+        if (he.Tag == Tag.Empty) return;
+
         he.Tag.WriteStartBegin(w);
-        foreach (var attr in he.Attrs())
-            attr.WriteTo(w);
+        if (he.AttrCount > 0)
+        {
+            foreach (var attr in he.Attrs())
+                attr.WriteTo(w);
+        }
         he.Tag.WriteStartEnd(w);
     }
 
     /// <summary> Writes the node closing tag if it needs one.</summary>
     public static void WriteCloseTag(this He he, TextWriter w)
     {
+        if (he.Tag == Tag.Empty) return;
+
         he.Tag.WriteClose(w);
     }
 }

src/Cubist.Helium/PrettyPrintExtensions.cs

@@ -18,7 +18,7 @@ public static string PrettyPrint(this Node n)
     public static bool IsInline(this Node n)
         => n is CData ||
            (n is Text t && !t.Value.Contains('\n')) ||
-           (n is He he && he.Tag.IsInline() &&
+           (n is He he && (he.Tag.IsInline() || he.Tag==Tag.Empty) &&
             he.All(child => child.IsInline()));
 
     /// <summary>

src/Cubist.Helium/Tag.cs

@@ -5,19 +5,28 @@ namespace Cubist.Helium;
 /// <summary> Represents a html tag name with some extra information. </summary>
 public readonly record struct Tag(string Value, TagOptions Options)
 {
+    /// <summary> The empty tag that will not render </summary>
+    public static Tag Empty => new(string.Empty, TagOptions.None);
+
     /// <summary> implicit conversion from a string to a tag, adds TagOptions </summary>
     public static implicit operator Tag(string s) => new(s, GetOption(s));
 
     /// <summary> Writes the start tag.  <c>&lt;{tag}&gt;</c> </summary>
     public void WriteStart(TextWriter w)
     {
+        if (string.IsNullOrEmpty(Value)) 
+            return;
+
         WriteStartBegin(w);
         WriteStartEnd(w);
     }
 
     /// <summary> Writes the start tag begin <c>&lt;{tag}</c> so that attributes can be written. </summary>
     public void WriteStartBegin(TextWriter w)
     {
+        if (string.IsNullOrEmpty(Value)) 
+            return;
+
         w.Write('<');
         WriteTag(w);
     }
@@ -33,12 +42,14 @@ private void WriteTag(TextWriter w)
     /// <summary> Writes the start tag's closing <c>&gt;</c> character. </summary>
     public void WriteStartEnd(TextWriter w)
     {
+        if (string.IsNullOrEmpty(Value)) return;
         w.Write(">");
     }
 
     /// <summary> Writes the close tag <c>&lt;/{tag}&gt;</c>. </summary>
     public void WriteClose(TextWriter w)
     {
+        if (string.IsNullOrEmpty(Value)) return;
         if (this.IsVoid()) return;
         w.Write("</");
         WriteTag(w);
@@ -78,7 +89,7 @@ public void WriteClose(TextWriter w)
     {
         "h1","h2","h3","h4","h5","h6"
     };
-    
+
     /// <summary> See https://html.spec.whatwg.org/multipage/dom.html#phrasing-content </summary>
     private static readonly IReadOnlySet<string> _phrasingContent = new HashSet<string>
     {