Introduce PathException for JsonPatch

This exception is thrown in JsonPatch::apply whenever a JsonPointer
call fails.

Author: Silvan-WMDE

src/JsonPatch.php

@@ -61,7 +61,7 @@ public static function import(array $data)
             }
 
             if (!is_object($operation)) {
-                throw new Exception( 'Invalid patch operation - should be a JSON object' );
+                throw new Exception('Invalid patch operation - should be a JSON object');
             }
 
             if (!isset($operation->op)) {
@@ -145,20 +145,26 @@ public function apply(&$original, $stopOnError = true)
         $errors = array();
         foreach ($this->operations as $operation) {
             try {
+                // track the current pointer field so we can use it for a potential PathException
+                $pointerField = 'path';
                 $pathItems = JsonPointer::splitPath($operation->path);
                 switch (true) {
                     case $operation instanceof Add:
                         JsonPointer::add($original, $pathItems, $operation->value, $this->flags);
                         break;
                     case $operation instanceof Copy:
+                        $pointerField = 'from';
                         $fromItems = JsonPointer::splitPath($operation->from);
                         $value = JsonPointer::get($original, $fromItems);
+                        $pointerField = 'path';
                         JsonPointer::add($original, $pathItems, $value, $this->flags);
                         break;
                     case $operation instanceof Move:
+                        $pointerField = 'from';
                         $fromItems = JsonPointer::splitPath($operation->from);
                         $value = JsonPointer::get($original, $fromItems);
                         JsonPointer::remove($original, $fromItems, $this->flags);
+                        $pointerField = 'path';
                         JsonPointer::add($original, $pathItems, $value, $this->flags);
                         break;
                     case $operation instanceof Remove:
@@ -178,6 +184,18 @@ public function apply(&$original, $stopOnError = true)
                         }
                         break;
                 }
+            } catch (JsonPointerException $jsonPointerException) {
+                $pathException = new PathException(
+                    $jsonPointerException->getMessage(),
+                    $operation,
+                    $pointerField,
+                    $jsonPointerException->getCode()
+                );
+                if ($stopOnError) {
+                    throw $pathException;
+                } else {
+                    $errors[] = $pathException;
+                }
             } catch (Exception $exception) {
                 if ($stopOnError) {
                     throw $exception;

src/PathException.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace Swaggest\JsonDiff;
+
+
+use Throwable;
+
+class PathException extends Exception
+{
+    /** @var object */
+    private $operation;
+
+    /** @var string */
+    private $field;
+
+    /**
+     * @param string $message
+     * @param object $operation
+     * @param string $field
+     * @param int $code
+     * @param Throwable|null $previous
+     */
+    public function __construct(
+        $message,
+        $operation,
+        $field,
+        $code = 0,
+        Throwable $previous = null
+    )
+    {
+        parent::__construct($message, $code, $previous);
+        $this->operation = $operation;
+        $this->field = $field;
+    }
+
+    /**
+     * @return object
+     */
+    public function getOperation()
+    {
+        return $this->operation;
+    }
+
+    /**
+     * @return string
+     */
+    public function getField()
+    {
+        return $this->field;
+    }
+}

tests/src/JsonPatchTest.php

@@ -5,8 +5,10 @@
 use Swaggest\JsonDiff\Exception;
 use Swaggest\JsonDiff\JsonDiff;
 use Swaggest\JsonDiff\JsonPatch;
+use Swaggest\JsonDiff\JsonPatch\OpPath;
 use Swaggest\JsonDiff\MissingFieldException;
 use Swaggest\JsonDiff\PatchTestOperationFailedException;
+use Swaggest\JsonDiff\PathException;
 use Swaggest\JsonDiff\UnknownOperationException;
 
 class JsonPatchTest extends \PHPUnit_Framework_TestCase
@@ -174,4 +176,88 @@ public function testTestOperationFailed()
         $this->assertSame($actualValue, $testError->getActualValue());
     }
 
+    public function testPathExceptionContinueOnError()
+    {
+        $actualValue = 'xyz';
+        $data = array('abc' => $actualValue);
+        $patch = new JsonPatch();
+
+        $operation1 = new JsonPatch\Test('/abc', 'def');
+        $patch->op($operation1);
+
+        $operation2 = new JsonPatch\Move('/target', '/source');
+        $patch->op($operation2);
+
+        $errors = $patch->apply($data, false);
+
+        $this->assertInstanceOf(PatchTestOperationFailedException::class, $errors[0]);
+        $this->assertSame($operation1, $errors[0]->getOperation());
+
+        $this->assertInstanceOf(PathException::class, $errors[1]);
+        $this->assertSame($operation2, $errors[1]->getOperation());
+        $this->assertSame('from', $errors[1]->getField());
+    }
+
+    public function pathExceptionProvider() {
+        return [
+            'splitPath_path' => [
+                new JsonPatch\Copy('invalid/path', '/valid/from'),
+                'Path must start with "/": invalid/path',
+                'path'
+            ],
+            'splitPath_from' => [
+                new JsonPatch\Copy('/valid/path', 'invalid/from'),
+                'Path must start with "/": invalid/from',
+                'from'
+            ],
+            'add' => [
+                new JsonPatch\Add('/some/path', 22),
+                'Non-existent path item: some',
+                'path'
+            ],
+            'get_from' => [
+                new JsonPatch\Copy('/target', '/source'),
+                'Key not found: source',
+                'from'
+            ],
+            'get_path' => [
+                new JsonPatch\Replace('/some/path', 23),
+                'Key not found: some',
+                'path'
+            ],
+            'remove_from' => [
+                new JsonPatch\Move('/target', '/source'),
+                'Key not found: source',
+                'from'
+            ],
+            'remove_path' => [
+                new JsonPatch\Remove('/some/path'),
+                'Key not found: some',
+                'path'
+            ]
+        ];
+    }
+
+    /**
+     * @param OpPath $operation
+     * @param string $expectedMessage
+     * @param string $expectedField
+     *
+     * @dataProvider pathExceptionProvider
+     */
+    public function testPathException(OpPath $operation, $expectedMessage, $expectedField) {
+        $data = new \stdClass();
+        $patch = new JsonPatch();
+
+        $patch->op($operation);
+
+        try {
+            $patch->apply($data );
+            $this->fail('PathException expected');
+        } catch (Exception $ex) {
+            $this->assertInstanceOf(PathException::class, $ex);
+            $this->assertEquals($expectedMessage, $ex->getMessage());
+            $this->assertEquals($expectedField, $ex->getField());
+        }
+    }
 }