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

Author: nuclearace

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

@@ -17,73 +17,75 @@ class SocketEngineTest: XCTestCase {
         super.setUp()
         client = SocketIOClient(socketURL: URL(string: "http://localhost")!)
         engine = SocketEngine(client: client, url: URL(string: "http://localhost")!, options: nil)
-        
+
         client.setTestable()
     }
-    
+
     func testBasicPollingMessage() {
         let expect = expectation(description: "Basic polling test")
         client.on("blankTest") {data, ack in
             expect.fulfill()
         }
-        
+
         engine.parsePollingMessage("15:42[\"blankTest\"]")
         waitForExpectations(timeout: 3, handler: nil)
     }
-    
+
     func testTwoPacketsInOnePollTest() {
         let finalExpectation = expectation(description: "Final packet in poll test")
         var gotBlank = false
-        
+
         client.on("blankTest") {data, ack in
             gotBlank = true
         }
-        
+
         client.on("stringTest") {data, ack in
             if let str = data[0] as? String, gotBlank {
                 if str == "hello" {
                     finalExpectation.fulfill()
                 }
             }
         }
-        
+
         engine.parsePollingMessage("15:42[\"blankTest\"]24:42[\"stringTest\",\"hello\"]")
         waitForExpectations(timeout: 3, handler: nil)
     }
-    
+
     func testEngineDoesErrorOnUnknownTransport() {
         let finalExpectation = expectation(description: "Unknown Transport")
-        
+
         client.on("error") {data, ack in
             if let error = data[0] as? String, error == "Unknown transport" {
                 finalExpectation.fulfill()
             }
         }
-        
-        engine.parseEngineMessage("{\"code\": 0, \"message\": \"Unknown transport\"}", fromPolling: false)
+
+        engine.parseEngineMessage("{\"code\": 0, \"message\": \"Unknown transport\"}")
         waitForExpectations(timeout: 3, handler: nil)
     }
-    
+
     func testEngineDoesErrorOnUnknownMessage() {
         let finalExpectation = expectation(description: "Engine Errors")
-        
+
         client.on("error") {data, ack in
             finalExpectation.fulfill()
         }
-        
-        engine.parseEngineMessage("afafafda", fromPolling: false)
+
+        engine.parseEngineMessage("afafafda")
         waitForExpectations(timeout: 3, handler: nil)
     }
-    
+
     func testEngineDecodesUTF8Properly() {
         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)
     }
 
@@ -102,23 +104,23 @@ class SocketEngineTest: XCTestCase {
         XCTAssertEqual(engine.urlPolling.query, "transport=polling&b64=1&forbidden=%21%2A%27%28%29%3B%3A%40%26%3D%2B%24%2C%2F%3F%25%23%5B%5D%22%20%7B%7D")
         XCTAssertEqual(engine.urlWebSocket.query, "transport=websocket&forbidden=%21%2A%27%28%29%3B%3A%40%26%3D%2B%24%2C%2F%3F%25%23%5B%5D%22%20%7B%7D")
     }
-    
+
     func testBase64Data() {
         let expect = expectation(description: "Engine Decodes base64 data")
         let b64String = "b4aGVsbG8NCg=="
         let packetString = "451-[\"test\",{\"test\":{\"_placeholder\":true,\"num\":0}}]"
-        
+
         client.on("test") {data, ack in
             if let data = data[0] as? Data, let string = String(data: data, encoding: .utf8) {
                 XCTAssertEqual(string, "hello")
             }
-            
+
             expect.fulfill()
         }
-        
-        engine.parseEngineMessage(packetString, fromPolling: false)
-        engine.parseEngineMessage(b64String, fromPolling: false)
-        
+
+        engine.parseEngineMessage(packetString)
+        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 @@ - (void)setUp {
     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) {
-            client?.parseEngineBinaryData(data as Data)
+        if let data = Data(base64Encoded: noPrefix, options: .ignoreUnknownCharacters) {
+            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 {
-            connected = false
-            websocket = false
+        guard websocket else {
+            flushProbeWait()
 
-            if let reason = error?.localizedDescription {
-                didError(reason: reason)
-            } else {
-                client?.engineDidClose(reason: "Socket Disconnected")
-            }
+            return
+        }
+
+        connected = false
+        websocket = false
+
+        if let reason = error?.localizedDescription {
+            didError(reason: reason)
         } else {
-            flushProbeWait()
+            client?.engineDidClose(reason: "Socket Disconnected")
         }
     }
 }