type safe routing

README.md

@@ -51,7 +51,7 @@ If you are having trouble connecting, make sure your ports are open. Check out `
 
 ## Routing
 
-Routing in Vapor is simple and very similar to Laravel.
+Routing in Vapor is simple and expressive.
 
 `main.swift`
 ```swift
@@ -60,27 +60,49 @@ app.get("welcome") { request in
 }
 ```
 
-Here we will respond to all HTTP GET requests to `http://example.com/welcome` with the string `"Hello"`.
+Here we will respond to all GET requests to `http://example.com/welcome` with the string `"Hello"`.
 
 ### JSON
 
 Responding with JSON is easy.
 
 ```swift
 app.get("version") { request in
-	return ["version": "1.0"]
+	return Json(["version": "1.0"])
 }
 ```
 
-This responds to all HTTP GET requests to `http://example.com/version` with the JSON dictionary `{"version": "1.0"}` and `Content-Type: application/json`.
+This responds to all GET requests to `http://example.com/version` with the JSON dictionary `{"version": "1.0"}` and `Content-Type: application/json`.
+
+### Type Safe Routing
+
+Vapor supports [Frank](https://github.com/nestproject/Frank) inspired type-safe routing.
+
+```swift
+app.get("users", Int, "posts", String, "comments") { request, userId, postName in 
+    return "You requested the comments for user #\(userId)'s post named \(postName))"
+}
+```
+
+Here we will respond to all GET requests to `http://example.com/users/<userId>/posts/<postName>/comments`
+
+You can also extend your own types to conform to Vapor's `StringInitializable` protocol. Here is an example where the `User` class conforms.
+
+```swift
+app.get("users", User) { request, user in
+    return "Hello \(user.name)"
+}
+```
+
+Now requesting a `User` is expressive and concise.
 
 ### Views
 
 You can also respond with HTML pages.
 
 ```swift
 app.get("/") { request in
-	return View(path: "index.html")
+	return try View(path: "index.html")
 }
 ```
 

Sources/Generator/main.swift

@@ -0,0 +1,232 @@
+//
+//  main.swift
+//  Vapor
+//
+//  Created by Tanner Nelson on 3/13/16.
+//  Copyright © 2016 Tanner Nelson. All rights reserved.
+//
+
+import Foundation
+
+let GENERIC_MAP = ["T", "U", "V", "W", "X"]
+let MAX_PARAMS = GENERIC_MAP.count
+
+struct Func: CustomStringConvertible {
+    enum Method {
+        case Get, Post, Put, Patch, Delete, Options
+    }
+
+    var method: Method
+    var params: [Param]
+
+    var description: String {
+
+
+
+        let wildcards = params.filter { param in
+            return param.type == .Wildcard
+        }
+
+
+        var f = ""
+        f += "\tpublic func "
+        f += "\(method)".lowercaseString
+
+        //generic <>
+        if wildcards.count > 0 {
+            let genericsString = wildcards.map { wildcard in
+                return "\(wildcard.generic): StringInitializable"
+            }.joinWithSeparator(", ")
+
+            f += "<\(genericsString)>"
+        }
+
+        let paramsString = params.enumerate().map { (index, param) in
+            if index > 0 {
+                return "_ \(param)"
+            } else {
+                return param.description
+            }
+        }.joinWithSeparator(", ")
+
+        f += "(\(paramsString), handler: (Request"
+
+        //handler params
+        if wildcards.count > 0 {
+            let genericsString = wildcards.map { wildcard in
+                return wildcard.generic
+            }.joinWithSeparator(", ")
+
+            f += ", \(genericsString)) throws -> ResponseConvertible) {\n"
+
+        } else {
+            f += ") throws -> ResponseConvertible) {\n"
+        }
+
+        let pathString = params.map { param in
+            if param.type == .Wildcard {
+                return ":\(param.name)"
+            }
+
+            return "\\(\(param.name))"
+        }.joinWithSeparator("/")
+
+        f += "\t\tself.add(.\(method), path: \"\(pathString)\") { request in\n"
+
+        //function body
+        if wildcards.count > 0 {
+            //grab from request params
+            for wildcard in wildcards {
+                f += "\t\t\tguard let v\(wildcard.name) = request.parameters[\"\(wildcard.name)\"] else {\n"
+                f += "\t\t\t\tthrow Abort.BadRequest\n"
+                f += "\t\t\t}\n"
+            }
+
+            f += "\n"
+
+            //try
+            for wildcard in wildcards {
+                f += "\t\t\tlet e\(wildcard.name) = try \(wildcard.generic)(from: v\(wildcard.name))\n"
+            }
+
+            f += "\n"
+
+            //ensure conversion worked
+            for wildcard in wildcards {
+                f += "\t\t\tguard let c\(wildcard.name) = e\(wildcard.name) else {\n"
+                f += "\t\t\t\tthrow Abort.BadRequest\n"
+                f += "\t\t\t}\n"
+            }
+
+            f += "\n"
+
+
+            let wildcardString = wildcards.map { wildcard in
+                return "c\(wildcard.name)"
+                }.joinWithSeparator(", ")
+
+
+            f += "\t\t\treturn try handler(request, \(wildcardString))\n"
+
+        } else {
+
+            f += "\t\t\treturn try handler(request)\n"
+        }
+
+        f += "\t\t}\n"
+
+        f += "\t}"
+        return f
+    }
+}
+
+func paramTypeCount(type: Param.`Type`, params: [Param]) -> Int {
+    var i = 0
+
+    for param in params {
+        if param.type == type {
+            i += 1
+        }
+    }
+
+    return i
+}
+
+struct Param: CustomStringConvertible {
+    var name: String
+    var type: Type
+    var generic: String
+
+    var description: String {
+        var description = "\(name): "
+        if type == .Wildcard {
+            description += "\(generic).Type"
+        } else {
+            description += "String"
+        }
+        return description
+    }
+
+    enum `Type` {
+        case Path, Wildcard
+    }
+    static var types: [Type] = [.Path, .Wildcard]
+
+    static func addTypePermutations(toArray paramsArray: [[Param]]) -> [[Param]] {
+        var permParamsArray: [[Param]] = []
+
+        for paramArray in paramsArray {
+            for type in Param.types {
+                var mutableParamArray = paramArray
+
+                var name = ""
+                if type == .Wildcard {
+                    name = "w"
+                } else {
+                    name = "p"
+                }
+
+                let count = paramTypeCount(type, params: paramArray)
+                name += "\(count)"
+
+                let generic = GENERIC_MAP[count]
+
+                let param = Param(name: name, type: type, generic: generic)
+
+                mutableParamArray.append(param)
+                permParamsArray.append(mutableParamArray)
+            }
+        }
+
+        return permParamsArray
+    }
+}
+
+
+
+
+var paramPermutations: [[Param]] = []
+
+for paramCount in 0...MAX_PARAMS {
+    var perms: [[Param]] = [[]]
+    for _ in 0..<paramCount {
+        perms = Param.addTypePermutations(toArray: perms)
+    }
+
+    paramPermutations += perms
+}
+
+var generated = "// *** GENERATED CODE ***\n"
+generated += "// \(NSDate())\n"
+generated += "//\n"
+generated += "// DO NOT EDIT THIS FILE OR CHANGES WILL BE OVERWRITTEN\n\n"
+generated += "extension Application {\n\n"
+
+for method: Func.Method in [.Get, .Post, .Put, .Patch, .Delete, .Options] {
+    for params in paramPermutations {
+        guard params.count > 0 else {
+            continue
+        }
+
+        var f = Func(method: method, params: params)
+        generated += "\(f)\n\n"
+    }
+}
+
+generated += "}\n"
+
+if Process.arguments.count < 2 {
+    fatalError("Please pass $SRCROOT as a parameter")
+}
+
+let path = Process.arguments[1].stringByReplacingOccurrencesOfString("XcodeProject", withString: "")
+let url = NSURL(fileURLWithPath: path + "/Sources/Vapor/Core/Generated.swift")
+
+do{
+    // writing to disk
+    try generated.writeToURL(url, atomically: true, encoding: NSUTF8StringEncoding)
+    print("File created at \(url)")
+} catch let error as NSError {
+    print("Error writing generated file at \(url)")
+    print(error.localizedDescription)
+}