SWIFT-916 Implement JSON Enum

Author: nspektor

Sources/BSON/JSON.swift

@@ -0,0 +1,139 @@
+import Foundation
+
+/// Enum representing a JSON value, used internally for modeling JSON
+/// during extendedJSON parsing/generation.
+internal enum JSON: Codable {
+    case number(Double)
+    case string(String)
+    case bool(Bool)
+    indirect case array([JSON])
+    indirect case object([String: JSON])
+    case null
+
+    /// Initialize a `JSON` from a decoder.
+    /// Tries to decode into each of the JSON types one by one until one succeeds or
+    /// throws an error indicating that the input is not a valid `JSON` type.
+    internal init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if let d = try? container.decode(Double.self) {
+            self = .number(d)
+        } else if let s = try? container.decode(String.self) {
+            self = .string(s)
+        } else if let b = try? container.decode(Bool.self) {
+            self = .bool(b)
+        } else if let a = try? container.decode([JSON].self) {
+            self = .array(a)
+        } else if let d = try? container.decode([String: JSON].self) {
+            self = .object(d)
+        } else if container.decodeNil() {
+            self = .null
+        } else {
+            throw DecodingError.dataCorrupted(
+                DecodingError.Context(
+                    codingPath: decoder.codingPath,
+                    debugDescription: "Not a valid JSON type"
+                ))
+        }
+    }
+
+    /// Encode a `JSON` to a container by encoding the type of this `JSON` instance.
+    internal func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case let .number(n):
+            try container.encode(n)
+        case let .string(s):
+            try container.encode(s)
+        case let .bool(b):
+            try container.encode(b)
+        case let .array(a):
+            try container.encode(a)
+        case let .object(o):
+            try container.encode(o)
+        case .null:
+            try container.encodeNil()
+        }
+    }
+}
+
+extension JSON: ExpressibleByFloatLiteral {
+    internal init(floatLiteral value: Double) {
+        self = .number(value)
+    }
+}
+
+extension JSON: ExpressibleByIntegerLiteral {
+    internal init(integerLiteral value: Int) {
+        // The number `JSON` type is a Double, so we cast any integers to doubles.
+        self = .number(Double(value))
+    }
+}
+
+extension JSON: ExpressibleByStringLiteral {
+    internal init(stringLiteral value: String) {
+        self = .string(value)
+    }
+}
+
+extension JSON: ExpressibleByBooleanLiteral {
+    internal init(booleanLiteral value: Bool) {
+        self = .bool(value)
+    }
+}
+
+extension JSON: ExpressibleByArrayLiteral {
+    internal init(arrayLiteral elements: JSON...) {
+        self = .array(elements)
+    }
+}
+
+extension JSON: ExpressibleByDictionaryLiteral {
+    internal init(dictionaryLiteral elements: (String, JSON)...) {
+        self = .object([String: JSON](uniqueKeysWithValues: elements))
+    }
+}
+
+/// Value Getters
+extension JSON {
+    /// If this `JSON` is a `.double`, return it as a `Double`. Otherwise, return nil.
+    internal var doubleValue: Double? {
+        guard case let .number(n) = self else {
+            return nil
+        }
+        return n
+    }
+
+    /// If this `JSON` is a `.string`, return it as a `String`. Otherwise, return nil.
+    internal var stringValue: String? {
+        guard case let .string(s) = self else {
+            return nil
+        }
+        return s
+    }
+
+    /// If this `JSON` is a `.bool`, return it as a `Bool`. Otherwise, return nil.
+    internal var boolValue: Bool? {
+        guard case let .bool(b) = self else {
+            return nil
+        }
+        return b
+    }
+
+    /// If this `JSON` is a `.array`, return it as a `[JSON]`. Otherwise, return nil.
+    internal var arrayValue: [JSON]? {
+        guard case let .array(a) = self else {
+            return nil
+        }
+        return a
+    }
+
+    /// If this `JSON` is a `.object`, return it as a `[String: JSON]`. Otherwise, return nil.
+    internal var objectValue: [String: JSON]? {
+        guard case let .object(o) = self else {
+            return nil
+        }
+        return o
+    }
+}
+
+extension JSON: Equatable {}

Tests/BSONTests/JSONTests.swift

@@ -0,0 +1,72 @@
+@testable import BSON
+import Foundation
+import Nimble
+import NIO
+import XCTest
+
+open class JSONTestCase: XCTestCase {
+    let encoder = JSONEncoder()
+    let decoder = JSONDecoder()
+
+    func testInteger() throws {
+        // Initializing a JSON with an int works, but it will be cast to a double.
+        let intJSON: JSON = 12
+        let encoded = try encoder.encode([intJSON])
+        /* JSONEncoder currently cannot encode non-object/array top level values.
+         To get around this, the generated JSON will need to be wrapped in an array
+         and unwrapped again at the end as a workaround.
+         This workaround can be removed when Swift 5.3 is the minimum supported version by the BSON library. */
+        expect(Double(String(data: encoded.dropFirst().dropLast(), encoding: .utf8)!)!)
+            .to(beCloseTo(12))
+
+        let decoded = try decoder.decode([JSON].self, from: encoded)[0]
+        expect(decoded.doubleValue).to(beCloseTo(intJSON.doubleValue!))
+    }
+
+    func testDouble() throws {
+        let doubleJSON: JSON = 12.3
+        let encoded = try encoder.encode([doubleJSON])
+        expect(Double(String(data: encoded.dropFirst().dropLast(), encoding: .utf8)!)!)
+            .to(beCloseTo(12.3))
+
+        let decoded = try decoder.decode([JSON].self, from: encoded)[0]
+        expect(decoded.doubleValue).to(beCloseTo(doubleJSON.doubleValue!))
+    }
+
+    func testString() throws {
+        let stringJSON: JSON = "I am a String"
+        let encoded = try encoder.encode([stringJSON])
+        expect(String(data: encoded.dropFirst().dropLast(), encoding: .utf8))
+            .to(equal("\"I am a String\""))
+        let decoded = try decoder.decode([JSON].self, from: encoded)[0]
+        expect(decoded).to(equal(stringJSON))
+    }
+
+    func testBool() throws {
+        let boolJSON: JSON = true
+        let encoded = try encoder.encode([boolJSON])
+        expect(String(data: encoded.dropFirst().dropLast(), encoding: .utf8))
+            .to(equal("true"))
+        let decoded = try decoder.decode([JSON].self, from: encoded)[0]
+        expect(decoded).to(equal(boolJSON))
+    }
+
+    func testArray() throws {
+        let arrayJSON: JSON = ["I am a string in an array"]
+        let encoded = try encoder.encode(arrayJSON)
+        let decoded = try decoder.decode(JSON.self, from: encoded)
+        expect(String(data: encoded, encoding: .utf8))
+            .to(equal("[\"I am a string in an array\"]"))
+        expect(decoded).to(equal(arrayJSON))
+    }
+
+    func testObject() throws {
+        let objectJSON: JSON = ["Key": "Value"]
+        let encoded = try encoder.encode(objectJSON)
+        let decoded = try decoder.decode(JSON.self, from: encoded)
+        expect(String(data: encoded, encoding: .utf8))
+            .to(equal("{\"Key\":\"Value\"}"))
+        expect(objectJSON.objectValue!["Key"]!.stringValue!).to(equal("Value"))
+        expect(decoded).to(equal(objectJSON))
+    }
+}