now parses element attributes correctly (with 1 exception), and...

RandomHashTags · RandomHashTags · commit 2095b9617ba2 · 2024-11-21T06:55:33.000-06:00
- macro expansion now escapes html where applicable
- fixed two unit tests in `HTMLKitTests.swift`
- macro compilation should be slightly faster (than v0.9.0) due to how parsing of extra attributes works
diff --git a/Sources/HTMLKitUtilities/HTMLElementAttribute.swift b/Sources/HTMLKitUtilities/HTMLElementAttribute.swift
@@ -75,7 +75,7 @@ public enum HTMLElementAttribute : Hashable {
             guard let s:String = expression.integerLiteral?.literal.text else { return nil }
             return Int(s)
         }
-        func array_string() -> [String] { expression.array!.elements.map({ $0.expression.stringLiteral!.string }) }
+        func array_string() -> [String] { expression.array?.elements.compactMap({ $0.expression.stringLiteral?.string }) ?? [] }
         func float() -> Float? {
             guard let s:String = expression.floatLiteral?.literal.text else { return nil }
             return Float(s)
diff --git a/Sources/HTMLKitUtilities/HTMLElementAttributeExtra.swift b/Sources/HTMLKitUtilities/HTMLElementAttributeExtra.swift
@@ -27,6 +27,71 @@ public extension HTMLInitializable where Self: RawRepresentable, RawValue == Str
 // MARK: HTMLElementAttribute.Extra
 extension HTMLElementAttribute {
     public enum Extra {
+
+        public static func parse(key: String, expr: ExprSyntax) -> (any HTMLInitializable)? {
+            func get<T : HTMLInitializable>(_ type: T.Type) -> T? {
+                let inner_key:String, arguments:LabeledExprListSyntax
+                if let function:FunctionCallExprSyntax = expr.functionCall {
+                    inner_key = function.calledExpression.memberAccess!.declName.baseName.text
+                    arguments = function.arguments
+                } else if let member:MemberAccessExprSyntax = expr.memberAccess {
+                    inner_key = member.declName.baseName.text
+                    arguments = LabeledExprListSyntax()
+                } else {
+                    return nil
+                }
+                return T(key: inner_key, arguments: arguments)
+            }
+            switch key {
+                case "as": return get(`as`.self)
+                case "autocapitalize": return get(autocapitalize.self)
+                case "autocomplete": return get(autocomplete.self)
+                case "autocorrect": return get(autocorrect.self)
+                case "blocking": return get(blocking.self)
+                case "buttontype": return get(buttontype.self)
+                case "capture": return get(capture.self)
+                case "command": return get(command.self)
+                case "contenteditable": return get(contenteditable.self)
+                case "controlslist": return get(controlslist.self)
+                case "crossorigin": return get(crossorigin.self)
+                case "decoding": return get(decoding.self)
+                case "dir": return get(dir.self)
+                case "dirname": return get(dirname.self)
+                case "draggable": return get(draggable.self)
+                case "download": return get(download.self)
+                case "enterkeyhint": return get(enterkeyhint.self)
+                case "event": return get(event.self)
+                case "fetchpriority": return get(fetchpriority.self)
+                case "formenctype": return get(formenctype.self)
+                case "formmethod": return get(formmethod.self)
+                case "formtarget": return get(formtarget.self)
+                case "hidden": return get(hidden.self)
+                case "httpEquiv": return get(httpequiv.self)
+                case "inputmode": return get(inputmode.self)
+                case "inputtype": return get(inputtype.self)
+                case "kind": return get(kind.self)
+                case "loading": return get(loading.self)
+                case "numberingtype": return get(numberingtype.self)
+                case "popover": return get(popover.self)
+                case "popovertargetaction": return get(popovertargetaction.self)
+                case "preload": return get(preload.self)
+                case "referrerpolicy": return get(referrerpolicy.self)
+                case "rel": return get(rel.self)
+                case "sandbox": return get(sandbox.self)
+                case "scripttype": return get(scripttype.self)
+                case "scope": return get(scope.self)
+                case "shadowrootmode": return get(shadowrootmode.self)
+                case "shadowrootclonable": return get(shadowrootclonable.self)
+                case "shape": return get(shape.self)
+                case "spellcheck": return get(spellcheck.self)
+                case "target": return get(target.self)
+                case "translate": return get(translate.self)
+                case "virtualkeyboardpolicy": return get(virtualkeyboardpolicy.self)
+                case "wrap": return get(wrap.self)
+                case "writingsuggestions": return get(writingsuggestions.self)
+                default: return nil
+            }
+        }
     }
 }
 public extension HTMLElementAttribute.Extra {
@@ -124,7 +189,7 @@ public extension HTMLElementAttribute.Extra {
                 guard let s:String = expression.integerLiteral?.literal.text else { return nil }
                 return Int(s)
             }
-            func array_string() -> [String] { expression.array!.elements.map({ $0.expression.stringLiteral!.string }) }
+            func array_string() -> [String] { expression.array?.elements.compactMap({ $0.expression.stringLiteral?.string }) ?? [] }
             func float() -> Float? {
                 guard let s:String = expression.floatLiteral?.literal.text else { return nil }
                 return Float(s)
diff --git a/Sources/HTMLKitUtilities/HTMLEncoding.swift b/Sources/HTMLKitUtilities/HTMLEncoding.swift
@@ -55,6 +55,7 @@ public enum HTMLEncoding {
     /// Use `$0` for the compiled HTML.
     /// - Parameters:
     ///   - logic: The encoding logic, represented as a string.
+    /// - Warning: The custom type needs to conform to `CustomStringConvertible` to be returned by the html macro!
     /// ### Example Usage
     /// ```swift
     /// let _:String = #html(encoding: .custom(#"String("$0")"#), p(5)) // String("<p>5</p>")
diff --git a/Sources/HTMLKitUtilities/HTMLKitUtilities.swift b/Sources/HTMLKitUtilities/HTMLKitUtilities.swift
@@ -5,6 +5,8 @@
 //  Created by Evan Anderson on 9/19/24.
 //
 
+import SwiftSyntax
+
 // MARK: HTMLKitUtilities
 public enum HTMLKitUtilities {
     public struct ElementData {
@@ -68,40 +70,87 @@ public extension String {
 
 // MARK: CSSUnit
 public extension HTMLElementAttribute {
-    enum CSSUnit { // https://www.w3schools.com/cssref/css_units.php
+    enum CSSUnit : HTMLInitializable { // https://www.w3schools.com/cssref/css_units.php
         // absolute
-        case centimeters(_ value: Float)
-        case millimeters(_ value: Float)
+        case centimeters(_ value: Float?)
+        case millimeters(_ value: Float?)
         /// 1 inch = 96px = 2.54cm
-        case inches(_ value: Float)
+        case inches(_ value: Float?)
         /// 1 pixel = 1/96th of 1inch
-        case pixels(_ value: Float)
+        case pixels(_ value: Float?)
         /// 1 point = 1/72 of 1inch
-        case points(_ value: Float)
+        case points(_ value: Float?)
         /// 1 pica = 12 points
-        case picas(_ value: Float)
+        case picas(_ value: Float?)
         
         // relative
         /// Relative to the font-size of the element (2em means 2 times the size of the current font)
-        case em(_ value: Float)
+        case em(_ value: Float?)
         /// Relative to the x-height of the current font (rarely used)
-        case ex(_ value: Float)
+        case ex(_ value: Float?)
         /// Relative to the width of the "0" (zero)
-        case ch(_ value: Float)
+        case ch(_ value: Float?)
         /// Relative to font-size of the root element
-        case rem(_ value: Float)
+        case rem(_ value: Float?)
         /// Relative to 1% of the width of the viewport
-        case viewportWidth(_ value: Float)
+        case viewportWidth(_ value: Float?)
         /// Relative to 1% of the height of the viewport
-        case viewportHeight(_ value: Float)
+        case viewportHeight(_ value: Float?)
         /// Relative to 1% of viewport's smaller dimension
-        case viewportMin(_ value: Float)
+        case viewportMin(_ value: Float?)
         /// Relative to 1% of viewport's larger dimension
-        case viewportMax(_ value: Float)
+        case viewportMax(_ value: Float?)
         /// Relative to the parent element
-        case percent(_ value: Float)
+        case percent(_ value: Float?)
+
+        public init?(key: String, arguments: LabeledExprListSyntax) {
+            func float() -> Float? {
+                guard let s:String = arguments.first!.expression.floatLiteral?.literal.text else { return nil }
+                return Float(s)
+            }
+            switch key {
+                case "centimeters": self = .centimeters(float())
+                case "millimeters": self = .millimeters(float())
+                case "inches": self = .inches(float())
+                case "pixels": self = .pixels(float())
+                case "points": self = .points(float())
+                case "picas": self = .picas(float())
+
+                case "em": self = .em(float())
+                case "ex": self = .ex(float())
+                case "ch": self = .ch(float())
+                case "rem": self = .rem(float())
+                case "viewportWidth": self = .viewportWidth(float())
+                case "viewportHeight": self = .viewportHeight(float())
+                case "viewportMin": self = .viewportMin(float())
+                case "viewportMax": self = .viewportMax(float())
+                case "percent": self = .percent(float())
+                default: return nil
+            }
+        }
 
-        public var htmlValue : String {
+        public var key : String {
+            switch self {
+                case .centimeters(_):    return "centimeters"
+                case .millimeters(_):    return "millimeters"
+                case .inches(_):         return "inches"
+                case .pixels(_):         return "pixels"
+                case .points(_):         return "points"
+                case .picas(_):          return "picas"
+
+                case .em(_):             return "em"
+                case .ex(_):             return "ex"
+                case .ch(_):             return "ch"
+                case .rem(_):            return "rem"
+                case .viewportWidth(_):  return "viewportWidth"
+                case .viewportHeight(_): return "viewportHeight"
+                case .viewportMin(_):    return "viewportMin"
+                case .viewportMax(_):    return "viewportMax"
+                case .percent(_):        return "percent"
+            }
+        }
+
+        public var htmlValue : String? {
             switch self {
                 case .centimeters(let v),
                         .millimeters(let v),
@@ -147,12 +196,13 @@ public extension HTMLElementAttribute {
 }
 
 // MARK: LiteralReturnType
-public indirect enum LiteralReturnType {
+public enum LiteralReturnType {
     case boolean(Bool)
     case string(String)
-    case enumCase(String)
+    case int(Int)
+    case float(Float)
     case interpolation(String)
-    case array(of: LiteralReturnType)
+    case array([Any])
 
     public var isInterpolation : Bool {
         switch self {
@@ -166,26 +216,24 @@ public indirect enum LiteralReturnType {
             default: return false
         }
     }
-    public var isEnumCase : Bool {
-        switch self {
-            case .enumCase(_): return true
-            default: return false
-        }
-    }
 
     public func value(key: String) -> String? {
         switch self {
             case .boolean(let b): return b ? key : nil
-            case .string(var string), .enumCase(var string):
-                if string.isEmpty && (isEnumCase || isString && key == "attributionsrc") {
+            case .string(var string):
+                if string.isEmpty && key == "attributionsrc" {
                     return ""
                 }
                 string.escapeHTML(escapeAttributes: true)
                 return string
+            case .int(let int):
+                return String(describing: int)
+            case .float(let float):
+                return String(describing: float)
             case .interpolation(let string):
                 return string
-            case .array(let value):
-                return ""
+            case .array(_):
+                return nil
         }
     }
 }
diff --git a/Sources/HTMLKitUtilities/HTMX.swift b/Sources/HTMLKitUtilities/HTMX.swift
@@ -67,7 +67,7 @@ public extension HTMLElementAttribute {
                 guard let s:String = expression.integerLiteral?.literal.text else { return nil }
                 return Int(s)
             }
-            func array_string() -> [String] { expression.array!.elements.map({ $0.expression.stringLiteral!.string }) }
+            func array_string() -> [String] { expression.array?.elements.compactMap({ $0.expression.stringLiteral?.string }) ?? [] }
             func float() -> Float? {
                 guard let s:String = expression.floatLiteral?.literal.text else { return nil }
                 return Float(s)
diff --git a/Sources/HTMLKitUtilities/HTMXAttributes.swift b/Sources/HTMLKitUtilities/HTMXAttributes.swift
@@ -123,7 +123,7 @@ public extension HTMLElementAttribute.HTMX {
 
         public init?(key: String, arguments: LabeledExprListSyntax) {
             let expression:ExprSyntax = arguments.first!.expression
-            func array_string() -> [String] { expression.array!.elements.map({ $0.expression.stringLiteral!.string }) }
+            func array_string() -> [String] { expression.array?.elements.compactMap({ $0.expression.stringLiteral?.string }) ?? [] }
             switch key {
                 case "all":  self = .all
                 case "none": self = .none
diff --git a/Sources/HTMLKitUtilities/ParseData.swift b/Sources/HTMLKitUtilities/ParseData.swift
@@ -44,11 +44,17 @@ public extension HTMLKitUtilities {
                     } else {
                         if key == "acceptCharset" {
                             key = "accept-charset"
-                        } else if key == "httpEquiv" {
-                            key = "http-equiv"
                         }
-                        if let string:String = parse_literal_value(context: context, key: key, expression: child.expression, lookupFiles: lookupFiles)?.value(key: key) {
-                            attributes[key] = string
+                        if let test:any HTMLInitializable = HTMLElementAttribute.Extra.parse(key: key, expr: child.expression) {
+                            attributes[key] = test
+                        } else if let string:LiteralReturnType = parse_literal_value(context: context, key: key, expression: child.expression, lookupFiles: lookupFiles) {
+                            switch string {
+                                case .boolean(let b): attributes[key] = b
+                                case .string(let s), .interpolation(let s): attributes[key] = s
+                                case .int(let i): attributes[key] = i
+                                case .float(let f): attributes[key] = f
+                                case .array(let values): attributes[key] = values
+                            }
                         }
                     }
                 // inner html
@@ -140,8 +146,11 @@ public extension HTMLKitUtilities {
         if let boolean:String = expression.booleanLiteral?.literal.text {
             return .boolean(boolean == "true")
         }
-        if let string:String = expression.integerLiteral?.literal.text ?? expression.floatLiteral?.literal.text {
-            return .string(string)
+        if let string:String = expression.integerLiteral?.literal.text {
+            return .int(Int(string)!)
+        }
+        if let string:String = expression.floatLiteral?.literal.text {
+            return .float(Float(string)!)
         }
         guard var returnType:LiteralReturnType = extract_literal(context: context, key: key, expression: expression, lookupFiles: lookupFiles) else {
             //context.diagnose(Diagnostic(node: expression, message: DiagnosticMsg(id: "somethingWentWrong", message: "Something went wrong. (" + expression.debugDescription + ")", severity: .warning)))
@@ -183,22 +192,17 @@ public extension HTMLKitUtilities {
             return stringLiteral.segments.count(where: { $0.is(ExpressionSegmentSyntax.self) }) == 0 ? .string(string) : .interpolation(string)
         }
         if let function:FunctionCallExprSyntax = expression.functionCall {
-            let enums:Set<String> = ["command", "download", "height", "width"]
-            if enums.contains(key) || key.hasPrefix("aria-") {
-                return .enumCase("")
-            } else {
-                if let decl:String = function.calledExpression.as(DeclReferenceExprSyntax.self)?.baseName.text {
-                    switch decl {
-                        case "StaticString":
-                            var string:String = function.arguments.first!.expression.stringLiteral!.string
-                            return .string(string)
-                        default:
-                            if let element:HTMLElement = HTMLElementValueType.parse_element(context: context, function) {
-                                let string:String = element.description
-                                return string.contains("\\(") ? .interpolation(string) : .string(string)
-                            }
-                            break
-                    }
+            if let decl:String = function.calledExpression.as(DeclReferenceExprSyntax.self)?.baseName.text {
+                switch decl {
+                    case "StaticString":
+                        let string:String = function.arguments.first!.expression.stringLiteral!.string
+                        return .string(string)
+                    default:
+                        if let element:HTMLElement = HTMLElementValueType.parse_element(context: context, function) {
+                            let string:String = element.description
+                            return string.contains("\\(") ? .interpolation(string) : .string(string)
+                        }
+                        break
                 }
                 return .interpolation("\(function)")
             }
@@ -219,21 +223,23 @@ public extension HTMLKitUtilities {
                     separator = " "
                     break
             }
-            var results:[String] = []
+            var results:[Any] = []
             for element in array.elements {
                 if let string:String = element.expression.stringLiteral?.string {
                     if string.contains(separator) {
                         context.diagnose(Diagnostic(node: element.expression, message: DiagnosticMsg(id: "characterNotAllowedInDeclaration", message: "Character \"\(separator)\" is not allowed when declaring values for \"" + key + "\".")))
                         return nil
                     }
                     results.append(string)
-                }
-                if let string:String = element.expression.integerLiteral?.literal.text ?? element.expression.floatLiteral?.literal.text {
-                    results.append(string)
+                } else if let string:String = element.expression.integerLiteral?.literal.text {
+                    results.append(Int(string)!)
+                } else if let string:String = element.expression.floatLiteral?.literal.text {
+                    results.append(Float(string)!)
+                } else if let attribute:any HTMLInitializable = HTMLElementAttribute.Extra.parse(key: key, expr: element.expression) {
+                    results.append(attribute)
                 }
             }
-            let result:String = results.joined(separator: separator)
-            return .array(of: .string(result))
+            return .array(results)
         }
         if let _:DeclReferenceExprSyntax = expression.as(DeclReferenceExprSyntax.self) {
             var string:String = "\(expression)", remaining_interpolation:Int = 1
diff --git a/Sources/HTMLKitUtilityMacros/HTMLElements.swift b/Sources/HTMLKitUtilityMacros/HTMLElements.swift
diff --git a/Tests/HTMLKitTests/HTMLKitTests.swift b/Tests/HTMLKitTests/HTMLKitTests.swift

Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public enum HTMLElementAttribute : Hashable {`
`75`	`75`	`guard let s:String = expression.integerLiteral?.literal.text else { return nil }`
`76`	`76`	`return Int(s)`
`77`	`77`	`}`
`78`		`- func array_string() -> [String] { expression.array!.elements.map({ $0.expression.stringLiteral!.string }) }`
	`78`	`+ func array_string() -> [String] { expression.array?.elements.compactMap({ $0.expression.stringLiteral?.string }) ?? [] }`
`79`	`79`	`func float() -> Float? {`
`80`	`80`	`guard let s:String = expression.floatLiteral?.literal.text else { return nil }`
`81`	`81`	`return Float(s)`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ public extension HTMLElementAttribute {`
`67`	`67`	`guard let s:String = expression.integerLiteral?.literal.text else { return nil }`
`68`	`68`	`return Int(s)`
`69`	`69`	`}`
`70`		`- func array_string() -> [String] { expression.array!.elements.map({ $0.expression.stringLiteral!.string }) }`
	`70`	`+ func array_string() -> [String] { expression.array?.elements.compactMap({ $0.expression.stringLiteral?.string }) ?? [] }`
`71`	`71`	`func float() -> Float? {`
`72`	`72`	`guard let s:String = expression.floatLiteral?.literal.text else { return nil }`
`73`	`73`	`return Float(s)`