Merge pull request #10 from LiveUI/linuxEncodingTest

rafiki270 · web-flow · commit 1dec74a7e9f4 · 2018-08-13T13:52:56.000+01:00
Moved the encoder to native Swift Types from NS* to be more typesafe
diff --git a/Jenkinsfile b/Jenkinsfile
@@ -24,3 +24,4 @@ pipeline {
     }
   }
 }
+
diff --git a/Sources/XMLCoding/Encoder/XMLEncoder.swift b/Sources/XMLCoding/Encoder/XMLEncoder.swift
diff --git a/Sources/XMLCoding/Encoder/XMLEncodingStorage.swift b/Sources/XMLCoding/Encoder/XMLEncodingStorage.swift
@@ -9,14 +9,111 @@
 
 import Foundation
 
+// MARK: - Mutable Containers
+
+internal class MutableContainerDictionary {
+    private var values: [String: MutableContainer] = [:]
+    
+    subscript(key: String) -> MutableContainer? {
+        get {
+            return values[key]
+        }
+        set(newValue) {
+            values[key] = newValue
+        }
+    }
+    
+    internal func asContainer() -> Container {
+        let transformedValues: [String: Container] = values.mapValues { value in
+            return value.asContainer()
+        }
+        
+        return .dictionary(transformedValues)
+    }
+}
+
+internal class MutableContainerArray {
+    private var values: [MutableContainer] = []
+    
+    subscript(index: Int) -> MutableContainer {
+        get {
+            return values[index]
+        }
+    }
+    
+    var count: Int {
+        return values.count
+    }
+    
+    func append(_ newElement: MutableContainer) {
+        values.append(newElement)
+    }
+    
+    func insert(_ newElement: MutableContainer, at index: Int) {
+        values.insert(newElement, at: index)
+    }
+    
+    internal func asContainer() -> Container {
+        let transformedValues: [Container] = values.map { value in
+            return value.asContainer()
+        }
+        
+        return .array(transformedValues)
+    }
+}
+
+internal enum MutableContainer {
+    case dictionary(MutableContainerDictionary)
+    case array(MutableContainerArray)
+    case boolean(Bool)
+    case string(String)
+    case int64(Int64)
+    case uint64(UInt64)
+    case double(Double)
+    case null
+    
+    internal func asContainer() -> Container {
+        switch self {
+        case .dictionary(let innerDictionary):
+            return innerDictionary.asContainer()
+        case .array(let innerArray):
+            return innerArray.asContainer()
+        case .boolean(let value):
+            return .boolean(value)
+        case .string(let value):
+            return .string(value)
+        case .int64(let value):
+            return .int64(value)
+        case .uint64(let value):
+            return .uint64(value)
+        case .double(let value):
+            return .double(value)
+        case .null:
+            return .null
+        }
+    }
+}
+
+// MARK: - Container
+
+internal enum Container {
+    case dictionary([String: Container])
+    case array([Container])
+    case boolean(Bool)
+    case string(String)
+    case int64(Int64)
+    case uint64(UInt64)
+    case double(Double)
+    case null
+}
+
 // MARK: - Encoding Storage and Containers
 
 internal struct _XMLEncodingStorage {
     // MARK: Properties
     
     /// The container stack.
-    /// Elements may be any one of the XML types (NSNull, NSNumber, NSString, NSArray, NSDictionary).
-    private(set) internal var containers: [NSObject] = []
+    private(set) internal var containers: [MutableContainer] = []
     
     // MARK: - Initialization
     
@@ -29,23 +126,27 @@ internal struct _XMLEncodingStorage {
         return self.containers.count
     }
     
-    internal mutating func pushKeyedContainer() -> NSMutableDictionary {
-        let dictionary = NSMutableDictionary()
-        self.containers.append(dictionary)
+    internal mutating func pushKeyedContainer() -> MutableContainerDictionary {
+        let dictionary = MutableContainerDictionary()
+        self.containers.append(.dictionary(dictionary))
         return dictionary
     }
     
-    internal mutating func pushUnkeyedContainer() -> NSMutableArray {
-        let array = NSMutableArray()
-        self.containers.append(array)
+    internal mutating func pushUnkeyedContainer() -> MutableContainerArray {
+        let array = MutableContainerArray()
+        self.containers.append(.array(array))
         return array
     }
     
-    internal mutating func push(container: NSObject) {
+    internal mutating func push(container: MutableContainer) {
         self.containers.append(container)
     }
     
-    internal mutating func popContainer() -> NSObject {
+    internal mutating func pushNull() {
+        self.containers.append(.null)
+    }
+    
+    internal mutating func popContainer() -> MutableContainer {
         precondition(self.containers.count > 0, "Empty container stack.")
         return self.containers.popLast()!
     }
diff --git a/Sources/XMLCoding/Encoder/XMLReferencingEncoder.swift b/Sources/XMLCoding/Encoder/XMLReferencingEncoder.swift
@@ -18,10 +18,10 @@ internal class _XMLReferencingEncoder : _XMLEncoder {
     /// The type of container we're referencing.
     private enum Reference {
         /// Referencing a specific index in an array container.
-        case array(NSMutableArray, Int)
+        case array(MutableContainerArray, Int)
         
         /// Referencing a specific key in a dictionary container.
-        case dictionary(NSMutableDictionary, String)
+        case dictionary(MutableContainerDictionary, String)
     }
     
     // MARK: - Properties
@@ -35,7 +35,7 @@ internal class _XMLReferencingEncoder : _XMLEncoder {
     // MARK: - Initialization
     
     /// Initializes `self` by referencing the given array container in the given encoder.
-    internal init(referencing encoder: _XMLEncoder, at index: Int, wrapping array: NSMutableArray) {
+    internal init(referencing encoder: _XMLEncoder, at index: Int, wrapping array: MutableContainerArray) {
         self.encoder = encoder
         self.reference = .array(array, index)
         super.init(options: encoder.options, codingPath: encoder.codingPath)
@@ -45,7 +45,7 @@ internal class _XMLReferencingEncoder : _XMLEncoder {
     
     /// Initializes `self` by referencing the given dictionary container in the given encoder.
     internal init(referencing encoder: _XMLEncoder,
-                     key: CodingKey, convertedKey: CodingKey, wrapping dictionary: NSMutableDictionary) {
+                     key: CodingKey, convertedKey: CodingKey, wrapping dictionary: MutableContainerDictionary) {
         self.encoder = encoder
         self.reference = .dictionary(dictionary, convertedKey.stringValue)
         super.init(options: encoder.options, codingPath: encoder.codingPath)
@@ -66,9 +66,9 @@ internal class _XMLReferencingEncoder : _XMLEncoder {
     
     // Finalizes `self` by writing the contents of our storage to the referenced encoder's storage.
     deinit {
-        let value: Any
+        let value: MutableContainer
         switch self.storage.count {
-        case 0: value = NSDictionary()
+        case 0: value = .dictionary(.init())
         case 1: value = self.storage.popContainer()
         default: fatalError("Referencing encoder deallocated with multiple containers on stack.")
         }
@@ -78,7 +78,7 @@ internal class _XMLReferencingEncoder : _XMLEncoder {
             array.insert(value, at: index)
             
         case .dictionary(let dictionary, let key):
-            dictionary[NSString(string: key)] = value
+            dictionary[key] = value
         }
     }
 }
diff --git a/Sources/XMLCoding/XMLStackParser.swift b/Sources/XMLCoding/XMLStackParser.swift
@@ -79,80 +79,80 @@ internal class _XMLElement {
         self.init(key: key, value: nil, attributes: attributes.mapValues({ $0.description }), children: children)
     }
     
-    static func createRootElement(rootKey: String, object: NSObject) -> _XMLElement? {
+    static func createRootElement(rootKey: String, header: XMLHeader?, options: XMLEncoder._Options, object: Container) throws -> Data {
         let element = _XMLElement(key: rootKey)
         
-        if let object = object as? NSDictionary {
-            _XMLElement.modifyElement(element: element, parentElement: nil, key: nil, object: object)
-        } else if let object = object as? NSArray {
-            _XMLElement.createElement(parentElement: element, key: rootKey, object: object)
+        switch object {
+        case .dictionary(let dictionary):
+            _XMLElement.modifyElement(element: element, parentElement: nil, key: nil, values: dictionary)
+        case .array(let array):
+            _XMLElement.createElement(parentElement: element, key: rootKey, object: array)
+        default:
+            throw EncodingError.invalidValue(object, EncodingError.Context(codingPath: [], debugDescription: "Top-level encoded as non-root XML fragment."))
         }
         
-        return element
+        return element.toXMLString(with: header, withCDATA: options.stringEncodingStrategy != .deferredToString).data(using: .utf8, allowLossyConversion: true)!
     }
     
-    fileprivate static func createElement(parentElement: _XMLElement?, key: String, object: NSDictionary) {
+    fileprivate static func createElement(parentElement: _XMLElement?, key: String, object: [String: Container]) {
         let element = _XMLElement(key: key)
         
-        modifyElement(element: element, parentElement: parentElement, key: key, object: object)
+        modifyElement(element: element, parentElement: parentElement, key: key, values: object)
     }
     
-    fileprivate static func modifyElement(element: _XMLElement, parentElement: _XMLElement?, key: String?, object: NSDictionary) {
-        element.attributes = (object[_XMLElement.attributesKey] as? [String: Any])?.mapValues({ String(describing: $0) }) ?? [:]
+    private static func modifyContainerElement(container: Container, element: _XMLElement, key: String) {
+        switch container {
+        case .dictionary(let values):
+            _XMLElement.createElement(parentElement: element, key: key, object: values)
+        case .array(let values):
+            _XMLElement.createElement(parentElement: element, key: key, object: values)
+        case .boolean(let value):
+            _XMLElement.createElement(parentElement: element, key: key, value: value)
+        case .string(let value):
+            _XMLElement.createElement(parentElement: element, key: key, value: value)
+        case .int64(let value):
+            _XMLElement.createElement(parentElement: element, key: key, value: value)
+        case .uint64(let value):
+            _XMLElement.createElement(parentElement: element, key: key, value: value)
+        case .double(let value):
+            _XMLElement.createElement(parentElement: element, key: key, value: value)
+        case .null:
+            _XMLElement.createNullElement(parentElement: element, key: key)
+        }
+    }
+    
+    private static func modifyElement(element: _XMLElement, parentElement: _XMLElement?, key: String?, values: [String: Container]) {
+        if let attributesContainer = values[_XMLElement.attributesKey], case let .dictionary(attributes) = attributesContainer {
+            element.attributes = attributes.mapValues({ String(describing: $0) })
+        }
         
-        let objects: [(String, NSObject)] = object.compactMap({
-            guard let key = $0 as? String, let value = $1 as? NSObject, key != _XMLElement.attributesKey else { return nil }
+        let filteredValues: [(String, Container)] = values.compactMap({
+            guard $0 != _XMLElement.attributesKey else { return nil }
             
-            return (key, value)
+            return ($0, $1)
         })
         
-        for (key, value) in objects {
-            if let dict = value as? NSDictionary {
-                _XMLElement.createElement(parentElement: element, key: key, object: dict)
-            } else if let array = value as? NSArray {
-                _XMLElement.createElement(parentElement: element, key: key, object: array)
-            } else if let string = value as? NSString {
-                _XMLElement.createElement(parentElement: element, key: key, object: string)
-            } else if let number = value as? NSNumber {
-                _XMLElement.createElement(parentElement: element, key: key, object: number)
-            } else {
-                _XMLElement.createElement(parentElement: element, key: key, object: NSNull())
-            }
+        for (key, value) in filteredValues {
+            modifyContainerElement(container: value, element: element, key: key)
         }
         
         if let parentElement = parentElement, let key = key {
             parentElement.children[key] = (parentElement.children[key] ?? []) + [element]
         }
     }
     
-    fileprivate static func createElement(parentElement: _XMLElement, key: String, object: NSArray) {
-        let objects = object.compactMap({ $0 as? NSObject })
-        objects.forEach({
-            if let dict = $0 as? NSDictionary {
-                _XMLElement.createElement(parentElement: parentElement, key: key, object: dict)
-            } else if let array = $0 as? NSArray {
-                _XMLElement.createElement(parentElement: parentElement, key: key, object: array)
-            } else if let string = $0 as? NSString {
-                _XMLElement.createElement(parentElement: parentElement, key: key, object: string)
-            } else if let number = $0 as? NSNumber {
-                _XMLElement.createElement(parentElement: parentElement, key: key, object: number)
-            } else {
-                _XMLElement.createElement(parentElement: parentElement, key: key, object: NSNull())
-            }
+    fileprivate static func createElement(parentElement: _XMLElement, key: String, object: [Container]) {
+        object.forEach({
+            modifyContainerElement(container: $0, element: parentElement, key: key)
         })
     }
-    
-    fileprivate static func createElement(parentElement: _XMLElement, key: String, object: NSNumber) {
-        let element = _XMLElement(key: key, value: object.description)
-        parentElement.children[key] = (parentElement.children[key] ?? []) + [element]
-    }
-    
-    fileprivate static func createElement(parentElement: _XMLElement, key: String, object: NSString) {
-        let element = _XMLElement(key: key, value: object.description)
+
+    fileprivate static func createElement(parentElement: _XMLElement, key: String, value: CustomStringConvertible) {
+        let element = _XMLElement(key: key, value: value.description)
         parentElement.children[key] = (parentElement.children[key] ?? []) + [element]
     }
     
-    fileprivate static func createElement(parentElement: _XMLElement, key: String, object: NSNull) {
+    fileprivate static func createNullElement(parentElement: _XMLElement, key: String) {
         let element = _XMLElement(key: key)
         parentElement.children[key] = (parentElement.children[key] ?? []) + [element]
     }
diff --git a/Tests/XMLCodingTests/XMLParsingTests.swift b/Tests/XMLCodingTests/XMLParsingTests.swift

Original file line number	Diff line number	Diff line change
`@@ -24,3 +24,4 @@ pipeline {`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`	`}`
	`27`	`+`