SWIFT-925 Implement ExtendedJSON Encoder API (#32)

Author: nspektor

Sources/BSON/ExtendedJSONEncoder.swift

@@ -21,9 +21,7 @@ public class ExtendedJSONEncoder {
     public var userInfo: [CodingUserInfoKey: Any] = [:]
 
     /// Initialize an `ExtendedJSONEncoder`.
-    public init() {
-        fatalError("unimplemented")
-    }
+    public init() {}
 
     /// Encodes an instance of the Encodable Type `T` into Data representing canonical or relaxed extended JSON.
     /// The value of `self.mode` will determine which format is used. If it is not set explicitly, relaxed will be used.
@@ -40,6 +38,18 @@ public class ExtendedJSONEncoder {
         // The `BSON` is converted to an instance of the `JSON` enum via the `toRelaxedExtendedJSON`
         // or `toCanonicalExtendedJSON` methods on `BSONValue`s (depending on the `mode`).
         // The `JSON` is then passed through a `JSONEncoder` and outputted as `Data`.
-        fatalError("unimplemented")
+        let encoder = BSONEncoder()
+        encoder.userInfo = self.userInfo
+        let bson: BSON = try encoder.encode(value)
+
+        let json: JSON
+        switch self.mode {
+        case .canonical:
+            json = bson.bsonValue.toCanonicalExtendedJSON()
+        case .relaxed:
+            json = bson.bsonValue.toRelaxedExtendedJSON()
+        }
+
+        return try JSONEncoder().encode(json)
     }
 }

Tests/BSONTests/ExtendedJSONConversionTests.swift

@@ -4,7 +4,70 @@ import Nimble
 import NIO
 import XCTest
 
+extension CodingUserInfoKey {
+    static let barInfo = CodingUserInfoKey(rawValue: "bar")!
+}
+
 open class ExtendedJSONConversionTestCase: BSONTestCase {
+    func testExtendedJSONDecoderAndEncoder() throws {
+        // Setup
+        struct Test: Codable, Equatable {
+            let x: Bool
+            let y: Int32
+            let z: BSONRegularExpression
+        }
+
+        let regexStr = "{\"$regularExpression\":{\"pattern\":\"p\",\"options\":\"i\"}}"
+        let extJSON = "{\"x\":true,\"y\":{\"$numberInt\":\"5\"},\"z\":\(regexStr)}"
+        let data = extJSON.data(using: .utf8)!
+        let regexObj = BSONRegularExpression(pattern: "p", options: "i")
+        let test = Test(x: true, y: 5, z: regexObj)
+
+        // Test canonical encoder
+        let encoder = ExtendedJSONEncoder()
+        encoder.mode = .canonical
+        let encoded: Data = try encoder.encode(test)
+
+        let encodedStr = String(data: encoded, encoding: .utf8)
+        expect(encodedStr).to(contain("\"x\":true"))
+        expect(encodedStr).to(contain("\"y\":{\"$numberInt\":\"5\"}"))
+        expect(encodedStr).to(contain("\"z\":{\"$regularExpression\""))
+        expect(encodedStr).to(contain("\"pattern\":\"p\""))
+        expect(encodedStr).to(contain("\"options\":\"i\""))
+
+        // Test relaxed encoder
+        encoder.mode = .relaxed
+        let relaxedEncoded: Data = try encoder.encode(test)
+        let relaxedEncodedStr = String(data: relaxedEncoded, encoding: .utf8)
+        expect(relaxedEncodedStr).to(contain("\"x\":true"))
+        expect(relaxedEncodedStr).to(contain("\"y\":5"))
+
+        // Test decoder
+        let decoder = ExtendedJSONDecoder()
+        let decoded = try decoder.decode(Test.self, from: data)
+        expect(decoded).to(equal(test))
+    }
+
+    func testExtendedJSONEncodingWithUserInfo() throws {
+        struct Foo: Codable, Equatable {
+            func encode(to encoder: Encoder) throws {
+                let barInfo = encoder.userInfo[.barInfo] as? Bool
+                var container = encoder.singleValueContainer()
+                try container.encode([barInfo])
+            }
+        }
+
+        let encoder = ExtendedJSONEncoder()
+
+        encoder.userInfo[.barInfo] = true
+        let fooBarEncoded = try encoder.encode(Foo())
+        expect(String(data: fooBarEncoded, encoding: .utf8)).to(contain("true"))
+
+        encoder.userInfo[.barInfo] = false
+        let fooEncoded = try encoder.encode(Foo())
+        expect(String(data: fooEncoded, encoding: .utf8)).to(contain("false"))
+    }
+
     func testAnyExtJSON() throws {
         // Success cases
         expect(try BSON(fromExtJSON: "hello", keyPath: [])).to(equal(BSON.string("hello")))
@@ -14,19 +77,6 @@ open class ExtendedJSONConversionTestCase: BSONTestCase {
         expect(document.documentValue!["extra"]).to(equal(.int32(1)))
     }
 
-    func testExtendedJSONDecoder() throws {
-        struct Foo: Decodable, Equatable {
-            let x: Bool
-            let y: Int
-            let z: BSONRegularExpression
-        }
-        let regexStr = "{\"$regularExpression\": {\"pattern\": \"p\", \"options\": \"i\"}}"
-        let regexObj = BSONRegularExpression(pattern: "p", options: "i")
-        let data = "{ \"x\": true, \"y\": { \"$numberInt\": \"5\" }, \"z\": \(regexStr) }".data(using: .utf8)!
-        let decoder = ExtendedJSONDecoder()
-        expect(try decoder.decode(Foo.self, from: data)).to(equal(Foo(x: true, y: 5, z: regexObj)))
-    }
-
     func testObjectId() throws {
         let oid = "5F07445CFBBBBBBBBBFAAAAA"