Merge pull request #1147 from EamonNerbonne/eamon/BoolHtml

fdij · web-flow · commit f4e2b30e0be1 · 2025-06-03T09:03:51.000+02:00
Better support for boolean attributes
diff --git a/.gitignore b/.gitignore
@@ -6,3 +6,4 @@ bin/
 BenchmarkDotNet.Artifacts
 *.vspx
 *.received.txt
+.DS_Store
diff --git a/src/ProgressOnderwijsUtils/ApprovalTest.cs b/src/ProgressOnderwijsUtils/ApprovalTest.cs
@@ -11,7 +11,7 @@ static string ToApprovalPath(SourceLocation sourceLocation)
     {
         var filename = Path.GetFileNameWithoutExtension(sourceLocation.FilePath);
         var filedir = Path.GetDirectoryName(sourceLocation.FilePath);
-        var approvalPath = $"{filedir}\\{filename}.{sourceLocation.MemberName}.approved.txt";
+        var approvalPath = Path.Combine(filedir.AssertNotNull(), $"{filename}.{sourceLocation.MemberName}.approved.txt");
         return approvalPath;
     }
 
diff --git a/src/ProgressOnderwijsUtils/Html/HtmlSpec.AttributeConstructionMethods.Generated.cs b/src/ProgressOnderwijsUtils/Html/HtmlSpec.AttributeConstructionMethods.Generated.cs
diff --git a/src/ProgressOnderwijsUtils/Html/HtmlSpec.AttributeLookupTable.Generated.cs b/src/ProgressOnderwijsUtils/Html/HtmlSpec.AttributeLookupTable.Generated.cs
diff --git a/src/ProgressOnderwijsUtils/Html/HtmlSpec.AttributeNameInterfaces.Generated.cs b/src/ProgressOnderwijsUtils/Html/HtmlSpec.AttributeNameInterfaces.Generated.cs
@@ -119,6 +119,7 @@ public interface IHasAttr_shadowrootmode { }
 public interface IHasAttr_shadowrootdelegatesfocus { }
 public interface IHasAttr_shadowrootclonable { }
 public interface IHasAttr_shadowrootserializable { }
+public interface IHasAttr_shadowrootcustomelementregistry { }
 public interface IHasAttr_cols { }
 public interface IHasAttr_rows { }
 public interface IHasAttr_wrap { }
diff --git a/src/ProgressOnderwijsUtils/Html/HtmlSpec.HtmlTagKinds.Generated.cs b/src/ProgressOnderwijsUtils/Html/HtmlSpec.HtmlTagKinds.Generated.cs
@@ -2030,7 +2030,7 @@ public struct TD : IHtmlElementAllowingContent<TD>, IHasAttr_colspan, IHasAttr_r
         public static HtmlFragment operator +(TD head, HtmlFragment tail) => HtmlFragment.Fragment(HtmlFragment.Element(head), tail);
         public static HtmlFragment operator +(string head, TD tail) => HtmlFragment.Fragment(head, HtmlFragment.Element(tail));
     }
-    public struct TEMPLATE : IHtmlElementAllowingContent<TEMPLATE>, IHasAttr_shadowrootmode, IHasAttr_shadowrootdelegatesfocus, IHasAttr_shadowrootclonable, IHasAttr_shadowrootserializable
+    public struct TEMPLATE : IHtmlElementAllowingContent<TEMPLATE>, IHasAttr_shadowrootmode, IHasAttr_shadowrootdelegatesfocus, IHasAttr_shadowrootclonable, IHasAttr_shadowrootserializable, IHasAttr_shadowrootcustomelementregistry
     {
         public string TagName => "template";
         string IHtmlElement.TagStart => "<template";
diff --git a/src/ProgressOnderwijsUtils/Html/TagDescription.cs b/src/ProgressOnderwijsUtils/Html/TagDescription.cs
@@ -29,24 +29,9 @@ public bool IsPredefined
             );
 
     static Dictionary<string, string> AttributeLookup(Type tagType, IHtmlElement emptyValue)
-        => typeof(AttributeConstructionMethods)
-            .GetMethods(BindingFlags.Public | BindingFlags.Static)
-            .Where(
-                mi => {
-                    var typeArgument = mi.GetGenericArguments().Single();
-                    return typeArgument.GetGenericParameterConstraints()
-                        .All(
-                            constraint =>
-                                constraint.IsAssignableFrom(tagType)
-                                || constraint == typeof(IHtmlElement<>).MakeGenericType(typeArgument) && typeof(IHtmlElement<>).MakeGenericType(tagType).IsAssignableFrom(tagType)
-                        );
-                }
-            )
-            .ToDictionary(
-                method => ((IHtmlElement)method.MakeGenericMethod(tagType).Invoke(null, new[] { emptyValue, (object)"", }).AssertNotNull()).Attributes[^1].Name,
-                method => method.Name,
-                StringComparer.OrdinalIgnoreCase
-            );
+        => AttributeLookupTable.ByTagName.TryGetValue(emptyValue.TagName, out var lookup)
+            ? new Dictionary<string, string>(lookup, StringComparer.OrdinalIgnoreCase)
+            : new Dictionary<string, string>(AttributeLookupTable.DefaultAttributes, StringComparer.OrdinalIgnoreCase);
 
     public static TagDescription LookupTag(string tagName)
         => ByTagName.TryGetValue(tagName, out var desc)
@@ -58,5 +43,5 @@ public static TagDescription LookupTag(string tagName)
                 AttributeMethodsByName = DefaultAttributes,
             };
 
-    static readonly IReadOnlyDictionary<string, string> DefaultAttributes = AttributeLookup(typeof(CustomHtmlElement), new CustomHtmlElement("unknown", null, null));
+    static readonly IReadOnlyDictionary<string, string> DefaultAttributes = AttributeLookupTable.DefaultAttributes;
 }
diff --git a/src/ProgressOnderwijsUtils/ProgressOnderwijsUtils.csproj b/src/ProgressOnderwijsUtils/ProgressOnderwijsUtils.csproj
@@ -1,8 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\NugetPackagesCommon.props" />
   <PropertyGroup Label="Configuration">
-    <Version>105.5.2</Version>
-    <PackageReleaseNotes>Updated Nuget-packges</PackageReleaseNotes>
+    <Version>105.6.0</Version>
+    <PackageReleaseNotes>HTML DSL: better support for https://html.spec.whatwg.org/#boolean-attribute </PackageReleaseNotes>
     <Title>ProgressOnderwijsUtils</Title>
     <Description>Collection of utilities developed by ProgressOnderwijs</Description>
     <PackageTags>ProgressOnderwijs</PackageTags>
diff --git a/test/ProgressOnderwijsUtils.Tests/HtmlDslGenerator.cs b/test/ProgressOnderwijsUtils.Tests/HtmlDslGenerator.cs
@@ -18,7 +18,8 @@ static readonly Uri
         HtmlTagKinds_GeneratedOutputFilePath = LibHtmlDirectory.Combine("HtmlSpec.HtmlTagKinds.Generated.cs"),
         HtmlTags_GeneratedOutputFilePath = LibHtmlDirectory.Combine("HtmlSpec.HtmlTags.Generated.cs"),
         AttributeNameInterfaces_GeneratedOutputFilePath = LibHtmlDirectory.Combine("HtmlSpec.AttributeNameInterfaces.Generated.cs"),
-        AttributeConstructionMethods_GeneratedOutputFilePath = LibHtmlDirectory.Combine("HtmlSpec.AttributeConstructionMethods.Generated.cs");
+        AttributeConstructionMethods_GeneratedOutputFilePath = LibHtmlDirectory.Combine("HtmlSpec.AttributeConstructionMethods.Generated.cs"),
+        AttributeLookupTable_GeneratedOutputFilePath = LibHtmlDirectory.Combine("HtmlSpec.AttributeLookupTable.Generated.cs");
 
     readonly ITestOutputHelper output;
 
@@ -59,11 +60,18 @@ public async Task RegenerateHtmlTagCSharp()
             tableOfAttributes.QuerySelectorAll("tbody tr")
                 .Where(tr => tr.QuerySelector("td")?.TextContent.Trim() == "HTML elements")
                 .Select(tr => tr.QuerySelector("th").AssertNotNull().TextContent.Trim())
-                .ToArray();
+                .ToHashSet(StringComparer.OrdinalIgnoreCase);
 
-        string toClassName(string s)
+        var booleanAttributes =
+            tableOfAttributes.QuerySelectorAll("tbody tr").GroupBy(
+                tr => tr.QuerySelector("th").AssertNotNull().TextContent.Trim(),
+                tr => tr.QuerySelector("td > a[href='#boolean-attribute']")?.TextContent.Trim() == "Boolean attribute",
+                (key, isBoolean) => (key, isBoolean: isBoolean.Distinct().ToArray() is [var unique,] ? unique : default(bool?))
+            ).ToDictionary(o => o.key, o => o.isBoolean, StringComparer.OrdinalIgnoreCase);
+
+        static string toClassName(string s)
             => s.Replace('-', '_');
-        string[] splitList(string list)
+        static string[] splitList(string list)
             => list.Split(';').Select(s => s.Trim().TrimEnd('*')).Where(s => s != "").ToArray();
 
         var elements = tableOfElements.QuerySelectorAll("tbody tr")
@@ -119,16 +127,6 @@ string[] splitList(string list)
                     }
             ).ToArray();
 
-        var globalAttributeExtensionMethods = globalAttributes
-            .Select(
-                attrName => $"""
-                    {(attrName == "class" ? "\n    [Obsolete]" : "")}
-                        public static THtmlTag _{toClassName(attrName)}<THtmlTag>(this THtmlTag htmlTagExpr, string? attrValue)
-                            where THtmlTag : struct, IHtmlElement<THtmlTag>
-                            => htmlTagExpr.Attribute("{attrName}", attrValue);
-                    """
-            );
-
         var specificAttributes = elements.SelectMany(el => el.attributes).ToDistinctArray();
 
         var elAttrInterfaces = specificAttributes
@@ -138,15 +136,8 @@ public interface IHasAttr_{{toClassName(attrName)}} { }
 
                     """
             );
-        var elAttrExtensionMethods = specificAttributes
-            .Select(
-                attrName => $"""
-                    
-                        public static THtmlTag _{toClassName(attrName)}<THtmlTag>(this THtmlTag htmlTagExpr, string? attrValue)
-                            where THtmlTag : struct, IHasAttr_{toClassName(attrName)}, IHtmlElement<THtmlTag>
-                            => htmlTagExpr.Attribute("{attrName}", attrValue);
-                    """
-            );
+        var elAttrExtensionMethods = globalAttributes.Concat(specificAttributes)
+            .Select(AttrHelper).JoinStrings("");
 
         var elTagNameClasses = elements
             .Select(
@@ -256,15 +247,97 @@ namespace ProgressOnderwijsUtils.Html.AttributeNameInterfaces;
                 namespace ProgressOnderwijsUtils.Html;
 
                 public static class AttributeConstructionMethods
-                {{{globalAttributeExtensionMethods.JoinStrings("")}}{{elAttrExtensionMethods.JoinStrings("")}}
+                {{{elAttrExtensionMethods}}
                 }
 
                 """
             ),
+
+            AssertFileExistsAndApproveContent(
+                AttributeLookupTable_GeneratedOutputFilePath,
+                GenerateAttributeLookupTable(
+                    elements.Select(el => (el.elementName, el.attributes)).ToArray(),
+                    globalAttributes,
+                    specificAttributes.ToArray(),
+                    booleanAttributes
+                )
+            ),
         }.WhereNotNull().ToArray();
 
         PAssert.That(() => diff.None());
-    }
+        return;
+
+        string GenerateAttributeLookupTable(
+            (string elementName, DistinctArray<string> attributes)[] elements,
+            HashSet<string> globalAttributes,
+            string[] specificAttributes,
+            Dictionary<string, bool?> booleanAttributes)
+        {
+            // Generate lookup entries for each element
+            var elementLookups = elements.Select(el => {
+                var elementAttributes = ((IEnumerable<string>)globalAttributes).Concat(el.attributes).ToDistinctArray();
+                var attributeEntries = elementAttributes.Select(attrName => {
+                    var methodName = $"_{toClassName(attrName)}";
+                    return $"[\"{attrName}\"] = \"{methodName}\"";
+                }).JoinStrings(",\n                ");
+                
+                return $"[\"" + el.elementName + "\"] = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) {\n" +
+                       $"                {attributeEntries}\n" +
+                       "            },";
+            }).JoinStrings("\n            ");
+
+            // Generate default attributes for unknown elements (global attributes only)
+            var defaultAttributeEntries = globalAttributes.Select(attrName => {
+                var methodName = $"_{toClassName(attrName)}";
+                return $"[\"{attrName}\"] = \"{methodName}\"";
+            }).JoinStrings(",\n                ");
+
+            return $$"""
+                #nullable enable
+                namespace ProgressOnderwijsUtils.Html;
+
+                public static class AttributeLookupTable
+                {
+                    public static readonly IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>> ByTagName =
+                        new Dictionary<string, IReadOnlyDictionary<string, string>>(StringComparer.OrdinalIgnoreCase) {
+                {{elementLookups}}
+                        };
+
+                    public static readonly IReadOnlyDictionary<string, string> DefaultAttributes =
+                        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) {
+                            {{defaultAttributeEntries}}
+                        };
+                }
+
+                """;
+        }
+
+        string AttrHelper(string attrName)
+        {
+            var obsoleteAttribute = attrName == "class" ? "\n    [Obsolete]" : "";
+            var applicabilityTypeContraint = globalAttributes.Contains(attrName) switch {
+                true => "",
+                false => $", IHasAttr_{toClassName(attrName)}",
+            };
+            var isBoolean = booleanAttributes.GetValueOrDefault(attrName) ?? (attrName.StartsWith("on", StringComparison.OrdinalIgnoreCase) ? false : null);
+            return isBoolean switch {
+                null => throw new(attrName + " could not be determined to be a boolean attribute or not"),
+                false => AttrExtensionMethod(attrName, applicabilityTypeContraint, obsoleteAttribute, ", string? attrValue", ", attrValue"),
+                _ => AttrExtensionMethod(attrName, applicabilityTypeContraint, obsoleteAttribute, ", bool attrValue", ", attrValue ? \"\" : null")
+                    + AttrExtensionMethod(attrName, applicabilityTypeContraint, obsoleteAttribute, "", ", \"\"")
+                    + AttrExtensionMethod(attrName, applicabilityTypeContraint, obsoleteAttribute, ", string? attrValue", ", attrValue"),
+            };
+        }
+
+        static string AttrExtensionMethod(string attrName, string applicabilityTypeContraint, string obsoleteAttribute, string attrValueParam, string attrValueExpr)
+            => $$"""
+                {{obsoleteAttribute}}
+                    public static THtmlTag _{{toClassName(attrName)}}<THtmlTag>(this THtmlTag htmlTagExpr{{attrValueParam}})
+                        where THtmlTag : struct{{applicabilityTypeContraint}}, IHtmlElement<THtmlTag>
+                        => htmlTagExpr.Attribute("{{attrName}}"{{attrValueExpr}});
+                """;
+        }
+    
 
     static string? AssertFileExistsAndApproveContent(Uri GeneratedOutputFilePath, string generatedCSharpContent)
     {
diff --git a/test/ProgressOnderwijsUtils.Tests/WikiPageHtml5.cs b/test/ProgressOnderwijsUtils.Tests/WikiPageHtml5.cs
@@ -211,7 +211,7 @@ public static HtmlFragment MakeHtml()
                     _link._rel("stylesheet")
                         ._href("/w/load.php?debug=false&lang=en&modules=ext.cite.styles%7Cext.uls.interlanguage%7Cext.visualEditor.desktopArticleTarget.noscript%7Cext.wikimediaBadges%7Cmediawiki.legacy.commonPrint%2Cshared%7Cmediawiki.sectionAnchor%7Cmediawiki.skinning.interface%7Cskins.vector.styles%7Cwikibase.client.init&only=styles&skin=vector"),
                     "\n",
-                    _script._async("")
+                    _script._async()
                         ._src("/w/load.php?debug=false&lang=en&modules=startup&only=scripts&skin=vector"),
                     "\n",
                     _meta._name("ResourceLoaderDynamicStyles")

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ static string ToApprovalPath(SourceLocation sourceLocation)`
`11`	`11`	`{`
`12`	`12`	`var filename = Path.GetFileNameWithoutExtension(sourceLocation.FilePath);`
`13`	`13`	`var filedir = Path.GetDirectoryName(sourceLocation.FilePath);`
`14`		`- var approvalPath = $"{filedir}\\{filename}.{sourceLocation.MemberName}.approved.txt";`
	`14`	`+ var approvalPath = Path.Combine(filedir.AssertNotNull(), $"{filename}.{sourceLocation.MemberName}.approved.txt");`
`15`	`15`	`return approvalPath;`
`16`	`16`	`}`
`17`	`17`
Original file line number	Diff line number	Diff line change
`@@ -2030,7 +2030,7 @@ public struct TD : IHtmlElementAllowingContent<TD>, IHasAttr_colspan, IHasAttr_r`
`2030`	`2030`	`public static HtmlFragment operator +(TD head, HtmlFragment tail) => HtmlFragment.Fragment(HtmlFragment.Element(head), tail);`
`2031`	`2031`	`public static HtmlFragment operator +(string head, TD tail) => HtmlFragment.Fragment(head, HtmlFragment.Element(tail));`
`2032`	`2032`	`}`
`2033`		`- public struct TEMPLATE : IHtmlElementAllowingContent<TEMPLATE>, IHasAttr_shadowrootmode, IHasAttr_shadowrootdelegatesfocus, IHasAttr_shadowrootclonable, IHasAttr_shadowrootserializable`
	`2033`	`+ public struct TEMPLATE : IHtmlElementAllowingContent<TEMPLATE>, IHasAttr_shadowrootmode, IHasAttr_shadowrootdelegatesfocus, IHasAttr_shadowrootclonable, IHasAttr_shadowrootserializable, IHasAttr_shadowrootcustomelementregistry`
`2034`	`2034`	`{`
`2035`	`2035`	`public string TagName => "template";`
`2036`	`2036`	`string IHtmlElement.TagStart => "<template";`