remove FineJSON dependency (not currently building for Swift 5.4 anyway) by using Yams for all order-dependent testing. add nightly Swift 5.4 CI step.

Author: mattpolzin

Package.resolved

@@ -14,16 +14,15 @@ let package = Package(
             targets: ["OpenAPIKit"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/jpsim/Yams.git", from: "4.0.0"), // just for tests
-        .package(url: "https://github.com/omochi/FineJSON.git", from: "1.14.0") // just for tests
+        .package(url: "https://github.com/jpsim/Yams.git", from: "4.0.0") // just for tests
     ],
     targets: [
         .target(
             name: "OpenAPIKit",
             dependencies: []),
         .testTarget(
             name: "OpenAPIKitTests",
-            dependencies: ["OpenAPIKit", "Yams", "FineJSON"]),
+            dependencies: ["OpenAPIKit", "Yams"]),
         .testTarget(
             name: "OpenAPIKitCompatibilitySuite",
             dependencies: ["OpenAPIKit", "Yams"]),
@@ -35,7 +34,7 @@ let package = Package(
             dependencies: ["OpenAPIKit"]),
         .testTarget(
             name: "OrderedDictionaryTests",
-            dependencies: ["OpenAPIKit", "Yams", "FineJSON"]),
+            dependencies: ["OpenAPIKit", "Yams"]),
         .testTarget(
             name: "AnyCodableTests",
             dependencies: ["OpenAPIKit"])

Package.swift

@@ -76,7 +76,9 @@ You can use this same validation system to dig arbitrarily deep into an OpenAPI
 ### A note on dictionary ordering
 The **Foundation** library's `JSONEncoder` and `JSONDecoder` do not make any guarantees about the ordering of keyed containers. This means decoding a JSON OpenAPI Document and then encoding again might result in the document's various hashed structures being in a different order.
 
-If retaining order is important for your use-case, I recommend the [**Yams**](https://github.com/jpsim/Yams) and [**FineJSON**](https://github.com/omochi/FineJSON) libraries for YAML and JSON respectively.
+If retaining order is important for your use-case, I recommend the [**Yams**](https://github.com/jpsim/Yams) and [**FineJSON**](https://github.com/omochi/FineJSON) libraries for YAML and JSON respectively. Also keep in mind that JSON is entirely valid YAML and therefore you will likely get good results from Yams decoding of JSON as well (it just won't _encode_ as valid JSON). 
+
+The Foundation JSON encoding and decoding will be the most stable and battle-tested option with Yams as a pretty well established and stable option as well. FineJSON is lesser used (to my knowledge) but I have had success with it in the past.
 
 ### OpenAPI Document structure
 The types used by this library largely mirror the object definitions found in the [OpenAPI specification](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md) version 3.0.3. The [Project Status](#project-status) lists each object defined by the spec and the name of the respective type in this library.

README.md

@@ -320,24 +320,17 @@ extension OperationTests {
             ]
         )
 
-        let encodedOperation = String(
-            data: try orderStableEncode(operation),
-            encoding: .utf8
-        )!
+        let encodedOperation = try orderStableYAMLEncode(operation)
 
         XCTAssertEqual(
             encodedOperation,
             """
-            {
-              "responses": {
-                "404": {
-                  "$ref": "#/components/responses/404"
-                },
-                "200": {
-                  "$ref": "#/components/responses/200"
-                }
-              }
-            }
+            responses:
+              404:
+                $ref: '#/components/responses/404'
+              200:
+                $ref: '#/components/responses/200'
+
             """
         )
 
@@ -348,24 +341,17 @@ extension OperationTests {
             ]
         )
 
-        let encodedOperation2 = String(
-            data: try orderStableEncode(operation2),
-            encoding: .utf8
-            )!
+        let encodedOperation2 = try orderStableYAMLEncode(operation2)
 
         XCTAssertEqual(
             encodedOperation2,
             """
-            {
-              "responses": {
-                "200": {
-                  "$ref": "#/components/responses/200"
-                },
-                "404": {
-                  "$ref": "#/components/responses/404"
-                }
-              }
-            }
+            responses:
+              200:
+                $ref: '#/components/responses/200'
+              404:
+                $ref: '#/components/responses/404'
+
             """
         )
     }

Tests/OpenAPIKitTests/Operation/OperationTests.swift

@@ -6,7 +6,7 @@
 //
 
 import Foundation
-import FineJSON
+import Yams
 import XCTest
 
 fileprivate let foundationTestEncoder = { () -> JSONEncoder in
@@ -32,12 +32,12 @@ func orderUnstableTestStringFromEncoding<T: Encodable>(of entity: T) throws -> S
     return String(data: try orderUnstableEncode(entity), encoding: .utf8)
 }
 
-fileprivate let fineJSONTestEncoder = { () -> FineJSONEncoder in
-    return FineJSONEncoder()
+fileprivate let yamsTestEncoder = { () -> YAMLEncoder in
+    return YAMLEncoder()
 }()
 
-func orderStableEncode<T: Encodable>(_ value: T) throws -> Data {
-    return try fineJSONTestEncoder.encode(value)
+func orderStableYAMLEncode<T: Encodable>(_ value: T) throws -> String {
+    return try yamsTestEncoder.encode(value)
 }
 
 fileprivate let foundationTestDecoder = { () -> JSONDecoder in
@@ -57,12 +57,12 @@ func orderUnstableDecode<T: Decodable>(_ type: T.Type, from data: Data) throws -
     return try foundationTestDecoder.decode(T.self, from: data)
 }
 
-fileprivate let fineJSONTestDecoder = { () -> FineJSONDecoder in
-    return FineJSONDecoder()
+fileprivate let yamsTestDecoder = { () -> YAMLDecoder in
+    return YAMLDecoder()
 }()
 
 func orderStableDecode<T: Decodable>(_ type: T.Type, from data: Data) throws -> T {
-    return try fineJSONTestDecoder.decode(T.self, from: data)
+    return try yamsTestDecoder.decode(T.self, from: data)
 }
 
 func assertJSONEquivalent(_ str1: String?, _ str2: String?, file: StaticString = #file, line: UInt = #line) {