0001    
import Foundation
0002    
0003    final public class Blackfish
Application.swift:129
extension Blackfish: SocketServerDelegate {
Application.swift:139
extension Blackfish {
Application.swift:174
extension Blackfish: Routing {
Application.swift:248
extension Blackfish: RendererSupplier {
Response.swift:104
        var headers = ["Server" : "Blackfish \(Blackfish.VERSION)"]
 {
0004    
0005        public static let VERSION
Response.swift:104
        var headers = ["Server" : "Blackfish \(Blackfish.VERSION)"]
 = "0.1.3"
0006    
0007        private let middlewareManager
Application.swift:25
        middlewareManager = HandlerManager<MiddlewareHandler>(allowsMultiplesPerPath: true)
Application.swift:39
        let handlers = middlewareManager.route(request)
Application.swift:206
        middlewareManager.register(handler)
Application.swift:217
        middlewareManager.register(middlewareHandler)
: HandlerManager<MiddlewareHandler>
0008    
0009        private let routeManager
Application.swift:26
        routeManager = HandlerManager<Route>(allowsMultiplesPerPath: false)
Application.swift:56
            let params = routeManager.paramsForPath(request.method.rawValue, path: request.path)
Application.swift:101
                if let result = routeManager.routeSingle(request) {
Application.swift:124
            self.routeManager.register(route.method.rawValue, handler: route)
: HandlerManager<Route>
0010    
0011        private var renderers
Application.swift:27
        renderers = [:]
Application.swift:31
        renderers[".html"] = HTMLRenderer()
Application.swift:181
        renderers[ext] = renderer
Application.swift:251
        for (key, value) in renderers {
: [String: Renderer]
0012        
0013        private let server
Application.swift:29
        server = SocketServer()
Application.swift:34
        server.delegate = self
Application.swift:158
            try server.start(port)
Application.swift:161
            server.loop()
: SocketServer
0014        
0015        private let parameterManager
Application.swift:30
        parameterManager = ParameterManager()
Application.swift:68
            let paramHandlers = parameterManager.handlersForParams(params)
Application.swift:168
        parameterManager.addHandler(handler, forParam: param)
: ParameterManager
0016    
0017        public var port: Int {
0018            return runningPort
0019        }
0020    
0021        private var runningPort
Application.swift:19
        return runningPort
Application.swift:28
        runningPort = 3000
Application.swift:159
            runningPort = port
: Int
0022    
0023        public init() {
0024            middlewareManager = HandlerManager<MiddlewareHandler>(allowsMultiplesPerPath: true)
0025            routeManager = HandlerManager<Route>(allowsMultiplesPerPath: false)
0026            renderers = [:]
0027            runningPort = 3000
0028            server = SocketServer()
0029            parameterManager = ParameterManager()
0030            renderers[".html"] = HTMLRenderer()
0031            use(middleware: StaticFileMiddleware())
0032            use(middleware: JSONParser())
0033            server.delegate = self
0034        }
0035        
0036        func dispatch
Application.swift:133
        self.dispatch(request: request, response: response, handlers: nil)
(request request: Request, response: Response, handlers: [Handler]?) {
0037            response.renderSupplier = self
0038            let handlers = middlewareManager.route(request)
0039            handleMiddleware(handlers, request: request, response: response)
0040    
0041        }
0042        
0043        func handleMiddleware
Application.swift:40
        handleMiddleware(handlers, request: request, response: response)
Application.swift:51
                self.handleMiddleware(handlers, request: request, response: response)
(handlers: [Handler], request: Request, response: Response) {
0044            
0045            var handlers = handlers
0046            
0047            if let handler = handlers.popLast() {
0048                
0049                handler.handle(request: request, response: response) {
0050                    self.handleMiddleware(handlers, request: request, response: response)
0051                }
0052                
0053            } else {
0054                
0055                let params = routeManager.paramsForPath(request.method.rawValue, path: request.path)
0056                
0057                var parameters = [String: String]()
0058                
0059                for (key, value) in params {
0060                    var k = key
0061                    if k.hasPrefix(":") {
0062                        k.removeAtIndex(k.startIndex)
0063                    }
0064                    parameters[k] = value
0065                }
0066                
0067                let paramHandlers = parameterManager.handlersForParams(params)
0068                handleParams(paramHandlers, parameters: parameters, request: request, response: response)
0069            }
0070        }
0071        
0072        func handleParams
Application.swift:69
            handleParams(paramHandlers, parameters: parameters, request: request, response: response)
Application.swift:91
                self.handleParams(handlers, parameters: parameters,
Application.swift:98
                handleParams(handlers, parameters: parameters,
(handlers: [String: [ParameterManager.Handler]],
0073                          parameters: [String: String], request: Request, response: Response) {
0074            
0075            var handlers = handlers
0076            var parameters = parameters
0077            
0078            if let param = parameters.first, let keyHandlers = handlers[param.0] where keyHandlers.count > 0 {
0079                
0080                let key = param.0
0081                let value = param.1
0082                
0083                var kHandlers = keyHandlers
0084                
0085                let handler = kHandlers.removeFirst()
0086                
0087                handlers[key] = kHandlers;
0088                
0089                handler(request: request, response: response, param: value) {
0090                    self.handleParams(handlers, parameters: parameters,
0091                                      request: request, response: response)
0092                }
0093            } else {
0094                parameters.popFirst()
0095                
0096                if parameters.count > 0 {
0097                    handleParams(handlers, parameters: parameters,
0098                                 request: request, response: response)
0099                } else {
0100                    if let result = routeManager.routeSingle(request) {
0101                        handleRoutes([result], request: request, response: response)
0102                    } else {
0103                        response.status = .NotFound
0104                        response.send(text: "Page not found")
0105                    }
0106                }
0107            }
0108        }
0109        
0110        func handleRoutes
Application.swift:102
                    handleRoutes([result], request: request, response: response)
Application.swift:115
                self.handleRoutes(routes, request: request, response: response)
(routes: [Handler], request: Request, response: Response) {
0111            var routes = routes
0112            if let route = routes.popLast() {
0113                route.handle(request: request, response: response) {
0114                    self.handleRoutes(routes, request: request, response: response)
0115                }
0116            }
0117        }
0118    
0119        func parseRoutes
Application.swift:143
        parseRoutes()
() {
0120    
0121            for route in Route.routes {
0122                
0123                self.routeManager.register(route.method.rawValue, handler: route)
0124            }
0125        }
0126    }
0127    
0128    extension Blackfish: SocketServerDelegate {
0129        func socketServer(socketServer: SocketServer,
0130                          didRecieveRequest request: Request,
0131                                            withResponse response: Response) {
0132            self.dispatch(request: request, response: response, handlers: nil)
0133        }
0134    }
0135    
0136    // MARK: - Public Methods
0137    
0138    extension Blackfish {
0139    
0140        public func listen(port inPort: Int = 80, handler: ((error: ErrorType?) -> ())? = nil) {
0141    
0142            parseRoutes()
0143    
0144            var port = inPort
0145    
0146            if Process.arguments.count >= 2 {
0147                let secondArg = Process.arguments[1]
0148                if secondArg.hasPrefix("--port=") {
0149                    let portString = secondArg.split("=")[1]
0150                    if let portInt = Int(portString) {
0151                        port = portInt
0152                    }
0153                }
0154            }
0155    
0156            do {
0157                try server.start(port)
0158                runningPort = port
0159                handler?(error: nil)
0160                server.loop()
0161            } catch {
0162                handler?(error: error)
0163            }
0164        }
0165        
0166        public func param(param: String, handler: (request: Request, response: Response, param: String, next: () -> ()) -> ()) {
0167            parameterManager.addHandler(handler, forParam: param)
0168        }
0169    }
0170    
0171    // MARK: - Routing
0172    
0173    extension Blackfish: Routing {
0174    
0175        public func use(path path: String, router: Router) {
0176            Route.createRoutesFromRouter(router, withPath: path)
0177        }
0178        
0179        public func use(renderer renderer: Renderer, ext: String) {
0180            renderers[ext] = renderer
0181        }
0182        
0183        public func use(path path: String, controller: Controller) {
0184            let router = Router()
0185            controller.routes(router)
0186            Route.createRoutesFromRouter(router, withPath: path)
0187        }
0188    
0189        public func use(middleware middleware: (request: Request, 
0190                        response: Response, next: () -> ()) -> ()) {
0191            self.use(path: "/", middleware: middleware)
0192        }
0193    
0194        public func use(path: String,
0195                        middleware: (request: Request, response: Response, 
0196                                     next: () -> ()) -> ()) {
0197            self.use(path: path, middleware: middleware)
0198        }
0199    
0200        public func use
Application.swift:192
        self.use(path: "/", middleware: middleware)
Application.swift:198
        self.use(path: path, middleware: middleware)
(path path: String, 
0201            middleware: (request: Request, response: Response, 
0202                         next: () -> ()) -> ()) {
0203            let handler = MiddlewareClosureHandler(path: path, 
0204                                                   handler: middleware)
0205            middlewareManager.register(handler)
0206    
0207        }
0208        
0209        public func use
Application.swift:32
        use(middleware: StaticFileMiddleware())
Application.swift:33
        use(middleware: JSONParser())
(middleware middleware: Middleware) {
0210            use(path: "/", middleware: middleware)
0211        }
0212        
0213        public func use
Application.swift:211
        use(path: "/", middleware: middleware)
(path path: String, middleware: Middleware) {
0214            let middlewareHandler = MiddlewareHandler(middleware: middleware,
0215                                                      path: path)
0216            middlewareManager.register(middlewareHandler)
0217        }
0218    
0219        public func get(path: String, handler: Route.Handler) {
0220            Route.get(path, handler: handler)
0221        }
0222    
0223        public func put(path: String, handler: Route.Handler) {
0224            Route.put(path, handler: handler)
0225        }
0226    
0227        public func delete(path: String, handler: Route.Handler) {
0228            Route.delete(path, handler: handler)
0229        }
0230    
0231        public func post(path: String, handler: Route.Handler) {
0232            Route.post(path, handler: handler)
0233        }
0234    
0235        public func patch(path: String, handler: Route.Handler) {
0236            Route.patch(path, handler: handler)
0237        }
0238    
0239        public func all(path: String, handler: Route.Handler) {
0240            Route.all(path, handler: handler)
0241        }
0242    
0243    }
0244    
0245    // MARK: - RendererSupplier
0246    
0247    extension Blackfish: RendererSupplier {
0248        public func rendererForFile(filename: String) -> Renderer? {
0249    
0250            for (key, value) in renderers {
0251                if filename.hasSuffix(key) {
0252                    return value
0253                }
0254            }
0255    
0256            return nil
0257        }
0258    }
0259