fixed type label only working for input macro; added 3 more unit tests

RandomHashTags · RandomHashTags · commit e8d1856cd506 · 2024-09-19T13:17:14.000-05:00
diff --git a/README.md b/README.md
@@ -4,8 +4,8 @@ Write HTML using Swift Macros.
 - Swift Macros are powerful and offer performance benefits
 - Alternative libraries may not fit all situations and may restrict how the html is generated/manipulated, prone to human error, or cost a constant performance overhead (middleware, rendering, result builders, etc)
 - HTML macros enforce safety, can be used anywhere, and compile directly to strings which are easily manipulated
-- The output is already minified at no performance cost
-### Examples
+- The output is minified at no performance cost
+## Examples
 ```swift
 let test:String = #html([
     #body([
diff --git a/Sources/HTMLKit/HTMLKit.swift b/Sources/HTMLKit/HTMLKit.swift
@@ -4575,12 +4575,7 @@ public macro wbr(
     _ innerHTML: [String] = []) -> String = #externalMacro(module: "HTMLKitMacros", type: "HTMLElement")
 
 // MARK: HTMLElementAttribute
-public struct HTMLElementAttribute : Hashable {
-    public let id:String
-
-    init(_ id: String) {
-        self.id = id
-    }
+public enum HTMLElementAttribute {
 }
 
 // MARK: CSSUnit
@@ -4628,7 +4623,6 @@ public extension HTMLElementAttribute.CSSUnit { // https://www.w3schools.com/css
 }
 
 public extension HTMLElementAttribute {
-    typealias type = inputmode
     typealias height = CSSUnit
     typealias width = CSSUnit
 
diff --git a/Sources/HTMLKitMacros/HTMLElement.swift b/Sources/HTMLKitMacros/HTMLElement.swift
@@ -11,7 +11,7 @@ import SwiftSyntaxMacros
 struct HTMLElement : ExpressionMacro {
     static func expansion(of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) throws -> ExprSyntax {
         let type:HTMLElementType = HTMLElementType(rawValue: node.macroName.text)!
-        let data:ElementData = parse_arguments(arguments: node.arguments)
+        let data:ElementData = parse_arguments(elementType: type, arguments: node.arguments)
         var string:String = (type == .html ? "<!DOCTYPE html>" : "") + "<" + type.rawValue + data.attributes + ">" + data.innerHTML
         if !type.isVoid {
             string += "</" + type.rawValue + ">"
@@ -21,7 +21,7 @@ struct HTMLElement : ExpressionMacro {
 }
 
 private extension HTMLElement {
-    static func parse_arguments(arguments: LabeledExprListSyntax) -> ElementData {
+    static func parse_arguments(elementType: HTMLElementType, arguments: LabeledExprListSyntax) -> ElementData {
         var attributes:[String] = [], innerHTML:[String] = []
         for element in arguments.children(viewMode: .all) {
             if let child:LabeledExprSyntax = element.as(LabeledExprSyntax.self) {
@@ -30,7 +30,7 @@ private extension HTMLElement {
                         let tuple:TupleExprSyntax = child.expression.as(TupleExprSyntax.self)!
                         key += "-\(tuple.elements.first!.expression.as(StringLiteralExprSyntax.self)!.string)"
                         attributes.append(key + "=\\\"\(tuple.elements.last!.expression.as(StringLiteralExprSyntax.self)!.string)\\\"")
-                    } else if let string:String = parse_attribute(key: key, expression: child.expression) {
+                    } else if let string:String = parse_attribute(elementType: elementType, key: key, expression: child.expression) {
                         attributes.append(string)
                     }
                 } else if let array:ArrayElementListSyntax = child.expression.as(ArrayExprSyntax.self)?.elements { // inner html
@@ -48,7 +48,7 @@ private extension HTMLElement {
     }
     static func parse_element_macro(expression: MacroExpansionExprSyntax) -> String {
         guard let elementType:HTMLElementType = HTMLElementType(rawValue: expression.macroName.text) else { return "\(expression)" }
-        let data:ElementData = parse_arguments(arguments: expression.arguments)
+        let data:ElementData = parse_arguments(elementType: elementType, arguments: expression.arguments)
         return "<" + elementType.rawValue + data.attributes + ">" + data.innerHTML + (elementType.isVoid ? "" : "</" + elementType.rawValue + ">")
     }
 
@@ -61,7 +61,7 @@ private extension HTMLElement {
         }
     }
     
-    static func parse_attribute(key: String, expression: ExprSyntax) -> String? {
+    static func parse_attribute(elementType: HTMLElementType, key: String, expression: ExprSyntax) -> String? {
         if let boolean:String = expression.as(BooleanLiteralExprSyntax.self)?.literal.text {
             return boolean.elementsEqual("true") ? key : nil
         }
@@ -79,7 +79,24 @@ private extension HTMLElement {
             return yup(value)
         }
         func member(_ value: String) -> String {
-            return yup("\\(HTMLElementAttribute." + key + value + ")")
+            var enumName:String = key
+            switch elementType.rawValue + key { // better performance than switching key, than switching elementType
+                case "buttontype":
+                    enumName = "buttontype"
+                    break
+                case "inputtype":
+                    enumName = "inputmode"
+                    break
+                case "oltype":
+                    enumName = "numberingtype"
+                    break
+                case "scripttype":
+                    enumName = "scripttype"
+                    break
+                default:
+                    break
+            }
+            return yup("\\(HTMLElementAttribute." + enumName + value + ")")
         }
         if let function:FunctionCallExprSyntax = expression.as(FunctionCallExprSyntax.self) {
             return member("\(function)")
diff --git a/Tests/HTMLKitTests/HTMLKitTests.swift b/Tests/HTMLKitTests/HTMLKitTests.swift
@@ -29,12 +29,20 @@ extension HTMLKitTests {
         XCTAssertEqual(#html([]), "<!DOCTYPE html><html></html>")
         XCTAssertEqual(#html(xmlns: "test", []), "<!DOCTYPE html><html xmlns=\"test\"></html>")
     }
+    func test_element_button() {
+        XCTAssertEqual(#button(type: .submit), "<button type=\"submit\"></button>")
+    }
     func test_element_canvas() {
         XCTAssertEqual(#canvas(height: .percent(4), width: .em(2.69)), "<canvas height=\"4.0%\" width=\"2.69em\"></canvas>")
     }
     func test_element_input() {
-        let string:String = #input(type: .text)
-        XCTAssertEqual(string, "<input type=\"text\">")
+        XCTAssertEqual(#input(type: .text), "<input type=\"text\">")
+    }
+    func test_element_ol() {
+        XCTAssertEqual(#ol(type: .a), "<ol type=\"a\"></ol>")
+    }
+    func test_element_script() {
+        XCTAssertEqual(#script(type: .classic), "<script type=\"classic\"></script>")
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -29,12 +29,20 @@ extension HTMLKitTests {`
`29`	`29`	`XCTAssertEqual(#html([]), "<!DOCTYPE html><html></html>")`
`30`	`30`	`XCTAssertEqual(#html(xmlns: "test", []), "<!DOCTYPE html><html xmlns=\"test\"></html>")`
`31`	`31`	`}`
	`32`	`+ func test_element_button() {`
	`33`	`+ XCTAssertEqual(#button(type: .submit), "<button type=\"submit\"></button>")`
	`34`	`+ }`
`32`	`35`	`func test_element_canvas() {`
`33`	`36`	`XCTAssertEqual(#canvas(height: .percent(4), width: .em(2.69)), "<canvas height=\"4.0%\" width=\"2.69em\"></canvas>")`
`34`	`37`	`}`
`35`	`38`	`func test_element_input() {`
`36`		`- let string:String = #input(type: .text)`
`37`		`- XCTAssertEqual(string, "<input type=\"text\">")`
	`39`	`+ XCTAssertEqual(#input(type: .text), "<input type=\"text\">")`
	`40`	`+ }`
	`41`	`+ func test_element_ol() {`
	`42`	`+ XCTAssertEqual(#ol(type: .a), "<ol type=\"a\"></ol>")`
	`43`	`+ }`
	`44`	`+ func test_element_script() {`
	`45`	`+ XCTAssertEqual(#script(type: .classic), "<script type=\"classic\"></script>")`
`38`	`46`	`}`
`39`	`47`	`}`
`40`	`48`