Merge branch 'development'

* development:
  Update readme to reflect that 10.0+ only support socket.io 2.0+
  Remove more doubleEncode stuff
  Remove doubleEncodeUTF8 from NSDictionary translation
  Fix unicode for socket.io 2.0
  Use guard statements in polling
  More Objective-c tests
  Use Data instead of NSData
  code style
  Make addHeaders inout

README.md

@@ -51,7 +51,7 @@ SocketIOClient* socket = [[SocketIOClient alloc] initWithSocketURL:url config:@{
 ```
 
 ## Features
-- Supports socket.io 1.0+
+- Supports socket.io 2.0+ (For socket.io 1.0 use v9.x)
 - Supports binary
 - Supports Polling and WebSockets
 - Supports TLS/SSL

SocketIO-MacTests/SocketEngineTest.swift

@@ -60,7 +60,7 @@ class SocketEngineTest: XCTestCase {
             }
         }
 
-        engine.parseEngineMessage("{\"code\": 0, \"message\": \"Unknown transport\"}", fromPolling: false)
+        engine.parseEngineMessage("{\"code\": 0, \"message\": \"Unknown transport\"}")
         waitForExpectations(timeout: 3, handler: nil)
     }
 
@@ -71,7 +71,7 @@ class SocketEngineTest: XCTestCase {
             finalExpectation.fulfill()
         }
 
-        engine.parseEngineMessage("afafafda", fromPolling: false)
+        engine.parseEngineMessage("afafafda")
         waitForExpectations(timeout: 3, handler: nil)
     }
 
@@ -79,11 +79,13 @@ class SocketEngineTest: XCTestCase {
         let expect = expectation(description: "Engine Decodes utf8")
 
         client.on("stringTest") {data, ack in
-            XCTAssertEqual(data[0] as? String, "lïne one\nlīne \rtwo", "Failed string test")
+            XCTAssertEqual(data[0] as? String, "lïne one\nlīne \rtwo𦅙𦅛", "Failed string test")
             expect.fulfill()
         }
 
-        engine.parsePollingMessage("41:42[\"stringTest\",\"lïne one\\nlīne \\rtwo\"]")
+        let stringMessage = "42[\"stringTest\",\"lïne one\\nlīne \\rtwo𦅙𦅛\"]"
+
+        engine.parsePollingMessage("\(stringMessage.utf16.count):\(stringMessage)")
         waitForExpectations(timeout: 3, handler: nil)
     }
 
@@ -116,8 +118,8 @@ class SocketEngineTest: XCTestCase {
             expect.fulfill()
         }
 
-        engine.parseEngineMessage(packetString, fromPolling: false)
+        engine.parseEngineMessage(packetString)
-        engine.parseEngineMessage(b64String, fromPolling: false)
+        engine.parseEngineMessage(b64String)
 
         waitForExpectations(timeout: 3, handler: nil)
     }

SocketIO-MacTests/SocketObjectiveCTest.m

@@ -7,7 +7,9 @@
 //  Merely tests whether the Objective-C api breaks
 //
 
-#import <XCTest/XCTest.h>
+@import Dispatch;
+@import Foundation;
+@import XCTest;
 @import SocketIO;
 
 @interface SocketObjectiveCTest : XCTestCase
@@ -24,20 +26,66 @@
     self.socket = [[SocketIOClient alloc] initWithSocketURL:url config:@{@"log": @NO, @"forcePolling": @YES}];
 }
 
+- (void)testProperties {
+    NSURL* url = nil;
+    
+    url = self.socket.socketURL;
+    self.socket.forceNew = false;
+    self.socket.handleQueue = dispatch_get_main_queue();
+    self.socket.nsp = @"/objective-c";
+    self.socket.reconnects = false;
+    self.socket.reconnectWait = 1;
+}
+
 - (void)testOnSyntax {
     [self.socket on:@"someCallback" callback:^(NSArray* data, SocketAckEmitter* ack) {
         [ack with:@[@1]];
     }];
 }
 
+- (void)testConnectSyntax {
+    [self.socket connect];
+}
+
+- (void)testConnectTimeoutAfterSyntax {
+    [self.socket connectWithTimeoutAfter:1 withHandler: ^() { }];
+}
+
+- (void)testDisconnectSyntax {
+    [self.socket disconnect];
+}
+
+- (void)testLeaveNamespaceSyntax {
+    [self.socket leaveNamespace];
+}
+
+- (void)testJoinNamespaceSyntax {
+    [self.socket joinNamespace:@"/objective-c"];
+}
+
+- (void)testOnAnySyntax {
+    [self.socket onAny:^(SocketAnyEvent* any) {
+        NSString* event = any.event;
+        NSArray* data = any.items;
+        
+        [self.socket emit:event with:data];
+    }];
+}
+
+- (void)testReconnectSyntax {
+    [self.socket reconnect];
+}
+
+- (void)testRemoveAllHandlersSyntax {
+    [self.socket removeAllHandlers];
+}
+
 - (void)testEmitSyntax {
     [self.socket emit:@"testEmit" with:@[@YES]];
 }
 
 - (void)testEmitWithAckSyntax {
-    [[self.socket emitWithAck:@"testAckEmit" with:@[@YES]] timingOutAfter:0 callback:^(NSArray* data) {
+    [[self.socket emitWithAck:@"testAckEmit" with:@[@YES]] timingOutAfter:0 callback:^(NSArray* data) { }];
-
-    }];
 }
 
 - (void)testOffSyntax {

Source/SocketEngine.swift

@@ -66,10 +66,6 @@ public final class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePoll
     /// An array of HTTPCookies that are sent during the connection.
     public private(set) var cookies: [HTTPCookie]?
 
-    /// Set to `true` if using the node.js version of socket.io. The node.js version of socket.io
-    /// handles utf8 incorrectly.
-    public private(set) var doubleEncodeUTF8 = true
-
     /// A dictionary of extra http headers that will be set during connection.
     public private(set) var extraHeaders: [String: String]?
 
@@ -153,8 +149,6 @@ public final class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePoll
                 connectParams = params
             case let .cookies(cookies):
                 self.cookies = cookies
-            case let .doubleEncodeUTF8(encode):
-                doubleEncodeUTF8 = encode
             case let .extraHeaders(headers):
                 extraHeaders = headers
             case let .sessionDelegate(delegate):
@@ -227,8 +221,8 @@ public final class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePoll
         // binary in base64 string
         let noPrefix = message[message.index(message.startIndex, offsetBy: 2)..<message.endIndex]
 
-        if let data = NSData(base64Encoded: noPrefix, options: .ignoreUnknownCharacters) {
+        if let data = Data(base64Encoded: noPrefix, options: .ignoreUnknownCharacters) {
-            client?.parseEngineBinaryData(data as Data)
+            client?.parseEngineBinaryData(data)
         }
     }
 
@@ -511,11 +505,10 @@ public final class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePoll
     /// - parameter message: The message to parse.
     /// - parameter fromPolling: Whether this message is from long-polling.
     ///                          If `true` we might have to fix utf8 encoding.
-    public func parseEngineMessage(_ message: String, fromPolling: Bool) {
+    public func parseEngineMessage(_ message: String) {
         DefaultSocketLogger.Logger.log("Got message: %@", type: logType, args: message)
 
         let reader = SocketStringReader(message: message)
-        let fixedString: String
 
         if message.hasPrefix("b4") {
             return handleBase64(message: message)
@@ -527,23 +520,17 @@ public final class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePoll
             return
         }
 
-        if fromPolling && type != .noop && doubleEncodeUTF8 {
-            fixedString = fixDoubleUTF8(message)
-        } else {
-            fixedString = message
-        }
-
         switch type {
         case .message:
-            handleMessage(String(fixedString.characters.dropFirst()))
+            handleMessage(String(message.characters.dropFirst()))
         case .noop:
             handleNOOP()
         case .pong:
-            handlePong(with: fixedString)
+            handlePong(with: message)
         case .open:
-            handleOpen(openData: String(fixedString.characters.dropFirst()))
+            handleOpen(openData: String(message.characters.dropFirst()))
         case .close:
-            handleClose(fixedString)
+            handleClose(message)
         default:
             DefaultSocketLogger.Logger.log("Got unknown packet type", type: logType)
         }
@@ -643,17 +630,19 @@ public final class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePoll
             return
         }
 
-        if websocket {
+        guard websocket else {
-            connected = false
-            websocket = false
-
-            if let reason = error?.localizedDescription {
-                didError(reason: reason)
-            } else {
-                client?.engineDidClose(reason: "Socket Disconnected")
-            }
-        } else {
             flushProbeWait()
+
+            return
+        }
+
+        connected = false
+        websocket = false
+
+        if let reason = error?.localizedDescription {
+            didError(reason: reason)
+        } else {
+            client?.engineDidClose(reason: "Socket Disconnected")
         }
     }
 }

Source/SocketEnginePollable.swift

@@ -71,9 +71,7 @@ public protocol SocketEnginePollable : SocketEngineSpec {
 
 // Default polling methods
 extension SocketEnginePollable {
-    private func addHeaders(for req: URLRequest) -> URLRequest {
+    private func addHeaders(to req: inout URLRequest) {
-        var req = req
-
         if cookies != nil {
             let headers = HTTPCookie.requestHeaderFields(with: cookies!)
             req.allHTTPHeaderFields = headers
@@ -84,8 +82,6 @@ extension SocketEnginePollable {
                 req.setValue(value, forHTTPHeaderField: headerName)
             }
         }
-
-        return req
     }
 
     func createRequestForPostWithPostWait() -> URLRequest {
@@ -94,9 +90,7 @@ extension SocketEnginePollable {
         var postStr = ""
 
         for packet in postWait {
-            let len = packet.characters.count
+            postStr += "\(packet.utf16.count):\(packet)"
-
-            postStr += "\(len):\(packet)"
         }
 
         DefaultSocketLogger.Logger.log("Created POST string: %@", type: "SocketEnginePolling", args: postStr)
@@ -104,11 +98,10 @@ extension SocketEnginePollable {
         var req = URLRequest(url: urlPollingWithSid)
         let postData = postStr.data(using: .utf8, allowLossyConversion: false)!
 
-        req = addHeaders(for: req)
+        addHeaders(to: &req)
 
         req.httpMethod = "POST"
         req.setValue("text/plain; charset=UTF-8", forHTTPHeaderField: "Content-Type")
-
         req.httpBody = postData
         req.setValue(String(postData.count), forHTTPHeaderField: "Content-Length")
 
@@ -119,20 +112,16 @@ extension SocketEnginePollable {
     ///
     /// You shouldn't need to call this directly, the engine should automatically maintain a long-poll request.
     public func doPoll() {
-        if websocket || waitingForPoll || !connected || closed {
+        guard !websocket && !waitingForPoll && connected && !closed else { return }
-            return
-        }
 
         var req = URLRequest(url: urlPollingWithSid)
-        req = addHeaders(for: req)
+        addHeaders(to: &req)
 
-        doLongPoll(for: req )
+        doLongPoll(for: req)
     }
 
     func doRequest(for req: URLRequest, callbackWith callback: @escaping (Data?, URLResponse?, Error?) -> Void) {
-        if !polling || closed || invalidated || fastUpgrade {
+        guard polling && !closed && !invalidated && !fastUpgrade else { return }
-            return
-        }
 
         DefaultSocketLogger.Logger.log("Doing polling %@ %@", type: "SocketEnginePolling",
                                        args: req.httpMethod ?? "", req)
@@ -173,10 +162,10 @@ extension SocketEnginePollable {
     }
 
     private func flushWaitingForPost() {
-        if postWait.count == 0 || !connected {
+        guard postWait.count != 0 && connected else { return }
-            return
+        guard !websocket else {
-        } else if websocket {
             flushWaitingForPostToWebSocket()
+
             return
         }
 
@@ -211,13 +200,15 @@ extension SocketEnginePollable {
     func parsePollingMessage(_ str: String) {
         guard str.characters.count != 1 else { return }
 
+        DefaultSocketLogger.Logger.log("Got poll message: %@", type: "SocketEnginePolling", args: str)
+
         var reader = SocketStringReader(message: str)
 
         while reader.hasNext {
             if let n = Int(reader.readUntilOccurence(of: ":")) {
-                parseEngineMessage(reader.read(count: n), fromPolling: true)
+                parseEngineMessage(reader.read(count: n))
             } else {
-                parseEngineMessage(str, fromPolling: true)
+                parseEngineMessage(str)
                 break
             }
         }
@@ -232,15 +223,8 @@ extension SocketEnginePollable {
     /// - parameter withData: The data associated with this message.
     public func sendPollMessage(_ message: String, withType type: SocketEnginePacketType, withData datas: [Data]) {
         DefaultSocketLogger.Logger.log("Sending poll: %@ as type: %@", type: "SocketEnginePolling", args: message, type.rawValue)
-        let fixedMessage: String
 
-        if doubleEncodeUTF8 {
+        postWait.append(String(type.rawValue) + message)
-            fixedMessage = doubleEncodeUTF8(message)
-        } else {
-            fixedMessage = message
-        }
-
-        postWait.append(String(type.rawValue) + fixedMessage)
 
         for data in datas {
             if case let .right(bin) = createBinaryDataForSend(using: data) {

Source/SocketEngineSpec.swift

@@ -39,10 +39,6 @@ import Foundation
     /// The connect parameters sent during a connect.
     var connectParams: [String: Any]? { get set }
 
-    /// Set to `true` if using the node.js version of socket.io. The node.js version of socket.io
-    /// handles utf8 incorrectly.
-    var doubleEncodeUTF8: Bool { get }
-
     /// An array of HTTPCookies that are sent during the connection.
     var cookies: [HTTPCookie]? { get }
 
@@ -125,7 +121,7 @@ import Foundation
     /// - parameter message: The message to parse.
     /// - parameter fromPolling: Whether this message is from long-polling.
     ///                          If `true` we might have to fix utf8 encoding.
-    func parseEngineMessage(_ message: String, fromPolling: Bool)
+    func parseEngineMessage(_ message: String)
 
     /// Writes a message to engine.io, independent of transport.
     ///
@@ -165,24 +161,6 @@ extension SocketEngineSpec {
         }
     }
 
-    func doubleEncodeUTF8(_ string: String) -> String {
-        if let latin1 = string.data(using: String.Encoding.utf8),
-            let utf8 = NSString(data: latin1, encoding: String.Encoding.isoLatin1.rawValue) {
-                return utf8 as String
-        } else {
-            return string
-        }
-    }
-
-    func fixDoubleUTF8(_ string: String) -> String {
-        if let utf8 = string.data(using: String.Encoding.isoLatin1),
-            let latin1 = NSString(data: utf8, encoding: String.Encoding.utf8.rawValue) {
-                return latin1 as String
-        } else {
-            return string
-        }
-    }
-
     /// Send an engine message (4)
     func send(_ msg: String, withData datas: [Data]) {
         write(msg, withType: .message, withData: datas)

Source/SocketEngineWebsocket.swift

@@ -68,7 +68,7 @@ extension SocketEngineWebsocket {
 
     /// Delegate method for when a message is received.
     public func websocketDidReceiveMessage(socket: WebSocket, text: String) {
-        parseEngineMessage(text, fromPolling: false)
+        parseEngineMessage(text)
     }
 
     /// Delegate method for when binary is received.

Source/SocketExtensions.swift

@@ -48,8 +48,6 @@ extension NSDictionary {
             return .connectParams(params)
         case let ("cookies", cookies as [HTTPCookie]):
             return .cookies(cookies)
-        case let ("doubleEncodeUTF8", encode as Bool):
-            return .doubleEncodeUTF8(encode)
         case let ("extraHeaders", headers as [String: String]):
             return .extraHeaders(headers)
         case let ("forceNew", force as Bool):
@@ -104,7 +102,7 @@ extension NSDictionary {
 
 extension String {
     func toArray() throws -> [Any] {
-        guard let stringData = data(using: .utf8, allowLossyConversion: false) else { return [] }
+        guard let stringData = data(using: .utf16, allowLossyConversion: false) else { return [] }
         guard let array = try JSONSerialization.jsonObject(with: stringData, options: .mutableContainers) as? [Any] else {
              throw JSONError.notArray
         }
@@ -113,7 +111,7 @@ extension String {
     }
 
     func toNSDictionary() throws -> NSDictionary {
-        guard let binData = data(using: .utf8, allowLossyConversion: false) else { return [:] }
+        guard let binData = data(using: .utf16, allowLossyConversion: false) else { return [:] }
         guard let json = try JSONSerialization.jsonObject(with: binData, options: .allowFragments) as? NSDictionary else {
             throw JSONError.notNSDictionary
         }

Source/SocketIOClient.swift

@@ -237,7 +237,7 @@ open class SocketIOClient : NSObject, SocketIOClientSpec, SocketEngineClient, So
     /// - parameter items: The items to send with this event. May be left out.
     open func emit(_ event: String, _ items: SocketData...) {
         do {
-            emit(event, with: try items.map({ try $0.socketRepresentation() }))
+            try emit(event, with: items.map({ try $0.socketRepresentation() }))
         } catch let err {
             DefaultSocketLogger.Logger.error("Error creating socketRepresentation for emit: \(event), \(items)",
                                              type: logType)

Source/SocketIOClientOption.swift

@@ -36,8 +36,8 @@ public enum SocketIOClientOption : ClientOption {
     /// An array of cookies that will be sent during the initial connection.
     case cookies([HTTPCookie])
 
-    /// The node.js socket.io currently does funky things to unicode when doing HTTP long-polling. Passing `true` in
+    /// Deprecated
-    /// this option causes the client to try and fix any bad unicode that might be sent.
+    @available(*, deprecated, message: "No longer needed in socket.io 2.0+")
     case doubleEncodeUTF8(Bool)
 
     /// Any extra HTTP headers that should be sent during the initial connection.

Source/SocketParsable.swift

@@ -107,7 +107,7 @@ extension SocketParsable where Self: SocketIOClientSpec {
             }
         }
         
-        var dataArray = message[message.characters.index(reader.currentIndex, offsetBy: 1)..<message.endIndex]
+        var dataArray = String(message.utf16[message.utf16.index(reader.currentIndex, offsetBy: 1)..<message.utf16.endIndex])!
         
         if type == .error && !dataArray.hasPrefix("[") && !dataArray.hasSuffix("]") {
             dataArray = "[" + dataArray + "]"

Source/SocketStringReader.swift

@@ -24,29 +24,29 @@
 
 struct SocketStringReader {
     let message: String
-    var currentIndex: String.Index
+    var currentIndex: String.UTF16View.Index
     var hasNext: Bool {
-        return currentIndex != message.endIndex
+        return currentIndex != message.utf16.endIndex
     }
 
     var currentCharacter: String {
-        return String(message[currentIndex])
+        return String(UnicodeScalar(message.utf16[currentIndex])!)
     }
 
     init(message: String) {
         self.message = message
-        currentIndex = message.startIndex
+        currentIndex = message.utf16.startIndex
     }
 
     @discardableResult
-    mutating func advance(by: Int) -> String.Index {
+    mutating func advance(by: Int) -> String.UTF16View.Index {
-        currentIndex = message.characters.index(currentIndex, offsetBy: by)
+        currentIndex = message.utf16.index(currentIndex, offsetBy: by)
 
         return currentIndex
     }
 
     mutating func read(count: Int) -> String {
-        let readString = message[currentIndex..<message.characters.index(currentIndex, offsetBy: count)]
+        let readString = String(message.utf16[currentIndex..<message.utf16.index(currentIndex, offsetBy: count)])!
 
         advance(by: count)
 
@@ -54,20 +54,20 @@ struct SocketStringReader {
     }
 
     mutating func readUntilOccurence(of string: String) -> String {
-        let substring = message[currentIndex..<message.endIndex]
+        let substring = message.utf16[currentIndex..<message.utf16.endIndex]
 
-        guard let foundRange = substring.range(of: string) else {
+        guard let foundIndex = substring.index(of: string.utf16.first!) else {
-            currentIndex = message.endIndex
+            currentIndex = message.utf16.endIndex
 
-            return substring
+            return String(substring)!
         }
 
-        advance(by: message.characters.distance(from: message.characters.startIndex, to: foundRange.lowerBound) + 1)
+        advance(by: substring.distance(from: substring.startIndex, to: foundIndex) + 1)
 
-        return substring.substring(to: foundRange.lowerBound)
+        return String(substring[substring.startIndex..<foundIndex])!
     }
 
     mutating func readUntilEnd() -> String {
-        return read(count: message.characters.distance(from: currentIndex, to: message.endIndex))
+        return read(count: message.utf16.distance(from: currentIndex, to: message.utf16.endIndex))
     }
 }