enum first letter lowercase

fix compile issue in SocketFile
import Swifter in test class
set open instead of public some class for tests

Sources/DemoServer.swift

@@ -34,7 +34,7 @@ public func demoServer(_ publicDir: String) -> HttpServer {
         }
     }
     
-    server["/magic"] = { .OK(.Html("You asked for " + $0.path)) }
+    server["/magic"] = { .ok(.html("You asked for " + $0.path)) }
     
     server["/test/:param1/:param2"] = { r in
         scopes {
@@ -101,7 +101,7 @@ public func demoServer(_ publicDir: String) -> HttpServer {
         for multipart in r.parseMultiPartFormData() {
             response += "Name: \(multipart.name) File name: \(multipart.fileName) Size: \(multipart.body.count)<br>"
         }
-        return HttpResponse.OK(.Html(response))
+        return HttpResponse.ok(.html(response))
     }
     
     server.GET["/login"] = scopes {
@@ -139,7 +139,7 @@ public func demoServer(_ publicDir: String) -> HttpServer {
     
     server.POST["/login"] = { r in
         let formFields = r.parseUrlencodedForm()
-        return HttpResponse.OK(.Html(formFields.map({ "\($0.0) = \($0.1)" }).joined(separator: "<br>")))
+        return HttpResponse.ok(.html(formFields.map({ "\($0.0) = \($0.1)" }).joined(separator: "<br>")))
     }
     
     server["/demo"] = scopes {
@@ -154,25 +154,25 @@ public func demoServer(_ publicDir: String) -> HttpServer {
     }
     
     server["/raw"] = { r in
-        return HttpResponse.RAW(200, "OK", ["XXX-Custom-Header": "value"], { try $0.write([UInt8]("test".utf8)) })
+        return HttpResponse.raw(200, "OK", ["XXX-Custom-Header": "value"], { try $0.write([UInt8]("test".utf8)) })
     }
     
     server["/redirect"] = { r in
-        return .MovedPermanently("http://www.google.com")
+        return .movedPermanently("http://www.google.com")
     }
 
     server["/long"] = { r in
         var longResponse = ""
         for k in 0..<1000 { longResponse += "(\(k)),->" }
-        return .OK(.Html(longResponse))
+        return .ok(.html(longResponse))
     }
     
     server["/wildcard/*/test/*/:param"] = { r in
-        return .OK(.Html(r.path))
+        return .ok(.html(r.path))
     }
     
     server["/stream"] = { r in
-        return HttpResponse.RAW(200, "OK", nil, { w in
+        return HttpResponse.raw(200, "OK", nil, { w in
             for i in 0...100 {
                 try w.write([UInt8]("[chunk \(i)]".utf8))
             }
@@ -186,7 +186,7 @@ public func demoServer(_ publicDir: String) -> HttpServer {
     })
     
     server.notFoundHandler = { r in
-        return .MovedPermanently("https://github.com/404")
+        return .movedPermanently("https://github.com/404")
     }
     
     server.middleware.append { r in

Sources/File.swift

@@ -12,13 +12,13 @@
 #endif
 
 public enum FileError: Error {
-    case OpenFailed(String)
-    case WriteFailed(String)
-    case ReadFailed(String)
-    case SeekFailed(String)
-    case GetCurrentWorkingDirectoryFailed(String)
-    case IsDirectoryFailed(String)
-    case OpenDirFailed(String)
+    case openFailed(String)
+    case writeFailed(String)
+    case readFailed(String)
+    case seekFailed(String)
+    case getCurrentWorkingDirectoryFailed(String)
+    case isDirectoryFailed(String)
+    case openDirFailed(String)
 }
 
 public class File {
@@ -37,7 +37,7 @@ public class File {
     
     public static func openFileForMode(_ path: String, _ mode: String) throws -> File {
         guard let file = path.withCString({ pathPointer in mode.withCString({ fopen(pathPointer, $0) }) }) else {
-            throw FileError.OpenFailed(Errno.description())
+            throw FileError.openFailed(Errno.description())
         }
         return File(file)
     }
@@ -45,14 +45,14 @@ public class File {
     public static func isDirectory(_ path: String) throws -> Bool {
         var s = stat()
         guard path.withCString({ stat($0, &s) }) == 0 else {
-            throw FileError.IsDirectoryFailed(Errno.description())
+            throw FileError.isDirectoryFailed(Errno.description())
         }
         return s.st_mode & S_IFMT == S_IFDIR
     }
     
     public static func currentWorkingDirectory() throws -> String {
         guard let path = getcwd(nil, 0) else {
-            throw FileError.GetCurrentWorkingDirectoryFailed(Errno.description())
+            throw FileError.getCurrentWorkingDirectoryFailed(Errno.description())
         }
         return String(cString: path)
     }
@@ -64,7 +64,7 @@ public class File {
     
     public static func list(_ path: String) throws -> [String] {
         guard let dir = path.withCString({ opendir($0) }) else {
-            throw FileError.OpenDirFailed(Errno.description())
+            throw FileError.openDirFailed(Errno.description())
         }
         defer { closedir(dir) }
         var results = [String]()
@@ -108,9 +108,9 @@ public class File {
             return count
         }
         if ferror(self.pointer) != 0 {
-            throw FileError.ReadFailed(Errno.description())
+            throw FileError.readFailed(Errno.description())
         }
-        throw FileError.ReadFailed("Unknown file read error occured.")
+        throw FileError.readFailed("Unknown file read error occured.")
     }
 
     public func write(data: [UInt8]) throws -> Void {
@@ -119,14 +119,14 @@ public class File {
         }
         try data.withUnsafeBufferPointer {
             if fwrite($0.baseAddress, 1, data.count, self.pointer) != data.count {
-                throw FileError.WriteFailed(Errno.description())
+                throw FileError.writeFailed(Errno.description())
             }
         }
     }
     
     public func seek(offset: Int) throws -> Void {
         if fseek(self.pointer, offset, SEEK_SET) != 0 {
-            throw FileError.SeekFailed(Errno.description())
+            throw FileError.seekFailed(Errno.description())
         }
     }
 

Sources/Files.swift

@@ -14,13 +14,13 @@
 public func shareFilesFromDirectory(_ directoryPath: String) -> ((HttpRequest) -> HttpResponse) {
     return { r in
         guard let fileRelativePath = r.params.first else {
-            return .NotFound
+            return .notFound
         }
         let absolutePath = directoryPath + "/" + fileRelativePath.1
         guard let file = try? File.openForReading(absolutePath) else {
-            return .NotFound
+            return .notFound
         }
-        return .RAW(200, "OK", [:], { writer in
+        return .raw(200, "OK", [:], { writer in
             defer { file.close() }
             try writer.write(file)
         })
@@ -30,12 +30,12 @@ public func shareFilesFromDirectory(_ directoryPath: String) -> ((HttpRequest) -
 public func directoryBrowser(_ dir: String) -> ((HttpRequest) -> HttpResponse) {
     return { r in
         guard let (_, value) = r.params.first else {
-            return HttpResponse.NotFound
+            return HttpResponse.notFound
         }
         let filePath = dir + "/" + value
         do {
             guard try File.exists(filePath) else {
-                return HttpResponse.NotFound
+                return HttpResponse.notFound
             }
             if try File.isDirectory(filePath) {
                 let files = try File.list(filePath)
@@ -57,15 +57,15 @@ public func directoryBrowser(_ dir: String) -> ((HttpRequest) -> HttpResponse) {
                 }(r)
             } else {
                 guard let file = try? File.openForReading(filePath) else {
-                    return .NotFound
+                    return .notFound
                 }
-                return .RAW(200, "OK", [:], { writer in
+                return .raw(200, "OK", [:], { writer in
                     defer { file.close() }
                     try writer.write(file)
                 })
             }
         } catch {
-            return HttpResponse.InternalServerError
+            return HttpResponse.internalServerError
         }
     }
 }

Sources/HttpResponse.swift

@@ -26,15 +26,15 @@ public protocol HttpResponseBodyWriter {
 
 public enum HttpResponseBody {
     
-    case Json(AnyObject)
-    case Html(String)
-    case Text(String)
-    case Custom(Any, (Any) throws -> String)
+    case json(AnyObject)
+    case html(String)
+    case text(String)
+    case custom(Any, (Any) throws -> String)
     
     func content() -> (Int, ((HttpResponseBodyWriter) throws -> Void)?) {
         do {
             switch self {
-            case .Json(let object):
+            case .json(let object):
                 #if os(Linux)
                     let data = [UInt8]("Not ready for Linux.".utf8)
                     return (data.count, {
@@ -49,18 +49,18 @@ public enum HttpResponseBody {
                         try $0.write(data)
                     })
                 #endif
-            case .Text(let body):
+            case .text(let body):
                 let data = [UInt8](body.utf8)
                 return (data.count, {
                     try $0.write(data)
                 })
-            case .Html(let body):
+            case .html(let body):
                 let serialised = "<html><meta charset=\"UTF-8\"><body>\(body)</body></html>"
                 let data = [UInt8](serialised.utf8)
                 return (data.count, {
                     try $0.write(data)
                 })
-            case .Custom(let object, let closure):
+            case .custom(let object, let closure):
                 let serialised = try closure(object)
                 let data = [UInt8](serialised.utf8)
                 return (data.count, {
@@ -78,61 +78,61 @@ public enum HttpResponseBody {
 
 public enum HttpResponse {
     
-    case SwitchProtocols([String: String], (Socket) -> Void)
-    case OK(HttpResponseBody), Created, Accepted
-    case MovedPermanently(String)
-    case BadRequest(HttpResponseBody?), Unauthorized, Forbidden, NotFound
-    case InternalServerError
-    case RAW(Int, String, [String:String]?, ((HttpResponseBodyWriter) throws -> Void)? )
+    case switchProtocols([String: String], (Socket) -> Void)
+    case ok(HttpResponseBody), created, accepted
+    case movedPermanently(String)
+    case badRequest(HttpResponseBody?), unauthorized, forbidden, notFound
+    case internalServerError
+    case raw(Int, String, [String:String]?, ((HttpResponseBodyWriter) throws -> Void)? )
 
     func statusCode() -> Int {
         switch self {
-        case .SwitchProtocols(_, _)   : return 101
-        case .OK(_)                   : return 200
-        case .Created                 : return 201
-        case .Accepted                : return 202
-        case .MovedPermanently        : return 301
-        case .BadRequest(_)           : return 400
-        case .Unauthorized            : return 401
-        case .Forbidden               : return 403
-        case .NotFound                : return 404
-        case .InternalServerError     : return 500
-        case .RAW(let code, _ , _, _) : return code
+        case .switchProtocols(_, _)   : return 101
+        case .ok(_)                   : return 200
+        case .created                 : return 201
+        case .accepted                : return 202
+        case .movedPermanently        : return 301
+        case .badRequest(_)           : return 400
+        case .unauthorized            : return 401
+        case .forbidden               : return 403
+        case .notFound                : return 404
+        case .internalServerError     : return 500
+        case .raw(let code, _ , _, _) : return code
         }
     }
     
     func reasonPhrase() -> String {
         switch self {
-        case .SwitchProtocols(_, _)    : return "Switching Protocols"
-        case .OK(_)                    : return "OK"
-        case .Created                  : return "Created"
-        case .Accepted                 : return "Accepted"
-        case .MovedPermanently         : return "Moved Permanently"
-        case .BadRequest(_)            : return "Bad Request"
-        case .Unauthorized             : return "Unauthorized"
-        case .Forbidden                : return "Forbidden"
-        case .NotFound                 : return "Not Found"
-        case .InternalServerError      : return "Internal Server Error"
-        case .RAW(_, let phrase, _, _) : return phrase
+        case .switchProtocols(_, _)    : return "Switching Protocols"
+        case .ok(_)                    : return "OK"
+        case .created                  : return "Created"
+        case .accepted                 : return "Accepted"
+        case .movedPermanently         : return "Moved Permanently"
+        case .badRequest(_)            : return "Bad Request"
+        case .unauthorized             : return "Unauthorized"
+        case .forbidden                : return "Forbidden"
+        case .notFound                 : return "Not Found"
+        case .internalServerError      : return "Internal Server Error"
+        case .raw(_, let phrase, _, _) : return phrase
         }
     }
     
     func headers() -> [String: String] {
         var headers = ["Server" : "Swifter \(HttpServer.VERSION)"]
         switch self {
-        case .SwitchProtocols(let switchHeaders, _):
+        case .switchProtocols(let switchHeaders, _):
             for (key, value) in switchHeaders {
                 headers[key] = value
             }
-        case .OK(let body):
+        case .ok(let body):
             switch body {
-            case .Json(_)   : headers["Content-Type"] = "application/json"
-            case .Html(_)   : headers["Content-Type"] = "text/html"
+            case .json(_)   : headers["Content-Type"] = "application/json"
+            case .html(_)   : headers["Content-Type"] = "text/html"
             default:break
             }
-        case .MovedPermanently(let location):
+        case .movedPermanently(let location):
             headers["Location"] = location
-        case .RAW(_, _, let rawHeaders, _):
+        case .raw(_, _, let rawHeaders, _):
             if let rawHeaders = rawHeaders {
                 for (k, v) in rawHeaders {
                     headers.updateValue(v, forKey: k)
@@ -145,16 +145,16 @@ public enum HttpResponse {
     
     func content() -> (length: Int, write: ((HttpResponseBodyWriter) throws -> Void)?) {
         switch self {
-        case .OK(let body)             : return body.content()
-        case .BadRequest(let body)     : return body?.content() ?? (-1, nil)
-        case .RAW(_, _, _, let writer) : return (-1, writer)
+        case .ok(let body)             : return body.content()
+        case .badRequest(let body)     : return body?.content() ?? (-1, nil)
+        case .raw(_, _, _, let writer) : return (-1, writer)
         default                        : return (-1, nil)
         }
     }
     
     func socketSession() -> ((Socket) -> Void)?  {
         switch self {
-        case .SwitchProtocols(_, let handler) : return handler
+        case .switchProtocols(_, let handler) : return handler
         default: return nil
         }
     }

Sources/HttpRouter.swift

@@ -11,7 +11,10 @@
     import Foundation
 #endif
 
-public class HttpRouter {
+open class HttpRouter {
+    
+    public init() {
+    }
     
     private class Node {
         var nodes = [String: Node]()

Sources/HttpServerIO.swift

@@ -15,7 +15,7 @@ public class HttpServerIO {
     
     private var socket = Socket(socketFileDescriptor: -1)
     private var sockets = Set<Socket>()
-    private var stateValue: Int32 = HttpServerIOState.Stopped.rawValue
+    private var stateValue: Int32 = HttpServerIOState.stopped.rawValue
     public private(set) var state: HttpServerIOState {
         get {
             return HttpServerIOState(rawValue: stateValue)!
@@ -24,7 +24,7 @@ public class HttpServerIO {
             OSAtomicCompareAndSwapInt(self.state.rawValue, state.rawValue, &stateValue)
         }
     }
-    public var operating: Bool { get { return self.state == .Running } }
+    public var operating: Bool { get { return self.state == .running } }
     private let queue = DispatchQueue(label: "swifter.httpserverio.clientsockets")
     
     public func port() throws -> Int {
@@ -43,7 +43,7 @@ public class HttpServerIO {
     public func start(_ port: in_port_t = 8080, forceIPv4: Bool = false, priority: DispatchQoS.QoSClass = DispatchQoS.QoSClass.background) throws {
         guard !self.operating else { return }
         stop()
-        self.state = .Starting
+        self.state = .starting
         self.socket = try Socket.tcpSocketForListen(port, forceIPv4)
         DispatchQueue.global(qos: priority).async { [weak self] in
             guard let `self` = self else { return }
@@ -63,12 +63,12 @@ public class HttpServerIO {
             }
             self.stop()
         }
-        self.state = .Running
+        self.state = .running
     }
     
     public func stop() {
         guard self.operating else { return }
-        self.state = .Stopping
+        self.state = .stopping
         // Shutdown connected peers because they can live in 'keep-alive' or 'websocket' loops.
         for socket in self.sockets {
             socket.shutdwn()
@@ -77,11 +77,11 @@ public class HttpServerIO {
             self.sockets.removeAll(keepingCapacity: true)
         }
         socket.release()
-        self.state = .Stopped
+        self.state = .stopped
     }
     
     public func dispatch(_ request: HttpRequest) -> ([String: String], (HttpRequest) -> HttpResponse) {
-        return ([:], { _ in HttpResponse.NotFound })
+        return ([:], { _ in HttpResponse.notFound })
     }
     
     private func handleConnection(_ socket: Socket) {
@@ -166,10 +166,10 @@ public class HttpServerIO {
 }
 
 public enum HttpServerIOState: Int32 {
-    case Starting
-    case Running
-    case Stopping
-    case Stopped
+    case starting
+    case running
+    case stopping
+    case stopped
 }
 
 #if os(Linux)

Sources/Scopes.swift

@@ -15,7 +15,7 @@ public func scopes(_ scope: @escaping Closure) -> ((HttpRequest) -> HttpResponse
     return { r in
         ScopesBuffer[Process.tid] = ""
         scope()
-        return .RAW(200, "OK", ["Content-Type": "text/html"], {
+        return .raw(200, "OK", ["Content-Type": "text/html"], {
             try? $0.write([UInt8](("<!DOCTYPE html>"  + (ScopesBuffer[Process.tid] ?? "")).utf8))
         })
     }

Sources/Socket+File.swift

@@ -14,8 +14,8 @@
 #if os(iOS) || os (Linux)
     struct sf_hdtr { }
     
-    private func sendfileImpl(source: Int32, _ target: Int32, _: off_t, _: UnsafeMutablePointer<off_t>, _: UnsafeMutablePointer<sf_hdtr>, _: Int32) -> Int32 {
-        var buffer = [UInt8](count: 1024, repeatedValue: 0)
+    private func sendfileImpl(_ source: Int32, _ target: Int32, _: off_t, _: UnsafeMutablePointer<off_t>, _: UnsafeMutablePointer<sf_hdtr>, _: Int32) -> Int32 {
+        var buffer = [UInt8](repeating: 0, count: 1024)
         while true {
             let readResult = read(source, &buffer, buffer.count)
             guard readResult > 0 else {
@@ -40,7 +40,9 @@ extension Socket {
     
     public func writeFile(_ file: File) throws -> Void {
         var offset: off_t = 0
-        let result = sendfileImpl(fileno(file.pointer), self.socketFileDescriptor, 0, &offset, nil, 0)
+        var sf: sf_hdtr = sf_hdtr()
+        let result = sendfileImpl(fileno(file.pointer), self.socketFileDescriptor, 0, &offset, &sf
+            , 0)
         if result == -1 {
             throw SocketError.writeFailed("sendfile: " + Errno.description())
         }

Sources/Socket.swift

@@ -27,7 +27,7 @@ public enum SocketError: Error {
     case getSockNameFailed(String)
 }
 
-public class Socket: Hashable, Equatable {
+open class Socket: Hashable, Equatable {
         
     let socketFileDescriptor: Int32
     private var shutdown = false
@@ -124,7 +124,7 @@ public class Socket: Hashable, Equatable {
         }
     }
     
-    public func read() throws -> UInt8 {
+    open func read() throws -> UInt8 {
         var buffer = [UInt8](repeating: 0, count: 1)
         let next = recv(self.socketFileDescriptor as Int32, &buffer, Int(buffer.count), 0)
         if next <= 0 {

Sources/WebSockets.swift

@@ -16,13 +16,13 @@ public func websocket(
     _ binary: ((WebSocketSession, [UInt8]) -> Void)?) -> ((HttpRequest) -> HttpResponse) {
     return { r in
         guard r.hasTokenForHeader("upgrade", token: "websocket") else {
-            return .BadRequest(.Text("Invalid value of 'Upgrade' header: \(r.headers["upgrade"])"))
+            return .badRequest(.text("Invalid value of 'Upgrade' header: \(r.headers["upgrade"])"))
         }
         guard r.hasTokenForHeader("connection", token: "upgrade") else {
-            return .BadRequest(.Text("Invalid value of 'Connection' header: \(r.headers["connection"])"))
+            return .badRequest(.text("Invalid value of 'Connection' header: \(r.headers["connection"])"))
         }
         guard let secWebSocketKey = r.headers["sec-websocket-key"] else {
-            return .BadRequest(.Text("Invalid value of 'Sec-Websocket-Key' header: \(r.headers["sec-websocket-key"])"))
+            return .badRequest(.text("Invalid value of 'Sec-Websocket-Key' header: \(r.headers["sec-websocket-key"])"))
         }
         let protocolSessionClosure: ((Socket) -> Void) = { socket in
             let session = WebSocketSession(socket)
@@ -33,14 +33,14 @@ public func websocket(
                 if let handleText = text {
                     if frame.fin {
                         if payload.count > 0 {
-                            throw WebSocketSession.WsError.ProtocolError("Continuing fragmented frame cannot have an operation code.")
+                            throw WebSocketSession.WsError.protocolError("Continuing fragmented frame cannot have an operation code.")
                         }
                         var textFramePayload = frame.payload.map { Int8(bitPattern: $0) }
                         textFramePayload.append(0)
                         if let text = String(validatingUTF8: textFramePayload) {
                             handleText(session, text)
                         } else {
-                            throw WebSocketSession.WsError.InvalidUTF8("")
+                            throw WebSocketSession.WsError.invalidUTF8("")
                         }
                     } else {
                         payload.append(contentsOf: frame.payload)
@@ -53,7 +53,7 @@ public func websocket(
                 if let handleBinary = binary {
                     if frame.fin {
                         if payload.count > 0 {
-                            throw WebSocketSession.WsError.ProtocolError("Continuing fragmented frame cannot have an operation code.")
+                            throw WebSocketSession.WsError.protocolError("Continuing fragmented frame cannot have an operation code.")
                         }
                         handleBinary(session, frame.payload)
                     } else {
@@ -85,10 +85,10 @@ public func websocket(
                 case .binary:
                     try handleBinaryPayload(frame)
                 case .close:
-                    throw WebSocketSession.Control.Close
+                    throw WebSocketSession.Control.close
                 case .ping:
                     if frame.payload.count > 125 {
-                        throw WebSocketSession.WsError.ProtocolError("Payload gretter than 125 octets.")
+                        throw WebSocketSession.WsError.protocolError("Payload gretter than 125 octets.")
                     } else {
                         session.writeFrame(ArraySlice(frame.payload), .pong)
                     }
@@ -104,16 +104,16 @@ public func websocket(
                 }
             } catch let error {
                 switch error {
-                case WebSocketSession.Control.Close:
+                case WebSocketSession.Control.close:
                     // Normal close
                     break
-                case WebSocketSession.WsError.UnknownOpCode:
+                case WebSocketSession.WsError.unknownOpCode:
                     print("Unknown Op Code: \(error)")
-                case WebSocketSession.WsError.UnMaskedFrame:
+                case WebSocketSession.WsError.unMaskedFrame:
                     print("Unmasked frame: \(error)")
-                case WebSocketSession.WsError.InvalidUTF8:
+                case WebSocketSession.WsError.invalidUTF8:
                     print("Invalid UTF8 character: \(error)")
-                case WebSocketSession.WsError.ProtocolError:
+                case WebSocketSession.WsError.protocolError:
                     print("Protocol error: \(error)")
                 default:
                     print("Unkown error \(error)")
@@ -124,15 +124,15 @@ public func websocket(
         }
         let secWebSocketAccept = String.toBase64((secWebSocketKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").sha1())
         let headers = [ "Upgrade": "WebSocket", "Connection": "Upgrade", "Sec-WebSocket-Accept": secWebSocketAccept]
-        return HttpResponse.SwitchProtocols(headers, protocolSessionClosure)
+        return HttpResponse.switchProtocols(headers, protocolSessionClosure)
     }
 }
 
 public class WebSocketSession: Hashable, Equatable  {
     
-    public enum WsError: Error { case UnknownOpCode(String), UnMaskedFrame(String), ProtocolError(String), InvalidUTF8(String) }
+    public enum WsError: Error { case unknownOpCode(String), unMaskedFrame(String), protocolError(String), invalidUTF8(String) }
     public enum OpCode: UInt8 { case `continue` = 0x00, close = 0x08, ping = 0x09, pong = 0x0A, text = 0x01, binary = 0x02 }
-    public enum Control: Error { case Close }
+    public enum Control: Error { case close }
     
     public class Frame {
         public var opcode = OpCode.close
@@ -215,20 +215,20 @@ public class WebSocketSession: Hashable, Equatable  {
         frm.rsv3 = fst & 0x10
         guard frm.rsv1 == 0 && frm.rsv2 == 0 && frm.rsv3 == 0
             else {
-            throw WsError.ProtocolError("Reserved frame bit has not been negocitated.")
+            throw WsError.protocolError("Reserved frame bit has not been negocitated.")
         }
         let opc = fst & 0x0F
         guard let opcode = OpCode(rawValue: opc) else {
             // "If an unknown opcode is received, the receiving endpoint MUST _Fail the WebSocket Connection_."
             // http://tools.ietf.org/html/rfc6455#section-5.2 ( Page 29 )
-            throw WsError.UnknownOpCode("\(opc)")
+            throw WsError.unknownOpCode("\(opc)")
         }
         if frm.fin == false {
             switch opcode {
             case .ping, .pong, .close:
                 // Control frames must not be fragmented
                 // https://tools.ietf.org/html/rfc6455#section-5.5 ( Page 35 )
-                throw WsError.ProtocolError("Control frames must not be framgemted.")
+                throw WsError.protocolError("Control frames must not be fragmented.")
             default:
                 break
             }
@@ -239,7 +239,7 @@ public class WebSocketSession: Hashable, Equatable  {
         guard msk else {
             // "...a client MUST mask all frames that it sends to the server."
             // http://tools.ietf.org/html/rfc6455#section-5.1
-            throw WsError.UnMaskedFrame("A client must mask all frames that it sends to the server.")
+            throw WsError.unMaskedFrame("A client must mask all frames that it sends to the server.")
         }
         var len = UInt64(sec & 0x7F)
         if len == 0x7E {

XCode/SwifterSampleOSX/main.swift

@@ -10,7 +10,7 @@ import Swifter
 do {
     let server = demoServer(try File.currentWorkingDirectory())
     server["/testAfterBaseRoute"] = { request in
-        return .OK(.Html("ok !"))
+        return .ok(.html("ok !"))
     }
     
     if #available(OSXApplicationExtension 10.10, *) {

XCode/SwifterSampleiOS/AppDelegate.swift

@@ -12,8 +12,7 @@ import Swifter
 class AppDelegate: UIResponder, UIApplicationDelegate {
     
     var window: UIWindow?
-    
-    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject : AnyObject]?) -> Bool {
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey : Any]? = nil) -> Bool {
         return true
     }
-}
+}

XCode/SwifterSampleiOS/ViewController.swift

@@ -14,7 +14,7 @@ class ViewController: UIViewController {
     override func viewDidLoad() {
         super.viewDidLoad()
         do {
-            let server = demoServer(NSBundle.mainBundle().resourcePath!)
+            let server = demoServer(Bundle.main.resourcePath!)
             try server.start(9080)
             self.server = server
         } catch {

XCode/SwifterTestsCommon/IOSafetyTests.swift

@@ -7,6 +7,7 @@
 //
 
 import XCTest
+import Swifter
 
 class IOSafetyTests: XCTestCase {
     var server: HttpServer!
@@ -24,16 +25,20 @@ class IOSafetyTests: XCTestCase {
     }
 
     func testStopWithActiveConnections() {
-        (0...100).forEach { _ in
+        (0...100).forEach { cpt in
             server = HttpServer.pingServer()
-            try! server.start()
-            XCTAssertFalse(URLSession.shared.retryPing())
-            (0...100).forEach { _ in
-                DispatchQueue.global(qos: DispatchQoS.default.qosClass).sync {
-                    URLSession.shared.pingTask { _, _, _ in }.resume()
+            do {
+                try server.start()
+                XCTAssertFalse(URLSession.shared.retryPing())
+                (0...100).forEach { _ in
+                    DispatchQueue.global(qos: DispatchQoS.default.qosClass).sync {
+                        URLSession.shared.pingTask { _, _, _ in }.resume()
+                    }
                 }
+                server.stop()
+            } catch let e {
+                XCTFail("\(cpt): \(e)")
             }
-            server.stop()
         }
     }
 }

XCode/SwifterTestsCommon/PingServer.swift

@@ -14,25 +14,25 @@ extension HttpServer {
     class func pingServer() -> HttpServer {
         let server = HttpServer()
         server.GET["/ping"] = { request in
-            return HttpResponse.OK(.Text("pong!"))
+            return HttpResponse.ok(.text("pong!"))
         }
         return server
     }
 }
 
-let defaultLocalhost = NSURL(string:"http://localhost:8080")!
+let defaultLocalhost = URL(string:"http://localhost:8080")!
 
 // Client
 extension URLSession {
     func pingTask(
-        hostURL: NSURL = defaultLocalhost,
+        hostURL: URL = defaultLocalhost,
         completionHandler handler: @escaping (Data?, URLResponse?, Error?) -> Void
     ) -> URLSessionDataTask {
-        return self.dataTask(with: hostURL.appendingPathComponent("/ping")!, completionHandler: handler)
+        return self.dataTask(with: hostURL.appendingPathComponent("/ping"), completionHandler: handler)
     }
     
     func retryPing(
-        hostURL: NSURL = defaultLocalhost,
+        hostURL: URL = defaultLocalhost,
         timeout: Double = 2.0
     ) -> Bool {
         let semaphore = DispatchSemaphore(value: 0)
@@ -52,7 +52,7 @@ extension URLSession {
         return timedOut
     }
     
-    func signalIfPongReceived(_ semaphore: DispatchSemaphore, hostURL: NSURL) {
+    func signalIfPongReceived(_ semaphore: DispatchSemaphore, hostURL: URL) {
         pingTask(hostURL: hostURL) { data, response, error in
             if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 {
                 semaphore.signal()

XCode/SwifterTestsCommon/SwifterTestsHttpParser.swift

@@ -6,6 +6,7 @@
 //
 
 import XCTest
+import Swifter
 
 class SwifterTestsHttpParser: XCTestCase {
     

XCode/SwifterTestsCommon/SwifterTestsHttpRouter.swift

@@ -7,6 +7,7 @@
 //
 
 import XCTest
+import Swifter
 
 class SwifterTestsHttpRouter: XCTestCase {
     
@@ -15,7 +16,7 @@ class SwifterTestsHttpRouter: XCTestCase {
         let router = HttpRouter()
         
         router.register(nil, path: "/", handler: { r in
-            return .OK(.Html("OK"))
+            return .ok(.html("OK"))
         })
         
         XCTAssertNotNil(router.route(nil, path: "/"))
@@ -26,7 +27,7 @@ class SwifterTestsHttpRouter: XCTestCase {
         let router = HttpRouter()
         
         router.register(nil, path: "/a/b/c/d", handler: { r in
-            return .OK(.Html("OK"))
+            return .ok(.html("OK"))
         })
         
         XCTAssertNil(router.route(nil, path: "/"))
@@ -41,7 +42,7 @@ class SwifterTestsHttpRouter: XCTestCase {
         let router = HttpRouter()
         
         router.register(nil, path: "/a/*/c/d", handler: { r in
-            return .OK(.Html("OK"))
+            return .ok(.html("OK"))
         })
         
         XCTAssertNil(router.route(nil, path: "/"))
@@ -57,7 +58,7 @@ class SwifterTestsHttpRouter: XCTestCase {
         let router = HttpRouter()
         
         router.register(nil, path: "/a/:arg1/:arg2/b/c/d/:arg3", handler: { r in
-            return .OK(.Html("OK"))
+            return .ok(.html("OK"))
         })
         
         XCTAssertNil(router.route(nil, path: "/"))
@@ -73,7 +74,7 @@ class SwifterTestsHttpRouter: XCTestCase {
         let router = HttpRouter()
         
         router.register(nil, path: "/a/**/e/f/g", handler: { r in
-            return .OK(.Html("OK"))
+            return .ok(.html("OK"))
         })
         
         XCTAssertNil(router.route(nil, path: "/"))
@@ -87,11 +88,11 @@ class SwifterTestsHttpRouter: XCTestCase {
         let router = HttpRouter()
         
         router.register(nil, path: "/a/b/", handler: { r in
-            return .OK(.Html("OK"))
+            return .ok(.html("OK"))
         })
         
         router.register(nil, path: "/a/b/:var", handler: { r in
-            return .OK(.Html("OK"))
+            return .ok(.html("OK"))
         })
         
         

XCode/SwifterTestsCommon/SwifterTestsWebSocketSession.swift

@@ -6,6 +6,7 @@
 //
 
 import XCTest
+import Swifter
 
 class SwifterTestsWebSocketSession: XCTestCase {
     
@@ -42,7 +43,7 @@ class SwifterTestsWebSocketSession: XCTestCase {
             let session = WebSocketSession(TestSocket([0b0000_0001, 0b0000_0000, 0, 0, 0, 0]))
             let _ = try session.readFrame()
             XCTAssert(false, "Parser should not accept unmasked frames.")
-        } catch WebSocketSession.WsError.UnMaskedFrame {
+        } catch WebSocketSession.WsError.unMaskedFrame {
             XCTAssert(true, "Parse should throw UnMaskedFrame error for unmasked message.")
         } catch {
             XCTAssert(false, "Parse should throw UnMaskedFrame error for unmasked message.")
@@ -84,24 +85,24 @@ class SwifterTestsWebSocketSession: XCTestCase {
             let session = WebSocketSession(TestSocket([0b0000_1000, 0b1000_0000, 0, 0, 0, 0]))
             let frame = try session.readFrame()
             XCTAssertEqual(frame.opcode, WebSocketSession.OpCode.close, "Parser should accept Close opcode.")
-        } catch {
-            XCTAssert(false, "Parser should accept Close opcode without any errors.")
+        } catch let e {
+            XCTAssert(false, "Parser should accept Close opcode without any errors. \(e)")
         }
         
         do {
             let session = WebSocketSession(TestSocket([0b0000_1001, 0b1000_0000, 0, 0, 0, 0]))
             let frame = try session.readFrame()
             XCTAssertEqual(frame.opcode, WebSocketSession.OpCode.ping, "Parser should accept Ping opcode.")
-        } catch {
-            XCTAssert(false, "Parser should accept Ping opcode without any errors.")
+        } catch let e {
+            XCTAssert(false, "Parser should accept Ping opcode without any errors. \(e)")
         }
         
         do {
             let session = WebSocketSession(TestSocket([0b0000_1010, 0b1000_0000, 0, 0, 0, 0]))
             let frame = try session.readFrame()
             XCTAssertEqual(frame.opcode, WebSocketSession.OpCode.pong, "Parser should accept Pong opcode.")
-        } catch {
-            XCTAssert(false, "Parser should accept Pong opcode without any errors.")
+        } catch let e {
+            XCTAssert(false, "Parser should accept Pong opcode without any errors. \(e)")
         }
         
         for opcode in [3, 4, 5, 6, 7, 11, 12, 13, 14, 15] {
@@ -109,7 +110,7 @@ class SwifterTestsWebSocketSession: XCTestCase {
                 let session = WebSocketSession(TestSocket([UInt8(opcode), 0b1000_0000, 0, 0, 0, 0]))
                 let _ = try session.readFrame()
                 XCTAssert(false, "Parse should throw an error for unknown opcode: \(opcode)")
-            } catch WebSocketSession.WsError.UnknownOpCode(_) {
+            } catch WebSocketSession.WsError.unknownOpCode(_) {
                 XCTAssert(true, "Parse should throw UnknownOpCode error for unknown opcode.")
             } catch {
                 XCTAssert(false, "Parse should throw UnknownOpCode error for unknown opcode (was \(error)).")