gardening

Author: swhitty

FlyingFox/Sources/HTTPRequest+RouteParameter.swift

@@ -45,36 +45,7 @@ public extension HTTPRequest {
     }
 
     /// Values extracted from the matched route and request
-    var routeParameters: [RouteParameter] { routeParameters() }
-}
-
-extension HTTPRequest {
-
-    func routeParameters(for route: HTTPRoute? = matchedRoute) -> [RouteParameter] {
-        guard let route else { return [] }
-
-        let pathComponents = path
-            .split(separator: "/", omittingEmptySubsequences: true)
-
-        return route.parameters
-            .compactMap {
-                switch $0 {
-                case let .path(name: name, index: index):
-                    if pathComponents.indices.contains(index) {
-                        return RouteParameter(name: name, value: String(pathComponents[index]))
-                    } else {
-                        return nil
-                    }
-                case let .query(name: name, index: index):
-                    if let value = query[index] {
-                        return RouteParameter(name: name, value: value)
-                    } else {
-                        return nil
-                    }
-                }
-            }
-    }
-
+    var routeParameters: [RouteParameter] { Self.matchedRoute?.extractParameters(from: self) ?? [] }
 }
 
 public extension Array where Element == HTTPRequest.RouteParameter {

FlyingFox/Sources/HTTPRequestParameter.swift

@@ -0,0 +1,110 @@
+//
+//  HTTPRequestParameter.swift
+//  FlyingFox
+//
+//  Created by Simon Whitty on 11/07/2024.
+//  Copyright © 2024 Simon Whitty. All rights reserved.
+//
+//  Distributed under the permissive MIT license
+//  Get the latest version from here:
+//
+//  https://github.com/swhitty/FlyingFox
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+
+/// Converts values from `HTTPRoute.Parameter` with `HTTPRequest`
+public protocol HTTPRouteParameterValue {
+    init(parameter: String) throws
+}
+
+extension String: HTTPRouteParameterValue {
+    public init(parameter: String) {
+        self.init(parameter)
+    }
+}
+
+extension Int: HTTPRouteParameterValue {
+    public init(parameter: String) throws {
+        guard let value = Int(parameter)else {
+            throw HTTPRouteParameterInvalid()
+        }
+        self = value
+    }
+}
+
+public struct HTTPRouteParameterInvalid: Error { }
+
+public extension HTTPRoute {
+
+    func extractParameters(from request: HTTPRequest) -> [HTTPRequest.RouteParameter] {
+        let pathComponents = request.path
+            .split(separator: "/", omittingEmptySubsequences: true)
+
+        return parameters
+            .compactMap {
+                switch $0 {
+                case let .path(name: name, index: index):
+                    if pathComponents.indices.contains(index) {
+                        return HTTPRequest.RouteParameter(
+                            name: name,
+                            value: String(pathComponents[index])
+                        )
+                    } else {
+                        return nil
+                    }
+                case let .query(name: name, index: index):
+                    if let value = request.query[index] {
+                        return HTTPRequest.RouteParameter(
+                            name: name,
+                            value: value
+                        )
+                    } else {
+                        return nil
+                    }
+                }
+            }
+    }
+}
+
+#if compiler(>=5.9)
+extension HTTPRoute {
+
+    func extractParameterValues<each P: HTTPRouteParameterValue>(
+        of type: (repeat each P).Type = (repeat each P).self,
+        from request: HTTPRequest
+    ) throws -> (repeat each P) {
+        let parameters = extractParameters(from: request).map(\.value)
+        var idx = 0
+        return try (repeat getParameter(at: &idx, parameters: parameters, type: (each P).self))
+    }
+
+    private func getParameter<P: HTTPRouteParameterValue>(at index: inout Int, parameters: [String], type: P.Type) throws -> P {
+        defer { index += 1 }
+
+        guard parameters.indices.contains(index) else {
+            throw HTTPRouteParameterInvalid()
+        }
+
+        return try P(parameter: parameters[index])
+    }
+}
+#endif

FlyingFox/Sources/HTTPRouteParameterValue.swift

@@ -69,7 +69,7 @@ public final actor HTTPServer {
     }
 
 #if compiler(>=5.9)
-    public func appendRoute<each P: HTTPRequestParameter>(
+    public func appendRoute<each P: HTTPRouteParameterValue>(
         _ route: HTTPRoute,
         handler: @Sendable @escaping (repeat each P) async throws -> HTTPResponse
     ) {

FlyingFox/Sources/HTTPServer.swift

@@ -45,12 +45,12 @@ public struct RoutedHTTPHandler: HTTPHandler, Sendable {
     }
 
 #if compiler(>=5.9)
-    public mutating func appendRoute<each P: HTTPRequestParameter>(
+    public mutating func appendRoute<each P: HTTPRouteParameterValue>(
         _ route: HTTPRoute,
         handler: @Sendable @escaping (repeat each P) async throws -> HTTPResponse
     ) {
         let closure = ClosureHTTPHandler { request in
-            let params = try request.extractParameters(type: (repeat each P).self)
+            let params = try route.extractParameterValues(of: (repeat each P).self, from: request)
             return try await handler(repeat each params)
         }
         append((route, closure))

FlyingFox/Sources/Handlers/RoutedHTTPHandler.swift

@@ -478,19 +478,19 @@ final class HTTPRouteTests: XCTestCase {
         let request = HTTPRequest.make(path: "/mock/12/hello/fish")
 
         XCTAssertTrue(
-            try request.extractParameters(for: route) == (12, "fish")
+            try route.extractParameterValues(from: request) == (12, "fish")
         )
 
         XCTAssertTrue(
-            try request.extractParameters(for: route) == (12)
+            try route.extractParameterValues(from: request) == (12)
         )
 
         XCTAssertThrowsError(
-            try request.extractParameters(for: route, type: (Int, Int).self)
+            try route.extractParameterValues(of: (Int, Int).self, from: request)
         )
 
         XCTAssertThrowsError(
-            try request.extractParameters(for: route, type: (Int, String, String).self)
+            try route.extractParameterValues(of: (Int, String, String).self, from: request)
         )
     }
 #endif