Accessors and JSON pointer package versions updated.

remorhaz · remorhaz · commit 9a2beaed5a8b · 2016-11-11T02:59:21.000+03:00
diff --git a/composer.json b/composer.json
@@ -13,8 +13,8 @@
   ],
   "require": {
     "php": ">=7.0",
-    "remorhaz/php-json-data": "0.1.*",
-    "remorhaz/php-json-pointer": "0.2.*"
+    "remorhaz/php-json-data": "0.2.1",
+    "remorhaz/php-json-pointer": "0.3.0"
   },
   "require-dev": {
     "phpunit/phpunit": "@stable",
diff --git a/src/Patch.php b/src/Patch.php
@@ -2,38 +2,38 @@
 
 namespace Remorhaz\JSON\Patch;
 
-use Remorhaz\JSON\Data\SelectableReaderInterface;
+use Remorhaz\JSON\Data\SelectorInterface;
 use Remorhaz\JSON\Pointer\Pointer;
 
 class Patch
 {
 
-    private $dataReader;
+    private $dataSelector;
 
-    private $patchReader;
+    private $patchSelector;
 
     private $dataPointer;
 
     private $patchPointer;
 
 
-    public function __construct(SelectableReaderInterface $dataReader)
+    public function __construct(SelectorInterface $dataSelector)
     {
-        $this->dataReader = $dataReader;
+        $this->dataSelector = $dataSelector;
     }
 
 
-    public function apply(SelectableReaderInterface $patchReader)
+    public function apply(SelectorInterface $patchSelector)
     {
         $this
-            ->setPatchReader($patchReader)
-            ->getPatchReader()
+            ->setPatchSelector($patchSelector)
+            ->getPatchSelector()
             ->selectRoot();
-        if (!$this->getPatchReader()->isArraySelected()) {
+        if (!$this->getPatchSelector()->isArray()) {
             throw new \RuntimeException("Patch must be an array");
         }
         $operationCount = $this
-            ->getPatchReader()
+            ->getPatchSelector()
             ->getElementCount();
         for ($operationIndex = 0; $operationIndex < $operationCount; $operationIndex++) {
             $this->performOperation($operationIndex);
@@ -42,16 +42,16 @@ public function apply(SelectableReaderInterface $patchReader)
     }
 
 
-    protected function getDataReader(): SelectableReaderInterface
+    protected function getDataSelector(): SelectorInterface
     {
-        return $this->dataReader;
+        return $this->dataSelector;
     }
 
 
     protected function performOperation(int $index)
     {
-        $operation = $this->getPatchPointer()->read("/{$index}/op")->getData();
-        $path = $this->getPatchPointer()->read("/{$index}/path")->getData();
+        $operation = $this->getPatchPointer()->read("/{$index}/op")->getAsString();
+        $path = $this->getPatchPointer()->read("/{$index}/path")->getAsString();
         switch ($operation) {
             case 'add':
                 $valueReader = $this->getPatchPointer()->read("/{$index}/value");
@@ -70,19 +70,19 @@ protected function performOperation(int $index)
             case 'test':
                 $expectedValueReader = $this->getPatchPointer()->read("/{$index}/value");
                 $actualValueReader = $this->getDataPointer()->read($path);
-                if ($expectedValueReader->getData() !== $actualValueReader->getData()) {
+                if ($expectedValueReader->getAsStruct() !== $actualValueReader->getAsStruct()) {
                     throw new \RuntimeException("Test operation failed");
                 }
                 break;
 
             case 'copy':
-                $from = $this->getPatchPointer()->read("/{$index}/from")->getData();
+                $from = $this->getPatchPointer()->read("/{$index}/from")->getAsString();
                 $valueReader = $this->getDataPointer()->read($from);
                 $this->getDataPointer()->add($path, $valueReader);
                 break;
 
             case 'move':
-                $from = $this->getPatchPointer()->read("/{$index}/from")->getData();
+                $from = $this->getPatchPointer()->read("/{$index}/from")->getAsString();
                 $valueReader = $this->getDataPointer()->read($from);
                 $this
                     ->getDataPointer()
@@ -97,26 +97,26 @@ protected function performOperation(int $index)
     }
 
 
-    protected function setPatchReader(SelectableReaderInterface $patchReader)
+    protected function setPatchSelector(SelectorInterface $patchReader)
     {
-        $this->patchReader = $patchReader;
+        $this->patchSelector = $patchReader;
         return $this;
     }
 
 
-    protected function getPatchReader(): SelectableReaderInterface
+    protected function getPatchSelector(): SelectorInterface
     {
-        if (null === $this->patchReader) {
+        if (null === $this->patchSelector) {
             throw new \LogicException("Patch reader is not set");
         }
-        return $this->patchReader;
+        return $this->patchSelector;
     }
 
 
     protected function getPatchPointer(): Pointer
     {
         if (null === $this->patchPointer) {
-            $this->patchPointer = new Pointer($this->getPatchReader());
+            $this->patchPointer = new Pointer($this->getPatchSelector());
         }
         return $this->patchPointer;
     }
@@ -125,7 +125,7 @@ protected function getPatchPointer(): Pointer
     protected function getDataPointer(): Pointer
     {
         if (null === $this->dataPointer) {
-            $this->dataPointer = new Pointer($this->getDataReader());
+            $this->dataPointer = new Pointer($this->getDataSelector());
         }
         return $this->dataPointer;
     }
diff --git a/tests/PatchTest.php b/tests/PatchTest.php
@@ -2,8 +2,8 @@
 
 namespace Remorhaz\JSON\Test\Patch;
 
-use Remorhaz\JSON\Data\RawSelectableReader;
-use Remorhaz\JSON\Data\RawSelectableWriter;
+use Remorhaz\JSON\Data\Reference\Selector;
+use Remorhaz\JSON\Data\Reference\Writer;
 use Remorhaz\JSON\Patch\Patch;
 
 class PatchTest extends \PHPUnit_Framework_TestCase
@@ -18,9 +18,9 @@ class PatchTest extends \PHPUnit_Framework_TestCase
      */
     public function testApply_ValidSpecPatch_Applied($data, array $patchData, $expectedData)
     {
-        $dataWriter = new RawSelectableWriter($data);
-        $patchDataReader = new RawSelectableReader($patchData);
-        (new Patch($dataWriter))->apply($patchDataReader);
+        $dataWriter = new Writer($data);
+        $patchDataSelector = new Selector($patchData);
+        (new Patch($dataWriter))->apply($patchDataSelector);
         $this->assertEquals($expectedData, $data);
     }
 
@@ -55,9 +55,9 @@ public function providerValidSpecPatch_Result(): array
      */
     public function testApply_InvalidSpecPatch_ExceptionThrown($data, array $patchData)
     {
-        $dataWriter = new RawSelectableWriter($data);
-        $patchDataReader = new RawSelectableReader($patchData);
-        (new Patch($dataWriter))->apply($patchDataReader);
+        $dataWriter = new Writer($data);
+        $patchDataSelector = new Selector($patchData);
+        (new Patch($dataWriter))->apply($patchDataSelector);
     }
 
 
@@ -89,9 +89,9 @@ public function providerInvalidSpecPatch(): array
      */
     public function testApply_ValidPatch_Applied($data, array $patchData, $expectedData)
     {
-        $dataWriter = new RawSelectableWriter($data);
-        $patchDataReader = new RawSelectableReader($patchData);
-        (new Patch($dataWriter))->apply($patchDataReader);
+        $dataWriter = new Writer($data);
+        $patchDataSelector = new Selector($patchData);
+        (new Patch($dataWriter))->apply($patchDataSelector);
         $this->assertEquals($expectedData, $data);
     }
 
@@ -125,9 +125,9 @@ public function providerValidPatch_Result(): array
      */
     public function testApply_InvalidPatch_ExceptionThrown($data, array $patchData)
     {
-        $dataWriter = new RawSelectableWriter($data);
-        $patchDataReader = new RawSelectableReader($patchData);
-        (new Patch($dataWriter))->apply($patchDataReader);
+        $dataWriter = new Writer($data);
+        $patchDataSelector = new Selector($patchData);
+        (new Patch($dataWriter))->apply($patchDataSelector);
     }
 
 

Original file line number	Diff line number	Diff line change
`@@ -2,38 +2,38 @@`
`2`	`2`
`3`	`3`	`namespace Remorhaz\JSON\Patch;`
`4`	`4`
`5`		`-use Remorhaz\JSON\Data\SelectableReaderInterface;`
	`5`	`+use Remorhaz\JSON\Data\SelectorInterface;`
`6`	`6`	`use Remorhaz\JSON\Pointer\Pointer;`
`7`	`7`
`8`	`8`	`class Patch`
`9`	`9`	`{`
`10`	`10`
`11`		`- private $dataReader;`
	`11`	`+ private $dataSelector;`
`12`	`12`
`13`		`- private $patchReader;`
	`13`	`+ private $patchSelector;`
`14`	`14`
`15`	`15`	`private $dataPointer;`
`16`	`16`
`17`	`17`	`private $patchPointer;`
`18`	`18`
`19`	`19`
`20`		`- public function __construct(SelectableReaderInterface $dataReader)`
	`20`	`+ public function __construct(SelectorInterface $dataSelector)`
`21`	`21`	`{`
`22`		`- $this->dataReader = $dataReader;`
	`22`	`+ $this->dataSelector = $dataSelector;`
`23`	`23`	`}`
`24`	`24`
`25`	`25`
`26`		`- public function apply(SelectableReaderInterface $patchReader)`
	`26`	`+ public function apply(SelectorInterface $patchSelector)`
`27`	`27`	`{`
`28`	`28`	`$this`
`29`		`- ->setPatchReader($patchReader)`
`30`		`- ->getPatchReader()`
	`29`	`+ ->setPatchSelector($patchSelector)`
	`30`	`+ ->getPatchSelector()`
`31`	`31`	`->selectRoot();`
`32`		`- if (!$this->getPatchReader()->isArraySelected()) {`
	`32`	`+ if (!$this->getPatchSelector()->isArray()) {`
`33`	`33`	`throw new \RuntimeException("Patch must be an array");`
`34`	`34`	`}`
`35`	`35`	`$operationCount = $this`
`36`		`- ->getPatchReader()`
	`36`	`+ ->getPatchSelector()`
`37`	`37`	`->getElementCount();`
`38`	`38`	`for ($operationIndex = 0; $operationIndex < $operationCount; $operationIndex++) {`
`39`	`39`	`$this->performOperation($operationIndex);`
`@@ -42,16 +42,16 @@ public function apply(SelectableReaderInterface $patchReader)`
`42`	`42`	`}`
`43`	`43`
`44`	`44`
`45`		`- protected function getDataReader(): SelectableReaderInterface`
	`45`	`+ protected function getDataSelector(): SelectorInterface`
`46`	`46`	`{`
`47`		`- return $this->dataReader;`
	`47`	`+ return $this->dataSelector;`
`48`	`48`	`}`
`49`	`49`
`50`	`50`
`51`	`51`	`protected function performOperation(int $index)`
`52`	`52`	`{`
`53`		`- $operation = $this->getPatchPointer()->read("/{$index}/op")->getData();`
`54`		`- $path = $this->getPatchPointer()->read("/{$index}/path")->getData();`
	`53`	`+ $operation = $this->getPatchPointer()->read("/{$index}/op")->getAsString();`
	`54`	`+ $path = $this->getPatchPointer()->read("/{$index}/path")->getAsString();`
`55`	`55`	`switch ($operation) {`
`56`	`56`	`case 'add':`
`57`	`57`	`$valueReader = $this->getPatchPointer()->read("/{$index}/value");`
`@@ -70,19 +70,19 @@ protected function performOperation(int $index)`
`70`	`70`	`case 'test':`
`71`	`71`	`$expectedValueReader = $this->getPatchPointer()->read("/{$index}/value");`
`72`	`72`	`$actualValueReader = $this->getDataPointer()->read($path);`
`73`		`- if ($expectedValueReader->getData() !== $actualValueReader->getData()) {`
	`73`	`+ if ($expectedValueReader->getAsStruct() !== $actualValueReader->getAsStruct()) {`
`74`	`74`	`throw new \RuntimeException("Test operation failed");`
`75`	`75`	`}`
`76`	`76`	`break;`
`77`	`77`
`78`	`78`	`case 'copy':`
`79`		`- $from = $this->getPatchPointer()->read("/{$index}/from")->getData();`
	`79`	`+ $from = $this->getPatchPointer()->read("/{$index}/from")->getAsString();`
`80`	`80`	`$valueReader = $this->getDataPointer()->read($from);`
`81`	`81`	`$this->getDataPointer()->add($path, $valueReader);`
`82`	`82`	`break;`
`83`	`83`
`84`	`84`	`case 'move':`
`85`		`- $from = $this->getPatchPointer()->read("/{$index}/from")->getData();`
	`85`	`+ $from = $this->getPatchPointer()->read("/{$index}/from")->getAsString();`
`86`	`86`	`$valueReader = $this->getDataPointer()->read($from);`
`87`	`87`	`$this`
`88`	`88`	`->getDataPointer()`
`@@ -97,26 +97,26 @@ protected function performOperation(int $index)`
`97`	`97`	`}`
`98`	`98`
`99`	`99`
`100`		`- protected function setPatchReader(SelectableReaderInterface $patchReader)`
	`100`	`+ protected function setPatchSelector(SelectorInterface $patchReader)`
`101`	`101`	`{`
`102`		`- $this->patchReader = $patchReader;`
	`102`	`+ $this->patchSelector = $patchReader;`
`103`	`103`	`return $this;`
`104`	`104`	`}`
`105`	`105`
`106`	`106`
`107`		`- protected function getPatchReader(): SelectableReaderInterface`
	`107`	`+ protected function getPatchSelector(): SelectorInterface`
`108`	`108`	`{`
`109`		`- if (null === $this->patchReader) {`
	`109`	`+ if (null === $this->patchSelector) {`
`110`	`110`	`throw new \LogicException("Patch reader is not set");`
`111`	`111`	`}`
`112`		`- return $this->patchReader;`
	`112`	`+ return $this->patchSelector;`
`113`	`113`	`}`
`114`	`114`
`115`	`115`
`116`	`116`	`protected function getPatchPointer(): Pointer`
`117`	`117`	`{`
`118`	`118`	`if (null === $this->patchPointer) {`
`119`		`- $this->patchPointer = new Pointer($this->getPatchReader());`
	`119`	`+ $this->patchPointer = new Pointer($this->getPatchSelector());`
`120`	`120`	`}`
`121`	`121`	`return $this->patchPointer;`
`122`	`122`	`}`
`@@ -125,7 +125,7 @@ protected function getPatchPointer(): Pointer`
`125`	`125`	`protected function getDataPointer(): Pointer`
`126`	`126`	`{`
`127`	`127`	`if (null === $this->dataPointer) {`
`128`		`- $this->dataPointer = new Pointer($this->getDataReader());`
	`128`	`+ $this->dataPointer = new Pointer($this->getDataSelector());`
`129`	`129`	`}`
`130`	`130`	`return $this->dataPointer;`
`131`	`131`	`}`