0001    import Foundation
0002    
0003    public protocol Responder
Response.swift:30
    unowned let responder: Responder
Response.swift:134
    init(request: Request, responder: Responder, socket: Socket) {
SocketServer.swift:108
extension SocketServer: Responder {
: class {
0004        func sendResponse
Response.swift:150
        responder.sendResponse(self)
(response: Response)
0005    }
0006    
0007    public protocol RendererSupplier
Application.swift:248
extension Blackfish: RendererSupplier {
Response.swift:31
    weak var renderSupplier: RendererSupplier?
: class {
0008        func rendererForFile
Response.swift:223
        guard let renderer = self.renderSupplier?.rendererForFile(path) else {
(filename: String) -> Renderer?
0009    }
0010    
0011    /**
0012        Responses are objects responsible for returning
0013        data to the HTTP request such as the body, status
0014        code and headers.
0015     */
0016    public class Response
Application.swift:37
    func dispatch(request request: Request, response: Response, handlers: [Handler]?) {
Application.swift:44
    func handleMiddleware(handlers: [Handler], request: Request, response: Response) {
Application.swift:74
                      parameters: [String: String], request: Request, response: Response) {
Application.swift:111
    func handleRoutes(routes: [Handler], request: Request, response: Response) {
Application.swift:132
                                        withResponse response: Response) {
Application.swift:167
    public func param(param: String, handler: (request: Request, response: Response, param: String, next: () -> ()) -> ()) {
Application.swift:191
                    response: Response, next: () -> ()) -> ()) {
Application.swift:196
                    middleware: (request: Request, response: Response, 
Application.swift:202
        middleware: (request: Request, response: Response, 
BodyParser.swift:5
    func handle(request: Request, response: Response, next: () -> ()) {
HandlerManager.swift:6
    func handle(request request: Request, response: Response, next: (() -> ()))
Logger.swift:41
    public func handle(request: Request, response: Response, next: () -> ()) {
Middleware.swift:4
    func handle(request: Request, response: Response, next: (() -> ())) -> Void
Middleware.swift:21
    func handle(request request: Request, response: Response, next: (() -> ())) {
Middleware.swift:29
    let handler: (request: Request, response: Response, next: () -> ()) -> ()
Middleware.swift:32
        response: Response, next: () -> ()) -> ()) {
Middleware.swift:41
    func handle(request request: Request, response: Response, next: () -> ()) {
Multiparser.swift:42
    public func handle(request: Request, response: Response, next: (() -> ())) {
ParameterManager.swift:5
    typealias Handler = (request: Request, response: Response, param: String, next: () -> ()) -> ();
Response.swift:4
    func sendResponse(response: Response)
Response.swift:146
extension Response {
Response.swift:245
func ==(left: Response, right: Response) -> Bool {
Response.swift:245
func ==(left: Response, right: Response) -> Bool {
Route.swift:5
    public typealias Handler = ((request: Request, response: Response) -> Void)
Route.swift:71
    func handle(request request: Request, response: Response, next: (() -> ())) {
Session.swift:34
	public static func close(request request: Request, response: Response) {
SocketServer.swift:12
                                        withResponse response: Response)
SocketServer.swift:79
                let response = Response(request: request, responder: self, 
SocketServer.swift:109
    public func sendResponse(response: Response) {
StaticFileMiddleware.swift:4
    func handle(request: Request, response: Response, next: (() -> ())) {
 {
0017    
0018        public enum SerializationError: ErrorType {
0019            case InvalidObject
0020            case NotSupported
0021        }
0022    
0023        public var contentType
Response.swift:118
        switch self.contentType {
Response.swift:137
        self.contentType = .Text
Response.swift:156
        contentType = .Text
Response.swift:165
        contentType = .JSON
Response.swift:174
        contentType = .HTML
Response.swift:210
        contentType = .JSON
Response.swift:225
            contentType = .Text
Response.swift:233
            contentType = .HTML
Response.swift:237
            contentType = .Text
StaticFileMiddleware.swift:19
                response.contentType = .Text
: ContentType
0024        public var status
Application.swift:104
                    response.status = .NotFound
Response.swift:71
        switch self.status {
Response.swift:136
        self.status = .OK
Response.swift:157
        status = .OK
Response.swift:166
        status = .Error
Response.swift:175
        status = .OK
Response.swift:180
        status = .MovedPermanently
Response.swift:211
        status = .OK
Response.swift:224
            status = .Error
Response.swift:234
            status = .OK
Response.swift:236
            status = .Error
Response.swift:246
    return left.status.code == right.status.code
Response.swift:246
    return left.status.code == right.status.code
SocketServer.swift:118
            try socket.writeString("HTTP/1.1 \(response.status.code) \(response.reasonPhrase)\r\n")
StaticFileMiddleware.swift:17
                response.status = .OK
: Status
0025        public var body
Response.swift:138
        self.body = []
Response.swift:155
        body = [UInt8](text.utf8)
Response.swift:164
        body = [UInt8](text.utf8)
Response.swift:173
        body = [UInt8](serialised.utf8)
Response.swift:212
        body = data
Response.swift:226
            body = [UInt8]("No renderer for this view type of \(path)".utf8)
Response.swift:232
            body = try renderer.renderToBytes(path, data: data)
Response.swift:238
            body = [UInt8]("An error occured: \(errorMessage)".utf8)
SocketServer.swift:122
            if response.body.count >= 0 {
SocketServer.swift:123
                headers["Content-Length"] = "\(response.body.count)"
SocketServer.swift:126
            if true && response.body.count != -1 {
StaticFileMiddleware.swift:18
                response.body = array
: [UInt8]
0026        public var cookies
Response.swift:106
        if self.cookies.count > 0 {
Response.swift:108
            for (key, value) in self.cookies {
Session.swift:36
			response.cookies["blackfish-session"] = key
: [String: String] = [:]
0027        public var additionalHeaders
Response.swift:127
        for (key, value) in additionalHeaders {
Response.swift:181
        additionalHeaders["Location"] = path
: [String: String] = [:]
0028    
0029        unowned let request
Response.swift:135
        self.request = request
: Request
0030        unowned let responder
Response.swift:139
        self.responder = responder
Response.swift:150
        responder.sendResponse(self)
: Responder
0031        weak var renderSupplier
Application.swift:38
        response.renderSupplier = self
Response.swift:223
        guard let renderer = self.renderSupplier?.rendererForFile(path) else {
: RendererSupplier?
0032    
0033        let socket
Response.swift:140
        self.socket = socket
SocketServer.swift:111
        let socket = response.socket
: Socket
0034    
0035        public enum ContentType
Response.swift:23
    public var contentType: ContentType
 {
0036            case Text
Response.swift:137
        self.contentType = .Text
Response.swift:156
        contentType = .Text
Response.swift:225
            contentType = .Text
Response.swift:237
            contentType = .Text
StaticFileMiddleware.swift:19
                response.contentType = .Text
, HTML
Response.swift:121
        case .HTML:
Response.swift:174
        contentType = .HTML
Response.swift:233
            contentType = .HTML
, JSON
Response.swift:119
        case .JSON:
Response.swift:165
        contentType = .JSON
Response.swift:210
        contentType = .JSON
, None
0037        }
0038    
0039        public enum Status
Response.swift:24
    public var status: Status
 {
0040            case OK
Response.swift:49
                case .OK: return 200
Response.swift:72
        case .OK:
Response.swift:136
        self.status = .OK
Response.swift:157
        status = .OK
Response.swift:175
        status = .OK
Response.swift:211
        status = .OK
Response.swift:234
            status = .OK
StaticFileMiddleware.swift:17
                response.status = .OK
, Created
Response.swift:50
                case .Created: return 201
Response.swift:74
        case .Created:
, Accepted
Response.swift:51
                case .Accepted: return 202
Response.swift:76
        case .Accepted:
, NoContent
Response.swift:52
                case .NoContent: return 204
Response.swift:78
        case .NoContent:

0041            case MovedPermanently
Response.swift:54
                case .MovedPermanently: return 301
Response.swift:81
        case .MovedPermanently:
Response.swift:180
        status = .MovedPermanently

0042            case BadRequest
Response.swift:56
                case .BadRequest: return 400
Response.swift:84
        case .BadRequest:
, Unauthorized
Response.swift:57
                case .Unauthorized: return 401
Response.swift:86
        case .Unauthorized:
, Forbidden
Response.swift:58
                case .Forbidden: return 403
Response.swift:88
        case .Forbidden:
, NotFound
Application.swift:104
                    response.status = .NotFound
Response.swift:59
                case .NotFound: return 404
Response.swift:90
        case .NotFound:

0043            case Error
Response.swift:61
                case .Error: return 500
Response.swift:93
        case .Error:
Response.swift:166
        status = .Error
Response.swift:224
            status = .Error
Response.swift:236
            status = .Error

0044            case Unknown
Response.swift:63
                case .Unknown: return 0
Response.swift:96
        case .Unknown:

0045            case Custom
Response.swift:64
                case .Custom(let code):
Response.swift:98
        case .Custom:
(Int)
0046    
0047            public var code
Response.swift:246
    return left.status.code == right.status.code
Response.swift:246
    return left.status.code == right.status.code
SocketServer.swift:118
            try socket.writeString("HTTP/1.1 \(response.status.code) \(response.reasonPhrase)\r\n")
: Int {
0048                switch self {
0049                    case .OK: return 200
0050                    case .Created: return 201
0051                    case .Accepted: return 202
0052                    case .NoContent: return 204
0053    
0054                    case .MovedPermanently: return 301
0055    
0056                    case .BadRequest: return 400
0057                    case .Unauthorized: return 401
0058                    case .Forbidden: return 403
0059                    case .NotFound: return 404
0060    
0061                    case .Error: return 500
0062    
0063                    case .Unknown: return 0
0064                    case .Custom(let code):
0065                        return code
0066                }
0067            }
0068        }
0069    
0070        var reasonPhrase
SocketServer.swift:118
            try socket.writeString("HTTP/1.1 \(response.status.code) \(response.reasonPhrase)\r\n")
: String {
0071            switch self.status {
0072            case .OK:
0073                return "OK"
0074            case .Created:
0075                return "Created"
0076            case .Accepted:
0077                return "Accepted"
0078            case .NoContent:
0079                return "No Content"
0080    
0081            case .MovedPermanently:
0082                return "Moved Permanently"
0083    
0084            case .BadRequest:
0085                return "Bad Request"
0086            case .Unauthorized:
0087                return "Unauthorized"
0088            case .Forbidden:
0089                return "Forbidden"
0090            case .NotFound:
0091                return "Not Found"
0092    
0093            case .Error:
0094                return "Internal Server Error"
0095    
0096            case .Unknown:
0097                return "Unknown"
0098            case .Custom:
0099                return "Custom"
0100            }
0101        }
0102    
0103        func headers
SocketServer.swift:120
            var headers = response.headers()
() -> [String: String] {
0104            var headers = ["Server" : "Blackfish \(Blackfish.VERSION)"]
0105    
0106            if self.cookies.count > 0 {
0107                var cookieString = ""
0108                for (key, value) in self.cookies {
0109                    if cookieString != "" {
0110                        cookieString += ";"
0111                    }
0112    
0113                    cookieString += "\(key)=\(value)"
0114                }
0115                headers["Set-Cookie"] = cookieString
0116            }
0117    
0118            switch self.contentType {
0119            case .JSON:
0120                headers["Content-Type"] = "application/json"
0121            case .HTML:
0122                headers["Content-Type"] = "text/html"
0123            default:
0124                break
0125            }
0126    
0127            for (key, value) in additionalHeaders {
0128                headers[key] = value
0129            }
0130    
0131            return headers
0132        }
0133    
0134        init
SocketServer.swift:79
                let response = Response(request: request, responder: self, 
(request: Request, responder: Responder, socket: Socket) {
0135            self.request = request
0136            self.status = .OK
0137            self.contentType = .Text
0138            self.body = []
0139            self.responder = responder
0140            self.socket = socket
0141        }
0142    }
0143    
0144    // MARK: - Public Methods
0145    
0146    extension Response {
0147    
0148        public func send
Response.swift:158
        send()
Response.swift:167
        send()
Response.swift:176
        send()
Response.swift:182
        send()
Response.swift:214
        self.send()
Response.swift:227
            send()
Response.swift:241
        send()
StaticFileMiddleware.swift:20
                response.send()
() {
0149    
0150            responder.sendResponse(self)
0151        }
0152    
0153        public func send
Application.swift:105
                    response.send(text: "Page not found")
(text text: String) {
0154    
0155            body = [UInt8](text.utf8)
0156            contentType = .Text
0157            status = .OK
0158            send()
0159        }
0160    
0161        public func send
Response.swift:196
                self.send(error: "Server error: \(errorMessage)")
Response.swift:200
                self.send(error: "Server error: Invalid JSON")
(error error: String) {
0162    
0163            let text = "{\n\t\"error\": true,\n\t\"message\":\"\(error)\"\n}"
0164            body = [UInt8](text.utf8)
0165            contentType = .JSON
0166            status = .Error
0167            send()
0168        }
0169    
0170        public func send(html html: String) {
0171    
0172            let serialised = "<html><meta charset=\"UTF-8\"><body>\(html)</body></html>"
0173            body = [UInt8](serialised.utf8)
0174            contentType = .HTML
0175            status = .OK
0176            send()
0177        }
0178    
0179        public func redirect(path: String) {
0180            status = .MovedPermanently
0181            additionalHeaders["Location"] = path
0182            send()
0183        }
0184    
0185        public func send(json json: Any) {
0186    
0187            let data: [UInt8]
0188    
0189            if let json = json as? AnyObject {
0190                if NSJSONSerialization.isValidJSONObject(json) {
0191    
0192                do {
0193                    let json = try NSJSONSerialization.dataWithJSONObject(json, options: NSJSONWritingOptions.PrettyPrinted)
0194                    data = Array(UnsafeBufferPointer(start: UnsafePointer<UInt8>(json.bytes), count: json.length))
0195                } catch let errorMessage {
0196                    self.send(error: "Server error: \(errorMessage)")
0197                    return
0198                }
0199                } else {
0200                    self.send(error: "Server error: Invalid JSON")
0201                    return
0202                }
0203            } else {
0204                //fall back to manual serializer
0205                let string = JSONSerializer.serialize(json)
0206                data = [UInt8](string.utf8)
0207            }
0208    
0209    
0210            contentType = .JSON
0211            status = .OK
0212            body = data
0213    
0214            self.send()
0215        }
0216    
0217        public func render(path: String) {
0218            render(path, data: nil)
0219        }
0220    
0221        public func render
Response.swift:218
        render(path, data: nil)
(path: String, data: [String: Any]?) {
0222    
0223            guard let renderer = self.renderSupplier?.rendererForFile(path) else {
0224                status = .Error
0225                contentType = .Text
0226                body = [UInt8]("No renderer for this view type of \(path)".utf8)
0227                send()
0228                return
0229            }
0230    
0231            do {
0232                body = try renderer.renderToBytes(path, data: data)
0233                contentType = .HTML
0234                status = .OK
0235            } catch let errorMessage {
0236                status = .Error
0237                contentType = .Text
0238                body = [UInt8]("An error occured: \(errorMessage)".utf8)
0239            }
0240    
0241            send()
0242        }
0243    }
0244    
0245    func ==(left: Response, right: Response) -> Bool {
0246        return left.status.code == right.status.code
0247    }
0248