Add mvp features

heoblitz · heoblitz · commit 4debd2131b43 · 2025-04-04T17:51:05.000+09:00
diff --git a/Sources/URLPatternClient/main.swift b/Sources/URLPatternClient/main.swift
@@ -3,11 +3,8 @@ import Foundation
 
 @URLPattern
 enum Deeplink {
-//  @URLPath("/post/{id}")
-//  case post(id: String)
-//  
-  @URLPath("/home/{id}/{name}")
-  case name(id: String, name: String)
+  @URLPath("/post/{id}/{name}")
+  case name(id: Int, name: String)
   
   @URLPath("/post/{id}/{name}/hi/{good}")
   case nameDetail(id: String, name: String, good: String)
diff --git a/Sources/URLPatternMacros/URLPathMacro.swift b/Sources/URLPatternMacros/URLPathMacro.swift
@@ -5,13 +5,17 @@ import SwiftSyntaxMacros
 import Foundation
 
 public struct URLPathMacro: PeerMacro {
-  struct CaseParam: Hashable {
-    let index: Int
-    let name: String
+  enum SupportedType: String {
+    case String
+    case Int
+    case Double
+    case Float
   }
   
-  struct PatternPathItem {
-  
+  struct PatternParam: Hashable {
+    let name: String
+    let type: SupportedType
+    let pathIndex: Int
   }
   
   public static func expansion(
@@ -23,48 +27,90 @@ public struct URLPathMacro: PeerMacro {
       let enumCase = declaration.as(EnumCaseDeclSyntax.self),
       let element = enumCase.elements.first
     else {
-      throw MacroError.message("URLPatternPath macro can only be applied to enum cases")
+      throw URLPatternError("@URLPathMacro can only be applied to enum cases")
     }
-
+    
     guard
       let argument = node.arguments?.as(LabeledExprListSyntax.self)?.first,
       let pathString = argument.expression.as(StringLiteralExprSyntax.self)?.segments.first?.description
     else {
-        throw MacroError.message("Invalid path")
+      throw URLPatternError("URLPath is nil")
     }
     
     guard let pathURL = URL(string: pathString) else {
-      throw MacroError.message("URLPatternPath macro requires a string literal path")
+      throw URLPatternError("URLPath is not in a valid URL format")
     }
     
     let patternPaths = pathURL.pathComponents
-
-    let pathComponents = pathURL.pathComponents
-    let parameters = pathComponents.enumerated()
+    
+    let caseAssociatedTypes = try element.parameterClause?.parameters.map { param -> (name: String, type: SupportedType) in
+      let name = param.firstName?.text ?? ""
+      let type = param.type.description
+      
+      guard let supportedType = SupportedType(rawValue: type) else {
+        throw URLPatternError("\(type) is not supported as an associated value")
+      }
+      return (name: name, type: supportedType)
+    } ?? []
+    
+    let patternParams = patternPaths.enumerated()
       .filter { index, value in value.isURLPathParam }
-      .map { CaseParam(index: $0.offset, name: String($0.element.dropFirst().dropLast())) }
+      .map { index, value in
+        let name = String(value.dropFirst().dropLast())
+        return PatternParam(
+          name:name ,
+          type: caseAssociatedTypes.first(where: { name == $0.name })!.type,
+          pathIndex: index
+        )
+      }
     
-    if Set(parameters).count != parameters.count {
-      throw MacroError.message("변수 이름은 중복되서는 안됩니다.")
+    if Set(patternParams.map { $0.name }).count != patternParams.count {
+      throw URLPatternError("The name of an associated value cannot be duplicated")
     }
-
+    
+    if Set(patternParams).count != caseAssociatedTypes.count {
+      throw URLPatternError("The number of associated values does not match URLPath")
+    }
+    
     let staticMethod = try FunctionDeclSyntax("""
       static func \(element.name)(_ url: URL) -> Self? {
-          let inputPaths = url.pathComponents
-          let patternPaths = \(raw: patternPaths)
-      
-          guard isValidURLPaths(inputPaths: inputPaths, patternPaths: patternPaths) else { return nil }
+        let inputPaths = url.pathComponents
+        let patternPaths = \(raw: patternPaths)
       
-          \(raw: parameters.map { param in
-          """
-          let \(param.name) = inputPaths[\(param.index)] 
-          """
+        guard isValidURLPaths(inputPaths: inputPaths, patternPaths: patternPaths) else {
+          return nil
+        }
+                
+        \(raw: patternParams.map { param in
+          switch param.type {
+            case .Double:
+            """
+            guard let \(param.name) = \(param.type.rawValue)(inputPaths[\(param.pathIndex)]) else {
+              return nil
+            }
+            """
+            case .Float:
+            """
+            guard let \(param.name) = \(param.type.rawValue)(inputPaths[\(param.pathIndex)]) else {
+              return nil
+            }
+            """
+            case .Int:
+            """
+            guard let \(param.name) = \(param.type.rawValue)(inputPaths[\(param.pathIndex)]) else {
+              return nil
+            }
+            """
+            case .String:
+            """
+            let \(param.name) = inputPaths[\(param.pathIndex)]
+            """
+            }
           }.joined(separator: "\n"))
           
-          return .\(raw: element.name.text)(\(raw: parameters.map { "\($0.name): \($0.name)" }.joined(separator: ", ")))
+        return .\(raw: element.name.text)(\(raw: patternParams.map { "\($0.name): \($0.name)" }.joined(separator: ", ")))
       }
-      """
-    )
+      """)
     
     return [DeclSyntax(staticMethod)]
   }
diff --git a/Sources/URLPatternMacros/URLPatternMacro.swift b/Sources/URLPatternMacros/URLPatternMacro.swift
@@ -4,27 +4,23 @@ import SwiftSyntaxBuilder
 import SwiftSyntaxMacros
 import Foundation
 
-enum MacroError: Error {
-  case message(String)
-}
-
 public struct URLPatternMacro: MemberMacro {
   public static func expansion(
     of node: AttributeSyntax,
     providingMembersOf declaration: some DeclGroupSyntax,
     in context: some MacroExpansionContext
   ) throws -> [DeclSyntax] {
     guard let enumDecl = declaration.as(EnumDeclSyntax.self) else {
-      throw MacroError.message("This macro can only be applied to enums")
+      throw URLPatternError("@URLPatternMacro can only be applied to enums")
     }
     
     let urlInitializer = try InitializerDeclSyntax("init?(url: URL)") {
       for caseDecl in enumDecl.memberBlock.members.compactMap({ $0.decl.as(EnumCaseDeclSyntax.self) }) {
         if let caseName = caseDecl.elements.first?.name.text {
           """
-          if let result = Self.\(raw: caseName)(url) {
-              self = result
-              return
+          if let urlPattern = Self.\(raw: caseName)(url) {
+            self = urlPattern
+            return
           }
           """
         }
@@ -40,7 +36,7 @@ public struct URLPatternMacro: MemberMacro {
         guard inputs.count == patterns.count else { return false }
         
         return zip(inputs, patterns).allSatisfy { input, pattern in
-          guard pattern.isURLPathParam else { return input == pattern }
+          guard Self.isURLPathParam(pattern) else { return input == pattern }
           
           return true
         }
@@ -49,10 +45,14 @@ public struct URLPatternMacro: MemberMacro {
     
     let isURLPathParamMethod = try FunctionDeclSyntax("""
       static func isURLPathParam(_ string: String) -> Bool {
-        return string.hasPrefix("{") && string.hasSuffix("}") }
+        return string.hasPrefix("{") && string.hasSuffix("}")
       }
       """)
     
-    return [DeclSyntax(urlInitializer), DeclSyntax(isValidURLPathsMethod), DeclSyntax(isURLPathParamMethod)]
+    return [
+      DeclSyntax(urlInitializer),
+      DeclSyntax(isValidURLPathsMethod),
+      DeclSyntax(isURLPathParamMethod)
+    ]
   }
 }
diff --git a/Sources/URLPatternMacros/Utils/URLPatternError.swift b/Sources/URLPatternMacros/Utils/URLPatternError.swift
@@ -0,0 +1,13 @@
+import Foundation
+
+struct URLPatternError: LocalizedError {
+  let errorDescription: String
+  
+  init(_ errorDescription: String) {
+    self.errorDescription = errorDescription
+  }
+}
+
+extension URLPatternError: CustomStringConvertible {
+  var description: String { self.errorDescription }
+}
diff --git a/Tests/URLPatternTests/URLPatternTests.swift b/Tests/URLPatternTests/URLPatternTests.swift
@@ -14,8 +14,6 @@ let testMacros: [String: Macro.Type] = [
 ]
 #endif
 
-
-
 final class URLPatternTests: XCTestCase {
     func testMacro() throws {
       assertMacroExpansion(
@@ -26,59 +24,71 @@ final class URLPatternTests: XCTestCase {
               case post(id: String)
               
               @URLPath("/post/{id}/{name}")
-              case name(id: String, name: String)
+              case name(id: String, name: Int)
           }
           """,
           expandedSource: """
           enum Deeplink {
               case post(id: String)
 
-              static func createFromURLpost(_ url: URL) -> Self? {
-                  let path = url.path
-                  let components = path.split(separator: "/")
+              static func post(_ url: URL) -> Self? {
+                  let inputPaths = url.pathComponents
+                  let patternPaths = ["/", "post", "{id}"]
 
-                  guard components.count == 2 else {
+                  guard isValidURLPaths(inputPaths: inputPaths, patternPaths: patternPaths) else {
                       return nil
                   }
 
-                  guard let id = components[1] as? String else {
-                      return nil
-                  }
+                  let id = inputPaths[2]
 
                   return .post(id: id)
               }
 
               case name(id: String, name: String)
 
-              static func createFromURLname(_ url: URL) -> Self? {
-                  let path = url.path
-                  let components = path.split(separator: "/")
+              static func name(_ url: URL) -> Self? {
+                  let inputPaths = url.pathComponents
+                  let patternPaths = ["/", "post", "{id}", "{name}"]
 
-                  guard components.count == 3 else {
+                  guard isValidURLPaths(inputPaths: inputPaths, patternPaths: patternPaths) else {
                       return nil
                   }
 
-                  guard let id = components[1] as? String else {
-                      return nil
-                  }
-                  guard let name = components[2] as? String else {
-                      return nil
-                  }
+                  let id = inputPaths[2]
+                  let name = inputPaths[3]
 
                   return .name(id: id, name: name)
               }
 
               init?(url: URL) {
-                  if let result = Self.createFromURLpost(url) {
-                                  self = result
-                                  return
+                  if let result = Self.post(url) {
+                      self = result
+                      return
                   }
-                  if let result = Self.createFromURLname(url) {
-                                  self = result
-                                  return
+                  if let result = Self.name(url) {
+                      self = result
+                      return
                   }
                   return nil
               }
+
+              static func isValidURLPaths(inputPaths inputs: [String], patternPaths patterns: [String]) -> Bool {
+                guard inputs.count == patterns.count else {
+                    return false
+                }
+
+                return zip(inputs, patterns).allSatisfy { input, pattern in
+                  guard pattern.isURLPathParam else {
+                      return input == pattern
+                  }
+
+                  return true
+                }
+              }
+
+              static func isURLPathParam(_ string: String) -> Bool {
+                return string.hasPrefix("{") && string.hasSuffix("}")
+              }
           }
           """,
           macros: testMacros
