init project

Author: heoblitz

.gitignore

@@ -60,3 +60,11 @@ fastlane/report.xml
 fastlane/Preview.html
 fastlane/screenshots/**/*.png
 fastlane/test_output
+.DS_Store
+/.build
+/Packages
+xcuserdata/
+DerivedData/
+.swiftpm/configuration/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

Package.resolved

@@ -0,0 +1,51 @@
+// swift-tools-version: 6.0
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+import CompilerPluginSupport
+
+let package = Package(
+    name: "URLPattern",
+    platforms: [.macOS(.v10_15), .iOS(.v13), .tvOS(.v13), .watchOS(.v6), .macCatalyst(.v13)],
+    products: [
+        // Products define the executables and libraries a package produces, making them visible to other packages.
+        .library(
+            name: "URLPattern",
+            targets: ["URLPattern"]
+        ),
+        .executable(
+            name: "URLPatternClient",
+            targets: ["URLPatternClient"]
+        ),
+    ],
+    dependencies: [
+        .package(url: "https://github.com/swiftlang/swift-syntax.git", from: "600.0.0-latest"),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package, defining a module or a test suite.
+        // Targets can depend on other targets in this package and products from dependencies.
+        // Macro implementation that performs the source transformation of a macro.
+        .macro(
+            name: "URLPatternMacros",
+            dependencies: [
+                .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+                .product(name: "SwiftCompilerPlugin", package: "swift-syntax")
+            ]
+        ),
+
+        // Library that exposes a macro as part of its API, which is used in client programs.
+        .target(name: "URLPattern", dependencies: ["URLPatternMacros"]),
+
+        // A client of the library, which is able to use the macro in its own code.
+        .executableTarget(name: "URLPatternClient", dependencies: ["URLPattern"]),
+
+        // A test target used to develop the macro implementation.
+        .testTarget(
+            name: "URLPatternTests",
+            dependencies: [
+                "URLPatternMacros",
+                .product(name: "SwiftSyntaxMacrosTestSupport", package: "swift-syntax"),
+            ]
+        ),
+    ]
+)

Package.swift

@@ -0,0 +1,5 @@
+@attached(member, names: arbitrary)
+public macro URLPattern() = #externalMacro(module: "URLPatternMacros", type: "URLPatternMacro")
+
+@attached(peer, names: arbitrary)
+public macro URLPath(_ path: String) = #externalMacro(module: "URLPatternMacros", type: "URLPathMacro")

Sources/URLPattern/URLPattern.swift

@@ -0,0 +1,35 @@
+import URLPattern
+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}/hi/{good}")
+  case nameDetail(id: String, name: String, good: String)
+  
+  @URLPath("/post/{id}")
+  case nameDetailHI(id: String)
+}
+
+let url1 = URL(string: "https://channel.io/post/12/12")
+let url2 = URL(string: "/post/hi/hello/hi/bye")
+
+// enumPath
+// inputPath
+
+
+print(url1?.pathComponents)
+print(url2?.pathComponents)
+
+
+let hi = URL(string: "https://post/{id}")
+let paths = url1!.pathComponents
+
+print(Deeplink(url: url1!))
+print(Deeplink(url: url2!))
+

Sources/URLPatternClient/main.swift

@@ -0,0 +1,5 @@
+import Foundation
+
+extension String {
+  var isURLPathParam: Bool { self.hasPrefix("{") && self.hasSuffix("}") }
+}

Sources/URLPatternMacros/Extensions/String+Extensions.swift

@@ -0,0 +1,71 @@
+import SwiftCompilerPlugin
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+import Foundation
+
+public struct URLPathMacro: PeerMacro {
+  struct CaseParam: Hashable {
+    let index: Int
+    let name: String
+  }
+  
+  struct PatternPathItem {
+  
+  }
+  
+  public static func expansion(
+    of node: AttributeSyntax,
+    providingPeersOf declaration: some DeclSyntaxProtocol,
+    in context: some MacroExpansionContext
+  ) throws -> [DeclSyntax] {
+    guard
+      let enumCase = declaration.as(EnumCaseDeclSyntax.self),
+      let element = enumCase.elements.first
+    else {
+      throw MacroError.message("URLPatternPath macro 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")
+    }
+    
+    guard let pathURL = URL(string: pathString) else {
+      throw MacroError.message("URLPatternPath macro requires a string literal path")
+    }
+    
+    let patternPaths = pathURL.pathComponents
+
+    let pathComponents = pathURL.pathComponents
+    let parameters = pathComponents.enumerated()
+      .filter { index, value in value.isURLPathParam }
+      .map { CaseParam(index: $0.offset, name: String($0.element.dropFirst().dropLast())) }
+    
+    if Set(parameters).count != parameters.count {
+      throw MacroError.message("변수 이름은 중복되서는 안됩니다.")
+    }
+
+    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 }
+      
+          \(raw: parameters.map { param in
+          """
+          let \(param.name) = inputPaths[\(param.index)] 
+          """
+          }.joined(separator: "\n"))
+          
+          return .\(raw: element.name.text)(\(raw: parameters.map { "\($0.name): \($0.name)" }.joined(separator: ", ")))
+      }
+      """
+    )
+    
+    return [DeclSyntax(staticMethod)]
+  }
+}

Sources/URLPatternMacros/URLPathMacro.swift

@@ -0,0 +1,58 @@
+import SwiftCompilerPlugin
+import SwiftSyntax
+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")
+    }
+    
+    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
+          }
+          """
+        }
+      }
+      
+      """
+      return nil
+      """
+    }
+    
+    let isValidURLPathsMethod = try FunctionDeclSyntax("""
+      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
+        }
+      }
+      """)
+    
+    let isURLPathParamMethod = try FunctionDeclSyntax("""
+      static func isURLPathParam(_ string: String) -> Bool {
+        return string.hasPrefix("{") && string.hasSuffix("}") }
+      }
+      """)
+    
+    return [DeclSyntax(urlInitializer), DeclSyntax(isValidURLPathsMethod), DeclSyntax(isURLPathParamMethod)]
+  }
+}

Sources/URLPatternMacros/URLPatternMacro.swift

@@ -0,0 +1,10 @@
+import SwiftCompilerPlugin
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+import Foundation
+
+@main
+struct URLPatternPlugin: CompilerPlugin {
+  let providingMacros: [Macro.Type] = [URLPatternMacro.self, URLPathMacro.self]
+}

Sources/URLPatternMacros/URLPatternPlugin.swift

@@ -0,0 +1,91 @@
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+import SwiftSyntaxMacrosTestSupport
+import XCTest
+
+// Macro implementations build for the host, so the corresponding module is not available when cross-compiling. Cross-compiled tests may still make use of the macro itself in end-to-end tests.
+#if canImport(URLPatternMacros)
+import URLPatternMacros
+
+let testMacros: [String: Macro.Type] = [
+    "URLPattern": URLPatternMacro.self,
+    "URLPath": URLPathMacro.self
+]
+#endif
+
+
+
+final class URLPatternTests: XCTestCase {
+    func testMacro() throws {
+      assertMacroExpansion(
+          """
+          @URLPattern
+          enum Deeplink {
+              @URLPath("/post/{id}")
+              case post(id: String)
+              
+              @URLPath("/post/{id}/{name}")
+              case name(id: String, name: String)
+          }
+          """,
+          expandedSource: """
+          enum Deeplink {
+              case post(id: String)
+
+              static func createFromURLpost(_ url: URL) -> Self? {
+                  let path = url.path
+                  let components = path.split(separator: "/")
+
+                  guard components.count == 2 else {
+                      return nil
+                  }
+
+                  guard let id = components[1] as? String else {
+                      return nil
+                  }
+
+                  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: "/")
+
+                  guard components.count == 3 else {
+                      return nil
+                  }
+
+                  guard let id = components[1] as? String else {
+                      return nil
+                  }
+                  guard let name = components[2] as? String else {
+                      return nil
+                  }
+
+                  return .name(id: id, name: name)
+              }
+
+              init?(url: URL) {
+                  if let result = Self.createFromURLpost(url) {
+                                  self = result
+                                  return
+                  }
+                  if let result = Self.createFromURLname(url) {
+                                  self = result
+                                  return
+                  }
+                  return nil
+              }
+          }
+          """,
+          macros: testMacros
+      )
+    }
+
+    func testMacroWithStringLiteral() throws {
+
+    }
+}