SWIFT-918 Extended JSON to BSON Conversion for Int32

Author: nspektor

Sources/BSON/BSONError.swift

@@ -42,6 +42,21 @@ public enum BSONError {
     }
 }
 
+extension DecodingError {
+    /// Standardize the errors emitted by BSONValue initializers.
+    internal static func _extendedJSONError(
+        keyPath: [String],
+        debugDescription: String
+    ) -> DecodingError {
+        let debugStart = keyPath.joined(separator: ".") +
+            (keyPath == [] ? "" : ": ")
+        return .dataCorrupted(DecodingError.Context(
+            codingPath: [],
+            debugDescription: debugStart + debugDescription
+        ))
+    }
+}
+
 /// Standardize the errors emitted from the BSON Iterator.
 /// The BSON iterator is used for validation so this should help debug the underlying incorrect binary.
 internal func BSONIterationError(

Sources/BSON/BSONValue.swift

@@ -14,6 +14,11 @@ internal protocol BSONValue: Codable {
 
     /// Writes this value's BSON byte representation to the provided ByteBuffer.
     func write(to buffer: inout ByteBuffer)
+
+    /// Initializes a corresponding `BSON` from the provided extendedJSON.
+    /// Currently commented out to avoid "not implemented" errors while implementing the
+    /// initializer one by one on each BSONValue.
+    // internal init(fromExtJSON json: JSON) throws
 }
 
 /// Convenience extension to get static bsonType from an instance

Sources/BSON/Integers+BSONValue.swift

@@ -1,6 +1,52 @@
 import NIO
 
 extension Int32: BSONValue {
+    /*
+     * Initializes an `Int32` from ExtendedJSON.
+     *
+     * Parameters:
+     *   - `json`: a `JSON` representing the canonical or relaxed form of ExtendedJSON for an `Int32`.
+     *   - `keyPath`: an array of `String`s containing the enclosing JSON keys of the current json being passed in.
+     *              This is used for error messages.
+     *
+     * Returns:
+     *   - `nil` if the provided value is not an `Int32`.
+     *
+     * Throws:
+     *   - `DecodingError` if `json` is a partial match or is malformed.
+     */
+    internal init?(fromExtJSON json: JSON, keyPath: [String]) throws {
+        switch json {
+        case let .number(n):
+            // relaxed extended JSON
+            guard let int = Int32(exactly: n) else {
+                return nil
+            }
+            self = int
+        case let .object(obj):
+            // canonical extended JSON
+            guard let value = obj["$numberInt"] else {
+                return nil
+            }
+            guard obj.count == 1 else {
+                throw DecodingError._extendedJSONError(
+                    keyPath: keyPath,
+                    debugDescription: "Expected only \"$numberInt\" key, found too many keys: \(obj.keys)"
+                )
+            }
+            guard let str = value.stringValue, let int = Int32(str) else {
+                throw DecodingError._extendedJSONError(
+                    keyPath: keyPath,
+                    debugDescription: "Could not parse `Int32` from \"\(value)\", " +
+                        "input must be a 32-bit signed integer as a string."
+                )
+            }
+            self = int
+        default:
+            return nil
+        }
+    }
+
     internal static var bsonType: BSONType { .int32 }
 
     internal var bson: BSON { .int32(self) }

Tests/BSONTests/ExtendedJSONConversionTests.swift

@@ -0,0 +1,28 @@
+@testable import BSON
+import Foundation
+import Nimble
+import NIO
+import XCTest
+
+open class ExtendedJSONConversionTestCase: BSONTestCase {
+    func testInt32() throws {
+        // Success cases
+        expect(try Int32(fromExtJSON: 5, keyPath: [])).to(equal(5))
+        expect(try Int32(fromExtJSON: ["$numberInt": "5"], keyPath: [])).to(equal(5))
+
+        // Nil cases
+        expect(try Int32(fromExtJSON: JSON.number(Double(Int32.max) + 1), keyPath: [])).to(beNil())
+        expect(try Int32(fromExtJSON: JSON.bool(true), keyPath: [])).to(beNil())
+        expect(try Int32(fromExtJSON: ["bad": "5"], keyPath: [])).to(beNil())
+
+        // Error cases
+        expect(try Int32(fromExtJSON: ["$numberInt": 5], keyPath: []))
+            .to(throwError(errorType: DecodingError.self))
+        expect(try Int32(fromExtJSON: ["$numberInt": "5", "extra": true], keyPath: []))
+            .to(throwError(errorType: DecodingError.self))
+        expect(try Int32(fromExtJSON: ["$numberInt": .string("\(Double(Int32.max) + 1)")], keyPath: ["key", "path"]))
+            .to(throwError(errorType: DecodingError.self))
+    }
+
+    // TODO: Add equivalent tests for each type that conforms to `BSONValue`
+}