0.3.0 (#8)

* 6.1.0 builds

* update README for 0.3

* API changes

- rename $Routing.prefix to $Routing.$prefix to avoid collision with a route named prefix
- rename resolvedPath to path (path can be a string or a function, depending on the route definition, now)
- add prefixedPath to work like rawPath but with the routing prefix
- remove path from- and add prefixedPath to MacroRoutingRoute (protocol)

+ Update tests

* don't escape arguments unless they need it

Author: scoates

.swift-version

@@ -0,0 +1 @@
+6.2.0

Package.swift

@@ -1,5 +1,4 @@
-// swift-tools-version:6.2
-// The swift-tools-version declares the minimum version of Swift required to build this package.
+// swift-tools-version:6.1.0
 
 import PackageDescription
 import CompilerPluginSupport

README.md

@@ -96,7 +96,7 @@ The main benefits to this approach are:
 - route lookup with `Controller.$Routing.routeName` where `routeName` is the function name (or declared route name)
   - If you have a `@MacroRouting` controller, a `$Routing` property is synthesized (this is a controller-specific struct, which includes routing info for each of your declared routes), so you can look up routes progrmamatically, and at compile time (so you also get code completion, and you can change route paths by changing the value in `@GET("/login")`, seamlessly, if you don't change the name of `AuthController.logIn`, and you'll get help from the compiler if you *do* rename the `logIn` function.
 - you can still use the normal routing methods, including the documented [`RouteCollection`](https://docs.hummingbird.codes/2.0/documentation/hummingbird/routerguide#Route-Collections) + `addRoutes(…)` based approach
-  - `hummingbird-macroroutes` provides a `RouteCollectionContainer` that wraps these to help hint that you shouldn't use the `atPath` signature (see below)
+  - `hummingbird-MacroRouting` provides a `RouteCollectionContainer` that wraps these to help hint that you shouldn't use the `atPath` signature (see below)
   - a `.$routes` var is synthesized on the controller to contain this `RouteCollectionContainer`
 - you can construct route paths based on path arguments, all statically, so if anything changes, the compiler will warn you
 
@@ -105,7 +105,7 @@ The main benefits to this approach are:
 In your `Package.swift`, put this into your `.dependencies`:
 
 ```swift
-    .package(url: "https://github.com/sloatescoan/hummingbird-macrorouting.git", from: "0.2.1")
+    .package(url: "https://github.com/sloatescoan/hummingbird-macrorouting.git", from: "0.3.0")
 ```
 
 …and in your `.target`/`.executableTarget`:
@@ -182,19 +182,19 @@ Additionally, route paths with arguments can be resolved through the synthesized
     }
 ```
 
-Where you might normally get the logs path with `ApiController.$Routing.logs.path`, here, the path has arguments. `.path` would return `/api/logs/{userId}/{timing}`, which isn't exactly useful for passing to a client if you want them to fetch "my logs for today", for example.
+Where you might normally get the logs path with `ApiController.$Routing.logs.path`, here, the path has arguments. If MacroRouting were to supply `.path` as a `String`, it would return `/api/logs/{userId}/{timing}`, which isn't exactly useful for passing to a client if you want them to fetch "my logs for today", for example.
 
-This is where `.resolvedPath` comes in:
+This is where `.path()` comes in:
 
 ```swift
-let logsPath = ApiController.$Routing.logs.resolvedPath(userId: "123", timing: "2025-05-27")
+let logsPath = ApiController.$Routing.logs.path(userId: "123", timing: "2025-05-27")
 ```
 
 This will return: `/api/logs/123/2025-05-27`.
 
-The argument names are synthesized by the HummingbirdMacroRouting, so they're available to well-behaving editors/IDEs:
+The argument names are synthesized by MacroRouting, so they're available to well-behaving editors/IDEs:
 
-![IDE completion of `ApiController.$Routing.logs.resolvedPath`](https://files.scoat.es/IKYWGNmUCq.gif)
+![IDE completion of `ApiController.$Routing.logs.path`](https://files.scoat.es/IKYWGNmUCq.gif)
 
 ## Tests
 

Sources/HummingbirdMacroRouting/Protocols/MacroRoutingRoute.swift

@@ -2,7 +2,7 @@ import Hummingbird
 
 public protocol MacroRoutingRoute: Sendable {
     static var method: HTTPRequest.Method {get}
-    static var path: String {get}
+    static var prefixedPath: String {get}
     static var rawPath: String {get}
     static var name: String {get}
     static var handler: String {get}

Sources/RoutingMacros/ReservedWord.swift

@@ -0,0 +1,60 @@
+// this list is from
+// https://github.com/swiftlang/swift-syntax/blob/974c292380c1b7961f901ce43dfc794e8d7ffa57/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift
+// it may need updating over time
+enum ReservedWord: String, RawRepresentable {
+  case `Any`
+  case `as`
+  case `associatedtype`
+  case `break`
+  case `case`
+  case `catch`
+  case `class`
+  case `continue`
+  case `default`
+  case `defer`
+  case `deinit`
+  case `do`
+  case `else`
+  case `enum`
+  case `extension`
+  case `fallthrough`
+  case `false`
+  case `fileprivate`
+  case `for`
+  case `func`
+  case `guard`
+  case `if`
+  case `import`
+  case `in`
+  case `init`
+  case `inout`
+  case `internal`
+  case `is`
+  case `let`
+  case `nil`
+  case `operator`
+  case `precedencegroup`
+  case `private`
+  case `Protocol`
+  case `protocol`
+  case `public`
+  case `repeat`
+  case `rethrows`
+  case `return`
+  case `self`
+  case `Self`
+  case `static`
+  case `struct`
+  case `subscript`
+  case `super`
+  case `switch`
+  case `throw`
+  case `throws`
+  case `true`
+  case `try`
+  case `Type`
+  case `typealias`
+  case `var`
+  case `where`
+  case `while`
+}

Sources/RoutingMacros/RoutingMacros.swift

@@ -167,7 +167,7 @@ public struct RoutingMacro: ExtensionMacro {
                 static let $all: [any MacroRoutingRoute.Type] = [
                     \(routes.map({ "`" + $0.name + "`" + ".self" }).joined(separator: ", "))
                 ]
-                static let prefix: String? = \(prefix == nil ? "nil" : "\"\(prefix!)\"")
+                static let $prefix: String? = \(prefix == nil ? "nil" : "\"\(prefix!)\"")
         """
 
         for route in routes {
@@ -195,17 +195,25 @@ public struct RoutingMacro: ExtensionMacro {
                 struct `\(route.name)`: MacroRoutingRoute {
                     private init() {}
                     static let method: HTTPRequest.Method = .\(route.method.rawValue.lowercased())
-                    static let rawPath: String = "\(route.path)"
                     static let handler: String = "\(route.handler)"
                     static let name: String = "\(route.name)"
+                    static let prefixedPath: String = "\(prefixedPath)"
+                    static let rawPath: String = "\(route.path)"
             """
 
             if captured.count > 0 {
-                // for routes that have captured arguments, mark path as deprecated, and provide resolvedPath
+                // for routes that have captured arguments, provide path(…) (formerly resolvedPath(…))
                 code += """
-                    @available(*, deprecated, renamed: "rawPath", message: "path will be removed for routes that have captured arguments; you probably want resolvedPath(…)")
-                    static let path: String = "\(prefixedPath)"
+                    @available(*, deprecated, renamed: "path", message: "resolvedPath(…) has been renamed to path(…)")
                     static func resolvedPath(\(captured.map({ "\($0): String"}).joined(separator: ", "))) -> String {
+                        path(\(captured.map({
+                            ReservedWord(rawValue: $0) == nil ?
+                                "\($0): \($0)"
+                                :
+                                "`\($0)`: `\($0)`"
+                        }).joined(separator: ", ")))
+                    }
+                    static func path(\(captured.map({ "\($0): String"}).joined(separator: ", "))) -> String {
                         "/\(out.joined(separator: "/"))"
                     }
                 """

Tests/HummingbirdMacroRoutingTests.swift

@@ -12,9 +12,11 @@ struct SimpleMacroRoutingTests {
     func testStructureStatic() {
         #expect(Controller.$Routing.logIn.method == .get)
         #expect(Controller.$Routing.logIn.path == "/login")
+        #expect(Controller.$Routing.logIn.prefixedPath == "/login")
 
         #expect(Controller.$Routing.logOutHandler.method == .post)
         #expect(Controller.$Routing.logOutHandler.path == "/logout")
+        #expect(Controller.$Routing.logOutHandler.prefixedPath == "/logout")
     }
 
     @Test("Instance Structure")

Tests/Sources/TrickyMacroRoutingController.swift

@@ -10,7 +10,7 @@ struct TrickyMacroRoutingController {
         return .init(status: .ok, body: .init(byteBuffer: ByteBuffer(string: "Logged in")))
     }
 
-    @POST("/func/{throw}/{catch}")
+    @POST("/func/{foo}/{throw}/{catch}")
     @Sendable func `func`(request: Request, context: Context) async throws -> Response {
         return .init(status: .ok, body: .init(byteBuffer: ByteBuffer(string: "Logged out")))
     }

Tests/TestPathArguments.swift

@@ -11,40 +11,40 @@ struct MacroRoutingTestPathArguments {
     @Test("Static Structure")
     func testStructureStatic() {
         #expect(Controller.$Routing.bookTitle.method == .get)
-        #expect(Controller.$Routing.bookTitle.path == "/book/:title")
+        #expect(Controller.$Routing.bookTitle.rawPath == "/book/:title")
     }
 
     @Test("Replacements")
     func testReplacements() {
         #expect(
-            Controller.$Routing.bookTitle.resolvedPath(title: "cryptonomicon") == "/book/cryptonomicon"
+            Controller.$Routing.bookTitle.path(title: "cryptonomicon") == "/book/cryptonomicon"
         )
         #expect(
-            Controller.$Routing.movieTitle.resolvedPath(title: "ratatouille") == "/movie/ratatouille"
+            Controller.$Routing.movieTitle.path(title: "ratatouille") == "/movie/ratatouille"
         )
 
         #expect(
-            Controller.$Routing.bookTitleYear.resolvedPath(
+            Controller.$Routing.bookTitleYear.path(
                 title: "cryptonomicon", year: "1999"
             ) == "/book/cryptonomicon/1999"
         )
         #expect(
-            Controller.$Routing.movieTitleYear.resolvedPath(
+            Controller.$Routing.movieTitleYear.path(
                 title: "ratatouille", year: "2007"
             ) == "/movie/ratatouille/2007"
         )
 
-        #expect(Controller.$Routing.other.path == "/other/{one}/{two}/{three}/{four}/{five}")
+        #expect(Controller.$Routing.other.rawPath == "/other/{one}/{two}/{three}/{four}/{five}")
         #expect(
-            Controller.$Routing.other.resolvedPath(
+            Controller.$Routing.other.path(
                 one: "apple", two: "banana", three: "carrot",
                 four: "durian", five: "eggplant" 
             ) == "/other/apple/banana/carrot/durian/eggplant"
         )
 
-        #expect(Controller.$Routing.mixed.path == "/mixed/{one}/:two/{three}/:four/{five}")
+        #expect(Controller.$Routing.mixed.rawPath == "/mixed/{one}/:two/{three}/:four/{five}")
         #expect(
-            Controller.$Routing.mixed.resolvedPath(
+            Controller.$Routing.mixed.path(
                 one: "apple", two: "banana", three: "carrot",
                 four: "durian", five: "eggplant" 
             ) == "/mixed/apple/banana/carrot/durian/eggplant"

Tests/TestPrefix.swift

@@ -10,13 +10,15 @@ struct MacroRoutingTestPrefix {
 
     @Test("Static Structure")
     func testStructureStatic() {
-        #expect(Controller.$Routing.prefix == "/api")
+        #expect(Controller.$Routing.$prefix == "/api")
 
         #expect(Controller.$Routing.auth.method == .get)
-        #expect(Controller.$Routing.auth.path == "/api/auth")
-        #expect(Controller.$Routing.deauth.path == "/api/deauth")
+        #expect(Controller.$Routing.auth.prefixedPath == "/api/auth")
+        #expect(Controller.$Routing.deauth.prefixedPath == "/api/deauth")
         #expect(Controller.$Routing.auth.rawPath == "/auth")
         #expect(Controller.$Routing.deauth.rawPath == "/deauth")
+        #expect(Controller.$Routing.auth.path == "/api/auth")
+        #expect(Controller.$Routing.deauth.path == "/api/deauth")
     }
 
     @Test("Instance Structure")
@@ -49,7 +51,11 @@ struct MacroRoutingTestPrefix {
 
     @Test("Resolved Path")
     func testPathResolution() async throws {
+        #expect(Controller.$Routing.auth.rawPath == "/auth")
+        #expect(Controller.$Routing.auth.prefixedPath == "/api/auth")
         #expect(Controller.$Routing.auth.path == "/api/auth")
-        #expect(Controller.$Routing.deauthId.resolvedPath(id: "test") == "/api/deauth/test")
+        #expect(Controller.$Routing.deauthId.rawPath == "/deauth/:id")
+        #expect(Controller.$Routing.deauthId.prefixedPath == "/api/deauth/:id")
+        #expect(Controller.$Routing.deauthId.path(id: "test") == "/api/deauth/test")
     }
 }