Comply with the latest EventSource specification (#31)

Author: gwhelanLD

Source/EventParser.swift

@@ -8,15 +8,14 @@ class EventParser {
         static let idLabel: Substring = "id"
         static let eventLabel: Substring = "event"
         static let retryLabel: Substring = "retry"
-        static let defaultEventType = "message"
     }
 
     private let handler: EventHandler
     private let connectionHandler: ConnectionHandler
 
     private var data: String = ""
     private var lastEventId: String?
-    private var eventType: String = Constants.defaultEventType
+    private var eventType: String = ""
 
     init(handler: EventHandler, connectionHandler: ConnectionHandler) {
         self.handler = handler
@@ -36,6 +35,11 @@ class EventParser {
         }
     }
 
+    func reset() {
+        data = ""
+        eventType = ""
+    }
+
     private func dropLeadingSpace(str: Substring) -> Substring {
         if str.first == " " {
             return str[str.index(after: str.startIndex)...]
@@ -46,12 +50,14 @@ class EventParser {
     private func processField(field: Substring, value: Substring) {
         switch field {
         case Constants.dataLabel:
-            if !data.isEmpty {
-                data.append(contentsOf: "\n")
-            }
             data.append(contentsOf: value)
+            data.append(contentsOf: "\n")
         case Constants.idLabel:
-            lastEventId = String(value)
+            // See https://github.com/whatwg/html/issues/689 for reasoning on not setting lastEventId if the value
+            // contains a null code point.
+            if !value.contains("\u{0000}") {
+                lastEventId = String(value)
+            }
         case Constants.eventLabel:
             eventType = String(value)
         case Constants.retryLabel:
@@ -64,15 +70,20 @@ class EventParser {
     }
 
     private func dispatchEvent() {
-        guard !data.isEmpty
-        else { return }
-        let messageEvent = MessageEvent(data: data, lastEventId: lastEventId)
         if let lastEventId = lastEventId {
             connectionHandler.setLastEventId(lastEventId)
         }
-        handler.onMessage(eventType: eventType, messageEvent: messageEvent)
+        guard !data.isEmpty
+        else {
+            eventType = ""
+            return
+        }
+        // remove the last LF
+        _ = data.popLast()
+        let messageEvent = MessageEvent(data: data, lastEventId: lastEventId)
+        handler.onMessage(eventType: eventType.isEmpty ? "message" : eventType, messageEvent: messageEvent)
         data = ""
-        eventType = Constants.defaultEventType
+        eventType = ""
     }
 }
 

Source/LDSwiftEventSource.swift

@@ -242,9 +242,8 @@ class EventSourceDelegate: NSObject, URLSessionDataDelegate {
     public func urlSession(_ session: URLSession,
                            task: URLSessionTask,
                            didCompleteWithError error: Error?) {
-        utf8LineParser.closeAndReset().forEach(eventParser.parse)
-        // Send additional empty line to force a last dispatch
-        eventParser.parse(line: "")
+        utf8LineParser.closeAndReset()
+        eventParser.reset()
 
         if let error = error {
             if readyState != .shutdown && errorHandlerAction != .shutdown {

Source/Logs.swift

@@ -8,22 +8,23 @@ class Logs {
     enum Level {
         case debug, info, warn, error
 
-        #if !os(Linux)
+#if !os(Linux)
         private static let osLogTypes = [ Level.debug: OSLogType.debug,
                                           Level.info: OSLogType.info,
                                           Level.warn: OSLogType.default,
                                           Level.error: OSLogType.error]
         var osLogType: OSLogType { Level.osLogTypes[self]! }
-        #endif
+#endif
     }
 
-    #if !os(Linux)
+#if !os(Linux)
     private let logger: OSLog = OSLog(subsystem: "com.launchdarkly.swift-eventsource", category: "LDEventSource")
-    #endif
 
     func log(_ level: Level, _ staticMsg: StaticString, _ args: CVarArg...) {
-        #if !os(Linux)
         os_log(staticMsg, log: logger, type: level.osLogType, args)
-        #endif
     }
+#else
+    // We use Any over CVarArg here, because on Linux prior to Swift 5.4 String does not conform to CVarArg
+    func log(_ level: Level, _ staticMsg: StaticString, _ args: Any...) { }
+#endif
 }

Source/UTF8LineParser.swift

@@ -1,21 +1,11 @@
 import Foundation
 
-class DataIter: IteratorProtocol {
-    let data: Data
-    var position: Data.Index
+struct DataIter: IteratorProtocol {
+    var data: Data
+    var position: Data.Index { data.startIndex }
 
-    init(_ data: Data) {
-        self.data = data
-        self.position = data.startIndex
-    }
-
-    func next() -> UInt8? {
-        guard position != data.endIndex
-        else { return nil }
-
-        let res = data[position]
-        position = data.index(after: position)
-        return res
+    mutating func next() -> UInt8? {
+        data.popFirst()
     }
 }
 
@@ -31,25 +21,22 @@ class UTF8LineParser {
 
     func append(_ body: Data) -> [String] {
         let data = remainder + body
-        var dataIter = DataIter(data)
+        var dataIter = DataIter(data: data)
         var remainderPos = data.endIndex
         var lines: [String] = []
 
         Decode: while true {
             switch utf8Parser.parseScalar(from: &dataIter) {
             case .valid(let scalarResult):
                 let scalar = Unicode.UTF8.decode(scalarResult)
-                if seenCr {
-                    lines.append(currentString)
-                    currentString = ""
+
+                if seenCr && scalar == lf {
                     seenCr = false
-                    if scalar == lf {
-                        continue
-                    }
+                    continue
                 }
-                if scalar == cr {
-                    seenCr = true
-                } else if scalar == lf {
+
+                seenCr = scalar == cr
+                if scalar == cr || scalar == lf {
                     lines.append(currentString)
                     currentString = ""
                 } else {
@@ -58,16 +45,14 @@ class UTF8LineParser {
             case .emptyInput:
                 break Decode
             case .error(let len):
+                seenCr = false
                 if dataIter.position == data.endIndex {
                     // Error at end of block, carry over in case of split code point
                     remainderPos = data.index(data.endIndex, offsetBy: -len)
+                    // May as well break here as next will be .emptyInput
+                    break Decode
                 } else {
                     // Invalid character, replace with replacement character
-                    if seenCr {
-                        lines.append(currentString)
-                        currentString = ""
-                        seenCr = false
-                    }
                     currentString.append(replacement)
                 }
             }
@@ -77,26 +62,9 @@ class UTF8LineParser {
         return lines
     }
 
-    func closeAndReset() -> [String] {
-        var lines: [String] = []
-
-        if seenCr {
-            lines.append(currentString)
-            currentString = ""
-        }
-
-        if !remainder.isEmpty {
-            currentString.append(replacement)
-            remainder = Data()
-        }
-
-        if !currentString.isEmpty {
-            lines.append(currentString)
-        }
-
-        currentString = ""
+    func closeAndReset() {
         seenCr = false
-
-        return lines
+        currentString = ""
+        remainder = Data()
     }
 }

Tests/.swiftlint.yml

@@ -3,10 +3,14 @@ disabled_rules:
 opt_in_rules:
   # Must specify even though enabled by default to update configuration of rule below.
   - line_length
+  - type_body_length
 
-# Provide a little extra lenience for test code line length.
+# Provide a little extra lenience for test code line and body length.
 line_length:
   warning: 140
+type_body_length:
+  warning: 400
+  error: 500
 
 excluded:
   # Autogenerated manifest of tests