Merge pull request #7 from vapor/spring-cleaning

Spring cleaning

Package.swift

@@ -4,11 +4,11 @@ let package = Package(
     name: "Routing",
     targets: [
         // Routing
-        Target(name: "Routing"),
-        Target(name: "HTTPRouting", dependencies: ["Routing"]),
+        Target(name: "Branches"),
+        Target(name: "Routing", dependencies: ["Branches"]),
 
         // Type Safe
-        Target(name: "TypeSafeRouting", dependencies: ["Routing", "HTTPRouting"]),
+        Target(name: "TypeSafeRouting", dependencies: ["Branches", "Routing"]),
         // Target(name: "TypeSafeGenerator"),
     ],
     dependencies: [

Sources/Routing/Router+Routes.swift → Sources/Branches/Branch+Paths.swift

@@ -1,25 +1,3 @@
-//
-//  Router+Routes.swift
-//  Routing
-//
-//  Created by Logan Wright on 11/1/16.
-//
-//
-
-import Foundation
-
-extension Router {
-    public var routes: [String] {
-        var routes = [String]()
-        tree.forEach { host, methodTree in
-            methodTree.forEach { method, branch in
-                let base = "\(host) \(method) "
-                routes += branch.routes.map { base + $0 }
-            }
-        }
-        return routes
-    }
-}
 
 extension Branch {
     public var routes: [String] {

Sources/Routing/Branch.swift → Sources/Branches/Branch.swift

@@ -22,21 +22,6 @@ extension Branch {
     }
 }
 
-/**
-    Branch result is used to encapsulate some metadata when fetching a branch.
- 
-    Less useful now, but will likely play role in chaining in future using remaining iterator.
-*/
-public class BranchResult<Output> {
-    public let branch: Branch<Output>
-    public let remaining: IndexingIterator<[String]>
-
-    init(_ branch: Branch<Output>, _ remaining: IndexingIterator<[String]>) {
-        self.branch = branch
-        self.remaining = remaining
-    }
-}
-
 /**
      When routing requests, different branches will be established,
      in a linked list style stemming from their host and request method.
@@ -115,6 +100,10 @@ public class Branch<Output> { // TODO: Rename Context
         return output != nil
     }
 
+    /// A branch has a singular parent, but multiple children with
+    /// varying levels of priority
+    /// named branches match first, followed by slugs, followed by 
+    /// wildcard
     internal fileprivate(set) var subBranches = SubBranchMap<Output>()
 
     /**
@@ -147,7 +136,7 @@ public class Branch<Output> { // TODO: Rename Context
 
          - returns: a request handler or nil if not supported
     */
-    public func fetch(_ path: [String]) -> BranchResult<Output>? {
+    public func fetch(_ path: [String]) -> Branch? {
         return fetch(path.makeIterator())
     }
 
@@ -160,30 +149,29 @@ public class Branch<Output> { // TODO: Rename Context
 
          - returns: a request handler or nil if not supported
     */
-    public func fetch(_ path: IndexingIterator<[String]>) -> BranchResult<Output>? {
+    public func fetch(_ path: IndexingIterator<[String]>) -> Branch? {
         var comps = path
-        guard let key = comps.next() else { return BranchResult(self, comps) }
+        guard let key = comps.next() else { return self }
 
         // first check if direct path exists
-        if let result = subBranches.paramBranches[key]?.fetch(comps), result.branch.hasValidOutput {
-            return result
+        if let branch = subBranches.paramBranches[key]?.fetch(comps), branch.hasValidOutput {
+            return branch
         }
 
         // next attempt to find slug matches if any exist
         for slug in subBranches.slugBranches {
-            guard let result = slug.fetch(comps), result.branch.hasValidOutput else { continue }
-            return result
+            guard let branch = slug.fetch(comps), branch.hasValidOutput else { continue }
+            return branch
         }
 
         // see if wildcard with path exists
-        if let result = subBranches.wildcard?.fetch(comps), result.branch.hasValidOutput {
-            return result
+        if let branch = subBranches.wildcard?.fetch(comps), branch.hasValidOutput {
+            return branch
         }
 
         // use fallback
         if let wildcard = subBranches.wildcard, wildcard.hasValidOutput {
-            let subRoute = [key] + comps
-            return BranchResult(wildcard, subRoute.makeIterator())
+            return wildcard
         }
 
         // unmatchable route

Sources/Routing/Method+Wildcard.swift

@@ -0,0 +1,7 @@
+import HTTP
+
+extension Method {
+    public static var wildcard: Method {
+        return .other(method: "*")
+    }
+}

Sources/Routing/Request+Routing.swift

@@ -0,0 +1,29 @@
+import Branches
+import HTTP
+import Node
+
+private let parametersKey = "parameters"
+
+extension HTTP.Request {
+    /// when routing a url with slug parameters, ie:
+    /// foo/:id
+    /// the request will populate these values before passing to handeler
+    /// for example:
+    /// given route: /foo/:id
+    /// and request with path `/foo/123`
+    /// parameters will be `["id": 123]`
+    public var parameters: Node {
+        get {
+            if let existing = storage[parametersKey] as? Node {
+                return existing
+            }
+
+            let node = Node([:])
+            storage[parametersKey] = node
+            return node
+        }
+        set {
+            storage[parametersKey] = newValue
+        }
+    }
+}