merge master

Socket.IO-Client-Swift.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name         = "Socket.IO-Client-Swift"
-  s.version      = "1.2.1"
+  s.version      = "1.2.2"
   s.summary      = "Socket.IO-client for Swift"
   s.description  = <<-DESC
                    Socket.IO-client for Swift.
@@ -12,7 +12,7 @@ Pod::Spec.new do |s|
   s.author       = { "Erik" => "nuclear.ace@gmail.com" }
   s.ios.deployment_target = '8.0'
   s.osx.deployment_target = '10.10'
-  s.source       = { :git => "https://github.com/socketio/socket.io-client-swift.git", :tag => 'v1.2.1' }
+  s.source       = { :git => "https://github.com/socketio/socket.io-client-swift.git", :tag => 'v1.2.2' }
   s.source_files  = "SwiftIO/**/*.swift"
   s.requires_arc = true
   # s.dependency 'Starscream', '~> 0.9' # currently this repo includes Starscream swift files

SwiftIO/SocketEngine.swift

@@ -407,7 +407,9 @@ public class SocketEngine: NSObject, WebSocketDelegate {
 
     private func parseEngineMessage(var message:String) {
         // NSLog("Engine got message: \(message)")
-        fixDoubleUTF8(&message)
+        if self.polling {
+            fixDoubleUTF8(&message)
+        }
 
         // We should upgrade
         if message == "3probe" {
@@ -501,9 +503,11 @@ public class SocketEngine: NSObject, WebSocketDelegate {
         }
     }
 
-    private func sendPollMessage(msg:String, withType type:PacketType,
+    private func sendPollMessage(var msg:String, withType type:PacketType,
         datas:[NSData]? = nil) {
             // println("Sending poll: \(msg) as type: \(type.rawValue)")
+
+            doubleEncodeUTF8(&msg)
             let strMsg = "\(type.rawValue)\(msg)"
 
             self.postWait.append(strMsg)

SwiftIO/SocketFixUTF8.swift

@@ -21,84 +21,17 @@
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 //  THE SOFTWARE.
 //
-// Adapted from: https://github.com/durbrow/fix-double-utf8.swift
 
 import Foundation
 
-var memoizer = [String: UnicodeScalar]()
+func fixDoubleUTF8(inout name:String) {
-
+    let utf8 = name.dataUsingEncoding(NSISOLatin1StringEncoding, allowLossyConversion: false)!
-private func lookup(base:UnicodeScalar, combi:UnicodeScalar) -> UnicodeScalar {
+    let latin1 = NSString(data: utf8, encoding: NSUTF8StringEncoding)!
-    let combined = "\(base)\(combi)"
+    name = latin1 as String
-    
-    if let y = memoizer[combined] {
-        return y
-    }
-    
-    for i in 0x80...0xFF {
-        let ch = UnicodeScalar(i)
-        
-        if String(ch) == combined {
-            memoizer[combined] = ch
-            return ch
-        }
-    }
-    let ch = UnicodeScalar(0xFFFD) // Unicode replacement character <EFBFBD>
-    
-    memoizer[combined] = ch
-    return ch
 }
 
-func fixDoubleUTF8(inout name:String) {
+func doubleEncodeUTF8(inout str:String) {
-    var isASCII = true
+    let latin1 = str.dataUsingEncoding(NSUTF8StringEncoding)!
-    var y = [UInt8]()
+    let utf8 = NSString(data: latin1, encoding: NSISOLatin1StringEncoding)!
-    
+    str = utf8 as String
-    for ch in name.unicodeScalars {
+}
-        if ch.value < 0x80 {
-            y.append(UInt8(ch.value))
-            continue
-        }
-        isASCII = false
-        
-        if ch.value < 0x100 {
-            y.append(UInt8(ch.value))
-            continue
-        }
-        // might be a combining character that when combined with the
-        // preceeding character maps to a codepoint in the UTF8 range
-        if y.count == 0 {
-            return
-        }
-        
-        let last = y.removeLast()
-        let repl = lookup(UnicodeScalar(last), ch)
-        
-        // the replacement needs to be in the UTF8 range
-        if repl.value >= 0x100 {
-            return
-        }
-        
-        y.append(UInt8(repl.value))
-    }
-    
-    if isASCII {
-        return
-    }
-    
-    y.append(0) // null terminator
-    
-    return y.withUnsafeBufferPointer {
-        let cstr = UnsafePointer<CChar>($0.baseAddress) // typecase from uint8_t * to char *
-        let rslt = String.fromCStringRepairingIllFormedUTF8(cstr) // -> (String, Bool)
-        if let str = rslt.0 {
-            if !rslt.hadError {
-                name = str
-            } else {
-                println("error")
-            }
-        } else {
-            println("error")
-        }
-        
-        return
-    }
-}

SwiftIO/SwiftRegex.swift

@@ -18,7 +18,7 @@ var swiftRegexCache = [String: NSRegularExpression]()
 public class SwiftRegex: NSObject, BooleanType {
     var target:String
     var regex: NSRegularExpression
-    
+
     init(target:String, pattern:String, options:NSRegularExpressionOptions = nil) {
         self.target = target
         if let regex = swiftRegexCache[pattern] {
@@ -36,16 +36,16 @@ public class SwiftRegex: NSObject, BooleanType {
         }
         super.init()
     }
-    
+
     class func failure(message: String) {
         println("SwiftRegex: "+message)
         //assert(false,"SwiftRegex: failed")
     }
-    
+
     final var targetRange: NSRange {
-        return NSRange(location: 0,length: count(target))
+        return NSRange(location: 0,length: target.utf16Count)
     }
-    
+
     final func substring(range: NSRange) -> String? {
         if ( range.location != NSNotFound ) {
             return (target as NSString).substringWithRange(range)
@@ -53,23 +53,23 @@ public class SwiftRegex: NSObject, BooleanType {
             return nil
         }
     }
-    
+
     public func doesMatch(options: NSMatchingOptions = nil) -> Bool {
         return range(options: options).location != NSNotFound
     }
-    
+
     public func range(options: NSMatchingOptions = nil) -> NSRange {
         return regex.rangeOfFirstMatchInString(target as String, options: nil, range: targetRange)
     }
-    
+
     public func match(options: NSMatchingOptions = nil) -> String? {
         return substring(range(options: options))
     }
-    
+
     public func groups(options: NSMatchingOptions = nil) -> [String]? {
         return groupsForMatch(regex.firstMatchInString(target as String, options: options, range: targetRange))
     }
-    
+
     func groupsForMatch(match: NSTextCheckingResult!) -> [String]? {
         if match != nil {
             var groups = [String]()
@@ -85,51 +85,51 @@ public class SwiftRegex: NSObject, BooleanType {
             return nil
         }
     }
-    
+
     public subscript(groupno: Int) -> String? {
         get {
             return groups()?[groupno]
         }
-        
+
         set(newValue) {
             if newValue == nil {
                 return
             }
-            
+
             for match in matchResults()!.reverse() {
                 let replacement = regex.replacementStringForResult(match,
                     inString: target as String, offset: 0, template: newValue!)
                 let mut = NSMutableString(string: target)
                 mut.replaceCharactersInRange(match.rangeAtIndex(groupno), withString: replacement)
-                
+
                 target = mut as String
             }
         }
     }
-    
+
     func matchResults(options: NSMatchingOptions = nil) -> [NSTextCheckingResult]? {
         let matches = regex.matchesInString(target as String, options: options, range: targetRange)
             as? [NSTextCheckingResult]
-        
+
         if matches != nil {
             return matches!
         } else {
             return nil
         }
     }
-    
+
     public func ranges(options: NSMatchingOptions = nil) -> [NSRange] {
         return matchResults(options: options)!.map { $0.range }
     }
-    
+
     public func matches(options: NSMatchingOptions = nil) -> [String] {
         return matchResults(options: options)!.map( { self.substring($0.range)!})
     }
-    
+
     public func allGroups(options: NSMatchingOptions = nil) -> [[String]?] {
         return matchResults(options: options)!.map {self.groupsForMatch($0)}
     }
-    
+
     public func dictionary(options: NSMatchingOptions = nil) -> Dictionary<String,String> {
         var out = Dictionary<String,String>()
         for match in matchResults(options: options)! {
@@ -137,26 +137,26 @@ public class SwiftRegex: NSObject, BooleanType {
         }
         return out
     }
-    
+
     func substituteMatches(substitution: (NSTextCheckingResult, UnsafeMutablePointer<ObjCBool>) -> String,
         options:NSMatchingOptions = nil) -> String {
             let out = NSMutableString()
             var pos = 0
-            
+
             regex.enumerateMatchesInString(target as String, options: options, range: targetRange ) {
                 (match: NSTextCheckingResult!, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
-                
+
                 let matchRange = match.range
                 out.appendString( self.substring(NSRange(location:pos, length:matchRange.location-pos))!)
                 out.appendString( substitution(match, stop) )
                 pos = matchRange.location + matchRange.length
             }
-            
+
             out.appendString(substring( NSRange(location:pos, length:targetRange.length-pos))!)
-            
+
             return out as String
     }
-    
+
     public var boolValue: Bool {
         return doesMatch()
     }
@@ -184,11 +184,11 @@ public func ~= (left: SwiftRegex, right: String) -> String {
 public func ~= (left: SwiftRegex, right: [String]) -> String {
     var matchNumber = 0
     return left.substituteMatches({match, stop -> String in
-        
+
         if ++matchNumber == right.count {
             stop.memory = true
         }
-        
+
         return left.regex.replacementStringForResult( match,
             inString: left.target as String, offset: 0, template: right[matchNumber-1] )
         }, options: nil)