Merge pull request raymccrae#2 from ChiellieNL/master

Ignore non existent values

Author: raymccrae

JSONPatch.xcodeproj/project.pbxproj

@@ -31,6 +31,7 @@
 		4DDA51EB219AAD8D00BA7704 /* NSArray+DeepCopy.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4DDA51EA219AAD8D00BA7704 /* NSArray+DeepCopy.swift */; };
 		4DDA51ED219AADE000BA7704 /* NSDictionary+DeepCopy.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4DDA51EC219AADE000BA7704 /* NSDictionary+DeepCopy.swift */; };
 		4DF8B18621B1C5E700CAABEE /* JSONPatchGenerator.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4DF8B18521B1C5E700CAABEE /* JSONPatchGenerator.swift */; };
+		CC4BF61423DB0BD100485D08 /* JSONCodableTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = CC4BF61323DB0BD100485D08 /* JSONCodableTests.swift */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
@@ -82,6 +83,7 @@
 		4DDA51EA219AAD8D00BA7704 /* NSArray+DeepCopy.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "NSArray+DeepCopy.swift"; sourceTree = "<group>"; };
 		4DDA51EC219AADE000BA7704 /* NSDictionary+DeepCopy.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "NSDictionary+DeepCopy.swift"; sourceTree = "<group>"; };
 		4DF8B18521B1C5E700CAABEE /* JSONPatchGenerator.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSONPatchGenerator.swift; sourceTree = "<group>"; };
+		CC4BF61323DB0BD100485D08 /* JSONCodableTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSONCodableTests.swift; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -141,10 +143,11 @@
 		4D22EB33219879EF00729769 /* JSONPatchTests */ = {
 			isa = PBXGroup;
 			children = (
+				4D5242CF21CD6F8100030720 /* ArrayTests.swift */,
 				4D471D9221A3545900E43468 /* Bundle.swift */,
 				4D452743219B60A2002637CF /* extra.json */,
 				4D22EB36219879EF00729769 /* Info.plist */,
-				4D5242CF21CD6F8100030720 /* ArrayTests.swift */,
+				CC4BF61323DB0BD100485D08 /* JSONCodableTests.swift */,
 				4D305DBC21A020F800CE9C84 /* JSONElementTests.swift */,
 				4D7E4D0621A6063800BFE359 /* JSONFileTestCase.swift */,
 				4D093AFE21B42A7B0097F14B /* JSONPatchGeneratorTests.swift */,
@@ -288,6 +291,7 @@
 				4D5242D021CD6F8100030720 /* ArrayTests.swift in Sources */,
 				4D0AF308219885A400E7F86B /* JSONPointerTests.swift in Sources */,
 				4D7E4D0921A60F2D00BFE359 /* TestFileTestCase.swift in Sources */,
+				CC4BF61423DB0BD100485D08 /* JSONCodableTests.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};

Sources/JSONPatch/JSONElement.swift

@@ -435,20 +435,29 @@ extension JSONElement {
     ///
     /// - Parameters:
     ///   - operation: The operation to apply.
-    public mutating func apply(_ operation: JSONPatch.Operation) throws {
-        switch operation {
-        case let .add(path, value):
-            try add(value: value, to: path)
-        case let .remove(path):
-            try remove(at: path)
-        case let .replace(path, value):
-            try replace(value: value, to: path)
-        case let .move(from, path):
-            try move(from: from, to: path)
-        case let .copy(from, path):
-            try copy(from: from, to: path)
-        case let .test(path, value):
-            try test(value: value, at: path)
+    public mutating func apply(_ operation: JSONPatch.Operation, ignoreNonexistentValues: Bool = false) throws {
+        do {
+            switch operation {
+            case let .add(path, value):
+                try add(value: value, to: path)
+            case let .remove(path):
+                try remove(at: path)
+            case let .replace(path, value):
+                try replace(value: value, to: path)
+            case let .move(from, path):
+                try move(from: from, to: path)
+            case let .copy(from, path):
+                try copy(from: from, to: path)
+            case let .test(path, value):
+                try test(value: value, at: path)
+            }
+        } catch {
+            if let error = error as? JSONError,
+                error == .referencesNonexistentValue && ignoreNonexistentValues {
+                // Don't throw, just continue
+            } else {
+                throw error
+            }
         }
     }
 
@@ -459,15 +468,15 @@ extension JSONElement {
     /// - Parameters:
     ///   - patch: The json-patch to be applied.
     ///   - path:  If present then the patch is applied to the child element at the path.
-    public mutating func apply(patch: JSONPatch, relativeTo path: JSONPointer? = nil) throws {
+    public mutating func apply(patch: JSONPatch, relativeTo path: JSONPointer? = nil, ignoreNonexistentValues: Bool = false) throws {
         if let path = path, let parent = path.parent {
             var parentElement = try makePathMutable(parent)
             var relativeRoot = try parentElement.value(for: path.lastComponent!)
-            try relativeRoot.apply(patch: patch)
+            try relativeRoot.apply(patch: patch, ignoreNonexistentValues: ignoreNonexistentValues)
             try parentElement.setValue(relativeRoot, component: path.lastComponent!, replace: true)
         } else {
             for operation in patch.operations {
-                try apply(operation)
+                try apply(operation, ignoreNonexistentValues: ignoreNonexistentValues)
             }
         }
     }

Sources/JSONPatch/JSONError.swift

@@ -29,3 +29,48 @@ public enum JSONError: Error {
     case missingRequiredPatchField(op: String, index: Int, field: String)
     case patchTestFailed(path: String, expected: Any, found: Any?)
 }
+
+extension JSONError: Equatable {
+    public static func ==(lhs: JSONError, rhs: JSONError) -> Bool {
+        switch lhs {
+        case .invalidObjectType:
+            if case .invalidObjectType = rhs {
+                return true
+            }
+            
+        case .invalidPointerSyntax:
+            if case .invalidPointerSyntax = rhs {
+                return true
+            }
+            
+        case .invalidPatchFormat:
+            if case .invalidPatchFormat = rhs {
+                return true
+            }
+            
+        case .referencesNonexistentValue:
+            if case .referencesNonexistentValue = rhs {
+                return true
+            }
+            
+        case .unknownPatchOperation:
+            if case .unknownPatchOperation = rhs {
+                return true
+            }
+            
+        case .missingRequiredPatchField(let op1, let index1, let field1):
+            if case .missingRequiredPatchField(let op2, let index2, let field2) = rhs,
+                op1 == op2 && index1 == index2 && field1 == field2 {
+                return true
+            }
+            
+        case .patchTestFailed(let path1, _, _):
+            if case .patchTestFailed(let path2, _, _) = rhs,
+                path1 == path2 {
+                return true
+            }
+        }
+        
+        return false
+    }
+}

Sources/JSONPatch/JSONPatch.swift

@@ -28,6 +28,13 @@ import Foundation
 /// https://tools.ietf.org/html/rfc6902
 public class JSONPatch: Codable {
 
+    /**
+     Default setting for ignoring non existent values (Default: false)
+     
+     When set to true, all JSONError.referencesNonexistentValue errors will be ignored
+     */
+    public static var ignoreNonexistentValues: Bool = false
+    
     /// The mimetype for json-patch
     public static let mimetype = "application/json-patch+json"
 
@@ -128,15 +135,17 @@ public class JSONPatch: Codable {
     ///              a patch inplace the result is not atomic, if an error occurs then the
     ///              json object may be left in a partial state. If false then a copy of
     ///              the json document is created and the patch applied to the copy.
+    ///   - ignoreNonexistentValues: if true, all references to non existent values will be ignored and the patch will continue applying all remaining operations
     /// - Returns: A transformed json document with the patch applied.
     public func apply(to jsonObject: Any,
                       relativeTo path: JSONPointer? = nil,
-                      inplace: Bool = true) throws -> Any {
+                      inplace: Bool = true,
+                      ignoreNonexistentValues: Bool = JSONPatch.ignoreNonexistentValues) throws -> Any {
         var jsonDocument = try JSONElement(any: jsonObject)
         if !inplace {
             jsonDocument = jsonDocument.copy()
         }
-        try jsonDocument.apply(patch: self, relativeTo: path)
+        try jsonDocument.apply(patch: self, relativeTo: path, ignoreNonexistentValues: ignoreNonexistentValues)
         return jsonDocument.rawValue
     }
 
@@ -151,15 +160,17 @@ public class JSONPatch: Codable {
     ///           If nil then the patch is applied directly to the whole json document.
     ///   - readingOptions: The options given to JSONSerialization to parse the json data.
     ///   - writingOptions: The options given to JSONSerialization to write the result to data.
+    ///   - ignoreNonexistentValues: if true, all references to non existent values will be ignored and the patch will continue applying all remaining operations
     /// - Returns: The transformed json document as data.
     public func apply(to data: Data,
                       relativeTo path: JSONPointer? = nil,
                       readingOptions: JSONSerialization.ReadingOptions = [.mutableContainers],
-                      writingOptions: JSONSerialization.WritingOptions = []) throws -> Data {
+                      writingOptions: JSONSerialization.WritingOptions = [],
+                      ignoreNonexistentValues: Bool = JSONPatch.ignoreNonexistentValues) throws -> Data {
         let jsonObject = try JSONSerialization.jsonObject(with: data,
                                                           options: readingOptions)
         var jsonElement = try JSONElement(any: jsonObject)
-        try jsonElement.apply(patch: self, relativeTo: path)
+        try jsonElement.apply(patch: self, relativeTo: path, ignoreNonexistentValues: ignoreNonexistentValues)
         let transformedData = try JSONSerialization.data(with: jsonElement,
                                                          options: writingOptions)
         return transformedData
@@ -301,3 +312,63 @@ extension JSONPatch: Equatable {
     }
 
 }
+
+// MARK: - Patch Codable
+
+public extension JSONPatch {
+    /**
+     Applies this patch on the specified Codable object
+
+     The originated object won't be changed, a new object will be returned with this patch applied on it
+
+     e.g.
+
+     ```swift
+     let patch = ... // get your JSONPatch from somewhere
+
+     let patchedDevice = try! patch.applied(to: self.device)
+     ```
+
+     - parameter object: The object to apply the patch on
+
+     - returns: A new object with the applied patch
+     */
+    func applied<T: Codable>(to object: T) throws -> T {
+        let data = try JSONEncoder().encode(object)
+        let patchedData = try self.apply(to: data)
+
+        return try JSONDecoder().decode(T.self, from: patchedData)
+    }
+
+    /**
+     Creates a patch from the source object to the target object
+
+     - note:
+     Generic use case would be that the `from` object is **an older** version of the `to` object.
+
+     e.g.:
+
+     ```swift
+     self.device.state.isPowered = false
+     var lastSent: Device = IOManager.send(self.device)
+
+     self.device.state.isPowered = true
+
+     let patch = try JSONPatch.createPatch(from: lastSent, to: self.device)
+
+     // Patch will now be a patch that changes
+     // the state's `isPowered` from false to true
+     ```
+
+     - parameter source: The source object
+     - parameter target: The target object
+
+     - returns: The JSONPatch to get from the source to the target object
+     */
+    static func createPatch<T: Codable>(from source: T, to target: T) throws -> JSONPatch {
+        let sourceData = try JSONEncoder().encode(source)
+        let targetData = try JSONEncoder().encode(target)
+
+        return try JSONPatch(source: sourceData, target: targetData)
+    }
+}

Sources/JSONPatch/JSONPointer.swift

@@ -178,8 +178,8 @@ extension JSONPointer: Equatable {
 }
 
 extension JSONPointer: Hashable {
-    public var hashValue: Int {
-        return components.hashValue
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(components)
     }
 }
 

Tests/JSONPatchTests/JSONCodableTests.swift

@@ -0,0 +1,59 @@
+//
+//  JSONPatchTests.swift
+//  JSONPatchTests
+//
+//  Created by Michiel Horvers on 01/24/2020.
+//  Copyright © 2020 Michiel Horvers.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import XCTest
+@testable import JSONPatch
+
+fileprivate struct Person: Codable {
+    var firstName: String
+    var lastName: String
+    var age: Int
+}
+
+class JSONCodableTests: XCTestCase {
+    
+    func testCreatePatch() throws {
+        let source = Person(firstName: "Michiel", lastName: "Horvers", age: 99)
+        let target = Person(firstName: "Michiel", lastName: "Horvers", age: 100)
+        
+        let patch = try JSONPatch.createPatch(from: source, to: target)
+        XCTAssert(patch.operations.count == 1, "Patch should have only 1 operation, but has \(patch.operations.count)")
+        
+        guard patch.operations.count == 1 else { return }
+        let dict = patch.operations[0].jsonObject
+        
+        XCTAssert((dict["op"] as? String) == "replace", "Operation should be 'replace', but is: \(String(describing: dict["op"]))")
+        XCTAssert((dict["path"] as? String) == "/age", "Path should be 'age', but is: \(String(describing: dict["path"]))")
+        XCTAssert((dict["value"] as? Int) == 100, "Value should be 100, but is: \(String(describing: dict["value"]))")
+    }
+    
+    func testApplyPatch() throws {
+        let person = Person(firstName: "Michiel", lastName: "Horvers", age: 99)
+        let patchData = Data("""
+        [
+            { "op": "replace", "path": "/age", "value": 100 }
+        ]
+        """.utf8)
+        let patch = try JSONDecoder().decode(JSONPatch.self, from: patchData)
+        
+        let patchedPerson = try patch.applied(to: person)
+        XCTAssert(patchedPerson.age == 100, "Age should be patchd to 100, but is: \(patchedPerson.age)")
+    }
+}