fix: improve codable's

Sources/ParseSwift/Coding/AnyDecodable.swift

@@ -13,7 +13,7 @@ import Foundation
      let json = """
      {
          "boolean": true,
-         "integer": 1,
+         "integer": 42,
          "double": 3.14159265358979323846,
          "string": "string",
          "array": [1, 2, 3],

Sources/ParseSwift/Coding/AnyEncodable.swift

@@ -12,15 +12,16 @@ import Foundation
 
      let dictionary: [String: AnyEncodable] = [
          "boolean": true,
-         "integer": 1,
+         "integer": 42,
          "double": 3.14159265358979323846,
          "string": "string",
          "array": [1, 2, 3],
          "nested": [
              "a": "alpha",
              "b": "bravo",
              "c": "charlie"
-         ]
+         ],
+         "null": nil
      ]
 
      let encoder = JSONEncoder()
@@ -99,6 +100,8 @@ extension _AnyEncodable {
             try container.encode(array.map { AnyEncodable($0) })
         case let dictionary as [String: Any?]:
             try container.encode(dictionary.mapValues { AnyEncodable($0) })
+        case let encodable as Encodable:
+            try encodable.encode(to: encoder)
         default:
             let context = EncodingError.Context(codingPath: container.codingPath,
                                                 debugDescription: "AnyEncodable value cannot be encoded")

Tests/ParseSwiftTests/AnyCodableTests/AnyCodableTests.swift

@@ -2,6 +2,22 @@ import XCTest
 @testable import ParseSwift
 
 class AnyCodableTests: XCTestCase {
+
+    struct SomeCodable: Codable {
+        var string: String
+        var int: Int
+        var bool: Bool
+        var hasUnderscore: String
+
+        // swiftlint:disable:next nesting
+        enum CodingKeys: String, CodingKey {
+            case string
+            case int
+            case bool
+            case hasUnderscore = "has_underscore"
+        }
+    }
+
     func testJSONDecoding() {
         guard let json = """
         {
@@ -42,17 +58,25 @@ class AnyCodableTests: XCTestCase {
     //Test has objective-c
     #if !os(Linux) && !os(Android) && !os(Windows)
     func testJSONEncoding() {
+
+        let someCodable = AnyCodable(SomeCodable(string: "String",
+                                                 int: 100,
+                                                 bool: true,
+                                                 hasUnderscore: "another string"))
+
         let dictionary: [String: AnyCodable] = [
             "boolean": true,
-            "integer": 1,
+            "integer": 42,
             "double": 3.14159265358979323846,
             "string": "string",
             "array": [1, 2, 3],
             "nested": [
                 "a": "alpha",
                 "b": "bravo",
                 "c": "charlie"
-            ]
+            ],
+            "someCodable": someCodable,
+            "null": nil
         ]
         do {
             let encoder = JSONEncoder()
@@ -64,16 +88,23 @@ class AnyCodableTests: XCTestCase {
             }
             guard let expected = """
             {
-                "boolean": true,
-                "integer": 1,
+                "boolean": 1,
+                "integer": 42,
                 "double": 3.14159265358979323846,
                 "string": "string",
                 "array": [1, 2, 3],
                 "nested": {
                     "a": "alpha",
                     "b": "bravo",
                     "c": "charlie"
-                }
+                },
+                "someCodable": {
+                    "string":"String",
+                    "int":100,
+                    "bool": true,
+                    "has_underscore":"another string"
+                },
+                "null": null
             }
             """.data(using: .utf8) else {
                 XCTFail("Should unrap data to utf8")

Tests/ParseSwiftTests/AnyCodableTests/AnyEncodableTests.swift

@@ -1,22 +1,47 @@
 import XCTest
 @testable import ParseSwift
 
-//Test has objective-c
+// Test has objective-c
 #if !os(Linux) && !os(Android) && !os(Windows)
 class AnyEncodableTests: XCTestCase {
+
+    struct SomeEncodable: Encodable {
+        var string: String
+        var int: Int
+        var bool: Bool
+        var hasUnderscore: String
+
+        // swiftlint:disable:next nesting
+        enum CodingKeys: String, CodingKey {
+            case string
+            case int
+            case bool
+            case hasUnderscore = "has_underscore"
+        }
+    }
+
     func testJSONEncoding() {
+
+        let someEncodable = AnyEncodable(SomeEncodable(string: "String",
+                                                       int: 100,
+                                                       bool: true,
+                                                       hasUnderscore: "another string"))
+
         let dictionary: [String: AnyEncodable] = [
             "boolean": true,
-            "integer": 1,
+            "integer": 42,
             "double": 3.14159265358979323846,
             "string": "string",
             "array": [1, 2, 3],
             "nested": [
                 "a": "alpha",
                 "b": "bravo",
                 "c": "charlie"
-            ]
+            ],
+            "someCodable": someEncodable,
+            "null": nil
         ]
+
         do {
             let encoder = JSONEncoder()
             let json = try encoder.encode(dictionary)
@@ -27,16 +52,23 @@ class AnyEncodableTests: XCTestCase {
             }
             guard let expected = """
             {
-                "boolean": true,
-                "integer": 1,
+                "boolean": 1,
+                "integer": 42,
                 "double": 3.14159265358979323846,
                 "string": "string",
                 "array": [1, 2, 3],
                 "nested": {
                     "a": "alpha",
                     "b": "bravo",
                     "c": "charlie"
-                }
+                },
+                "someCodable": {
+                    "string": "String",
+                    "int": 100,
+                    "bool": true,
+                    "has_underscore": "another string"
+                },
+                "null": null
             }
             """.data(using: .utf8) else {
                 XCTFail("Should unrap data to utf8")
@@ -52,5 +84,104 @@ class AnyEncodableTests: XCTestCase {
             XCTFail(error.localizedDescription)
         }
     }
+
+    func testEncodeNSNumber() throws {
+        let dictionary: [String: NSNumber] = [
+            "boolean": true,
+            "char": -127,
+            "int": -32767,
+            "short": -32767,
+            "long": -2147483647,
+            "longlong": -9223372036854775807,
+            "uchar": 255,
+            "uint": 65535,
+            "ushort": 65535,
+            "ulong": 4294967295,
+            "ulonglong": 18446744073709615,
+            "double": 3.141592653589793
+        ]
+
+        let encoder = JSONEncoder()
+
+        let json = try encoder.encode(AnyEncodable(dictionary))
+        guard let encodedJSONObject = try JSONSerialization.jsonObject(with: json, options: []) as? NSDictionary else {
+            XCTFail("Should have unwrapped")
+            return
+        }
+
+        let expected = """
+        {
+            "boolean": 1,
+            "char": -127,
+            "int": -32767,
+            "short": -32767,
+            "long": -2147483647,
+            "longlong": -9223372036854775807,
+            "uchar": 255,
+            "uint": 65535,
+            "ushort": 65535,
+            "ulong": 4294967295,
+            "ulonglong": 18446744073709615,
+            "double": 3.141592653589793,
+        }
+        """.data(using: .utf8)!
+        // swiftlint:disable:next line_length
+        guard let expectedJSONObject = try JSONSerialization.jsonObject(with: expected, options: []) as? NSDictionary else {
+            XCTFail("Should have unwrapped")
+            return
+        }
+
+        XCTAssertEqual(encodedJSONObject, expectedJSONObject)
+        XCTAssert(encodedJSONObject["boolean"] is Bool)
+
+        XCTAssert(encodedJSONObject["char"] is Int8)
+        XCTAssert(encodedJSONObject["int"] is Int16)
+        XCTAssert(encodedJSONObject["short"] is Int32)
+        XCTAssert(encodedJSONObject["long"] is Int32)
+        XCTAssert(encodedJSONObject["longlong"] is Int64)
+
+        XCTAssert(encodedJSONObject["uchar"] is UInt8)
+        XCTAssert(encodedJSONObject["uint"] is UInt16)
+        XCTAssert(encodedJSONObject["ushort"] is UInt32)
+        XCTAssert(encodedJSONObject["ulong"] is UInt32)
+        XCTAssert(encodedJSONObject["ulonglong"] is UInt64)
+
+        XCTAssert(encodedJSONObject["double"] is Double)
+    }
+
+    func testStringInterpolationEncoding() throws {
+        let dictionary: [String: AnyEncodable] = [
+            "boolean": "\(true)",
+            "integer": "\(42)",
+            "double": "\(3.141592653589793)",
+            "string": "\("string")",
+            "array": "\([1, 2, 3])"
+        ]
+
+        let encoder = JSONEncoder()
+
+        let json = try encoder.encode(dictionary)
+        guard let encodedJSONObject = try JSONSerialization.jsonObject(with: json, options: []) as? NSDictionary else {
+            XCTFail("Should have unwrapped")
+            return
+        }
+
+        let expected = """
+        {
+            "boolean": "true",
+            "integer": "42",
+            "double": "3.141592653589793",
+            "string": "string",
+            "array": "[1, 2, 3]",
+        }
+        """.data(using: .utf8)!
+        // swiftlint:disable:next line_length
+        guard let expectedJSONObject = try JSONSerialization.jsonObject(with: expected, options: []) as? NSDictionary else {
+            XCTFail("Should have unwrapped")
+            return
+        }
+
+        XCTAssertEqual(encodedJSONObject, expectedJSONObject)
+    }
 }
 #endif