more progress on using a closure for the innerHTML

Author: RandomHashTags

Sources/HTMLElements/CustomElement.swift

@@ -17,12 +17,12 @@ public struct custom : HTMLElement {
     public var attributes:[HTMLAttribute]
     public var innerHTML:[CustomStringConvertible & Sendable]
 
-    @usableFromInline internal var encoding:HTMLEncoding = .string
+    public private(set) var encoding:HTMLEncoding = .string
     public var isVoid:Bool
     public var trailingSlash:Bool
     public var escaped:Bool = false
 
-    @usableFromInline internal var fromMacro:Bool = false
+    public private(set) var fromMacro:Bool = false
 
     public init(_ encoding: HTMLEncoding, _ data: HTMLKitUtilities.ElementData) {
         self.encoding = encoding

Sources/HTMLElements/HTMLElement.swift

@@ -13,6 +13,9 @@ public protocol HTMLElement : CustomStringConvertible, Sendable {
     /// Remapped attribute names.
     static var otherAttributes : [String:String] { get }
 
+    var encoding : HTMLEncoding { get }
+    var fromMacro : Bool { get }
+
     /// Whether or not this element is a void element.
     var isVoid : Bool { get }
 
@@ -38,4 +41,44 @@ extension HTMLElement {
     public static var otherAttributes : [String:String] {
         return [:]
     }
+    @inlinable
+    func render(
+        prefix: String = "",
+        suffix: String = "",
+        items: [String]
+    ) -> String {
+        let l:String, g:String
+        if escaped {
+            l = "<"
+            g = ">"
+        } else {
+            l = "<"
+            g = ">"
+        }
+        var s:String = ""
+        if !prefix.isEmpty {
+            s += l + prefix + g
+        }
+        s += l + tag
+        for attr in self.attributes {
+            if let v = attr.htmlValue(encoding: encoding, forMacro: fromMacro) {
+                let d = attr.htmlValueDelimiter(encoding: encoding, forMacro: fromMacro)
+                s += " " + attr.key + (attr.htmlValueIsVoidable && v.isEmpty ? "" : "=" + d + v + d)
+            }
+        }
+        for item in items {
+            s += " " + item
+        }
+        if isVoid && trailingSlash {
+            s += " /"
+        }
+        s += g
+        for i in innerHTML {
+            s += String(describing: i)
+        }
+        if !suffix.isEmpty {
+            s += l + suffix + g
+        }
+        return s
+    }
 }

Sources/HTMLKitParse/ParseData.swift

@@ -64,7 +64,7 @@ extension HTMLKitUtilities {
         let (string, encoding):(String, HTMLEncoding) = expandMacro(context: context)
         return "\(raw: encodingResult(context: context, node: context.expansion, string: string, for: encoding))"
     }
-    private static func encodingResult(context: HTMLExpansionContext, node: FreestandingMacroExpansionSyntax, string: String, for encoding: HTMLEncoding) -> String {
+    private static func encodingResult(context: HTMLExpansionContext, node: MacroExpansionExprSyntax, string: String, for encoding: HTMLEncoding) -> String {
         func hasNoInterpolation() -> Bool {
             let hasInterpolation:Bool = !string.ranges(of: try! Regex("\\((.*)\\)")).isEmpty
             guard !hasInterpolation else {
@@ -237,6 +237,7 @@ extension HTMLKitUtilities {
     ) -> (CustomStringConvertible & Sendable)? {
         if let expansion = expr.macroExpansion {
             var c = context
+            c.expansion = expansion
             c.arguments = expansion.arguments
             switch expansion.macroName.text {
             case "html", "anyHTML", "uncheckedHTML":

Sources/HTMLKitUtilities/HTMLExpansionContext.swift

@@ -14,7 +14,7 @@ import SwiftSyntaxMacros
 public struct HTMLExpansionContext : @unchecked Sendable {
     #if canImport(SwiftSyntax) && canImport(SwiftSyntaxMacros)
     public let context:MacroExpansionContext
-    public package(set) var expansion:FreestandingMacroExpansionSyntax
+    public var expansion:MacroExpansionExprSyntax
     public var arguments:LabeledExprListSyntax
     #endif
 
@@ -46,7 +46,7 @@ public struct HTMLExpansionContext : @unchecked Sendable {
         elementsRequireEscaping: Bool = true
     ) {
         self.context = context
-        self.expansion = expansion
+        self.expansion = expansion.as(ExprSyntax.self)!.macroExpansion!
         self.ignoresCompilerWarnings = ignoresCompilerWarnings
         self.encoding = encoding
         self.key = key

Sources/HTMLKitUtilityMacros/HTMLElements.swift

@@ -43,8 +43,8 @@ enum HTMLElements : DeclarationMacro {
             public let tag:String = "\(tag)"
             public var attributes:[HTMLAttribute]
             public var innerHTML:[CustomStringConvertible & Sendable]
-            private var encoding:HTMLEncoding = .string
-            private var fromMacro:Bool = false
+            public private(set) var encoding:HTMLEncoding = .string
+            public private(set) var fromMacro:Bool = false
             public let isVoid:Bool = \(isVoid)
             public var trailingSlash:Bool = false
             public var escaped:Bool = false
@@ -100,12 +100,12 @@ enum HTMLElements : DeclarationMacro {
             initializers += "_ innerHTML: CustomStringConvertible & Sendable...\n) {\n"
             initializers += "self.attributes = attributes\n"
             for (key, _, _) in attributes {
-                var key_literal = key
-                if key_literal.first == "`" {
-                    key_literal.removeFirst()
-                    key_literal.removeLast()
+                var keyLiteral = key
+                if keyLiteral.first == "`" {
+                    keyLiteral.removeFirst()
+                    keyLiteral.removeLast()
                 }
-                initializers += "self.\(key_literal) = \(key)\n"
+                initializers += "self.\(keyLiteral) = \(key)\n"
             }
             initializers += "self.innerHTML = innerHTML\n}\n"
 
@@ -117,10 +117,10 @@ enum HTMLElements : DeclarationMacro {
             }
             initializers += "self.attributes = data.globalAttributes\n"
             for (key, value_type, _) in attributes {
-                var key_literal = key
-                if key_literal.first == "`" {
-                    key_literal.removeFirst()
-                    key_literal.removeLast()
+                var keyLiteral = key
+                if keyLiteral.first == "`" {
+                    keyLiteral.removeFirst()
+                    keyLiteral.removeLast()
                 }
                 var value = "as? \(value_type)"
                 switch value_type {
@@ -129,80 +129,68 @@ enum HTMLElements : DeclarationMacro {
                 default:
                     break
                 }
-                initializers += "self.\(key) = data.attributes[\"\(key_literal)\"] " + value + "\n"
+                initializers += "self.\(key) = data.attributes[\"\(keyLiteral)\"] " + value + "\n"
             }
             initializers += "self.innerHTML = data.innerHTML\n"
             initializers += "}"
             string += initializers
 
             var render = "\npublic var description : String {\n"
-            var attributes_func = "func attributes() -> String {\n"
+            var attributes_func = ""
+            var itemsArray:String = ""
             if !attributes.isEmpty {
                 attributes_func += "let sd = encoding.stringDelimiter(forMacro: fromMacro)\n"
-                attributes_func += "var"
-            } else {
-                attributes_func += "let"
+                itemsArray += "var items:[String] = []\n"
             }
-            attributes_func += " items:[String] = self.attributes.compactMap({\n"
-            attributes_func += "guard let v = $0.htmlValue(encoding: encoding, forMacro: fromMacro) else { return nil }\n"
-            attributes_func += "let d = $0.htmlValueDelimiter(encoding: encoding, forMacro: fromMacro)\n"
-            attributes_func += #"return $0.key + ($0.htmlValueIsVoidable && v.isEmpty ? "" : "=" + d + v + d)"#
-            attributes_func += "\n})\n"
             for (key, value_type, _) in attributes {
-                var key_literal = key
-                if key_literal.first == "`" {
-                    key_literal.removeFirst()
-                    key_literal.removeLast()
+                var keyLiteral = key
+                if keyLiteral.first == "`" {
+                    keyLiteral.removeFirst()
+                    keyLiteral.removeLast()
                 }
-                let variable_name = key_literal
-                if key_literal == "httpEquiv" {
-                    key_literal = "http-equiv"
-                } else if key_literal == "acceptCharset" {
-                    key_literal = "accept-charset"
+                let variable_name = keyLiteral
+                if keyLiteral == "httpEquiv" {
+                    keyLiteral = "http-equiv"
+                } else if keyLiteral == "acceptCharset" {
+                    keyLiteral = "accept-charset"
                 }
                 if value_type == "Bool" {
-                    attributes_func += "if \(key) { items.append(\"\(key_literal)\") }\n"
+                    itemsArray += "if \(key) { items.append(\"\(keyLiteral)\") }\n"
                 } else if value_type.first == "[" {
-                    attributes_func += "if let _\(variable_name):String = "
+                    itemsArray += "if let _\(variable_name):String = "
                     let separator = separator(key: key)
                     switch value_type {
                     case "[String]":
-                        attributes_func += "\(key)?"
+                        itemsArray += "\(key)?"
                     case "[Int]", "[Float]":
-                        attributes_func += "\(key)?.map({ \"\\($0)\" })"
+                        itemsArray += "\(key)?.map({ \"\\($0)\" })"
                     default:
-                        attributes_func += "\(key)?.compactMap({ return $0.htmlValue(encoding: encoding, forMacro: fromMacro) })"
+                        itemsArray += "\(key)?.compactMap({ return $0.htmlValue(encoding: encoding, forMacro: fromMacro) })"
                     }
-                    attributes_func += ".joined(separator: \"\(separator)\") {\n"
-                    attributes_func += #"let k:String = _\#(variable_name).isEmpty ? "" : "=" + sd + _\#(variable_name) + sd"#
-                    attributes_func += "\nitems.append(\"\(key_literal)\" + k)"
-                    attributes_func += "\n}\n"
+                    itemsArray += ".joined(separator: \"\(separator)\") {\n"
+                    itemsArray += #"let k:String = _\#(variable_name).isEmpty ? "" : "=" + sd + _\#(variable_name) + sd"#
+                    itemsArray += "\nitems.append(\"\(keyLiteral)\" + k)"
+                    itemsArray += "\n}\n"
                 } else if value_type == "String" || value_type == "Int" || value_type == "Float" || value_type == "Double" {
                     let value = value_type == "String" ? key : "String(describing: \(key))"
-                    attributes_func += #"if let \#(key) { items.append("\#(key_literal)=" + sd + \#(value) + sd) }"#
-                    attributes_func += "\n"
+                    itemsArray += #"if let \#(key) { items.append("\#(keyLiteral)=" + sd + \#(value) + sd) }"#
+                    itemsArray += "\n"
                 } else {
-                    attributes_func += "if let \(key), let v = \(key).htmlValue(encoding: encoding, forMacro: fromMacro) {\n"
-                    attributes_func += #"let s = \#(key).htmlValueIsVoidable && v.isEmpty ? "" : "=" + sd + v + sd"#
-                    attributes_func += "\nitems.append(\"\(key_literal)\" + s)"
-                    attributes_func += "\n}\n"
+                    itemsArray += "if let \(key), let v = \(key).htmlValue(encoding: encoding, forMacro: fromMacro) {\n"
+                    itemsArray += #"let s = \#(key).htmlValueIsVoidable && v.isEmpty ? "" : "=" + sd + v + sd"#
+                    itemsArray += "\nitems.append(\"\(keyLiteral)\" + s)"
+                    itemsArray += "\n}\n"
                 }
             }
-            attributes_func += "return (items.isEmpty ? \"\" : \" \") + items.joined(separator: \" \")\n}\n"
-            render += attributes_func
-            render += "let string:String = innerHTML.map({ String(describing: $0) }).joined()\n"
-            let trailing_slash = isVoid ? " + (trailingSlash ? \" /\" : \"\")" : ""
-            render += """
-            let l:String, g:String
-            if escaped {
-                l = "<"
-                g = ">"
-            } else {
-                l = "<"
-                g = ">"
+            render += attributes_func + itemsArray
+            render += "return render("
+            if tag == "html" {
+                render += "prefix: \"!DOCTYPE html\", "
             }
-            """
-            render += "return \(tag == "html" ? "l + \"!DOCTYPE html\" + g + " : "")l + tag + attributes()\(trailing_slash) + g + string" + (isVoid ? "" : " + l + \"/\" + tag + g")
+            if !isVoid {
+                render += "suffix: \"/\" + tag, "
+            }
+            render += "items: \(itemsArray.isEmpty ? "[]" : "items"))"
             render += "}"
 
             string += render

Tests/HTMLKitTests/HTMLKitTests.swift

@@ -39,7 +39,7 @@ struct HTMLKitTests {
         public init(_ encoding: HTMLEncoding, _ data: HTMLKitUtilities.ElementData) {
         }
 
-        private var encoding:HTMLEncoding = .string
+        public private(set) var encoding:HTMLEncoding = .string
 
         /// Causes the browser to treat the linked URL as a download. Can be used with or without a `filename` value.
         /// 
@@ -58,7 +58,7 @@ struct HTMLKitTests {
         public var ping:[String] = []
         public var rel:[HTMLAttribute.Extra.rel] = []
         public var escaped:Bool = false
-        private var fromMacro:Bool = false
+        public private(set) var fromMacro:Bool = false
         public let isVoid:Bool = false
         public var referrerPolicy:HTMLAttribute.Extra.referrerpolicy? = nil
         public var target:HTMLAttribute.Extra.target? = nil