chore: run linter

arg2009 · arg2009 · commit 25c4be8a66fc · 2023-05-05T13:57:41.000+10:00
diff --git a/src/Actions/AddAdditionsToJsonDiffAction.php b/src/Actions/AddAdditionsToJsonDiffAction.php
@@ -30,20 +30,16 @@ public function __construct(
 
     /**
      * @param Collection<DiffMapping> $diffMappings
-     * @param array $new
-     * @param JsonDiff $jsonDiff
-     * @param string $path
-     * @return JsonDiff
      */
     public function execute(Collection $diffMappings, array $new, JsonDiff $jsonDiff, string $path): JsonDiff
     {
         $this
             ->getUnmappedNewIndexesAction
             ->execute($diffMappings, $new)
-            ->each(function (int $newKey) use ($path, $new, $jsonDiff) {
+            ->each(function (int $newKey) use ($path, $new, $jsonDiff): void {
                 $jsonDiff->addAddedKey($this->getItemPathAction->execute($path, $newKey), $newKey, $new[$newKey]);
             });
 
         return $jsonDiff;
     }
-}
+}
diff --git a/src/Actions/AddRemovalsToJsonDiffAction.php b/src/Actions/AddRemovalsToJsonDiffAction.php
@@ -32,10 +32,10 @@ public function execute(Collection $diffMappings, array $original, JsonDiff $jso
         $this
             ->getUnmappedOriginalIndexesAction
             ->execute($diffMappings, $original)
-            ->each(function (int $originalKey) use ($original, $path, $jsonDiff) {
+            ->each(function (int $originalKey) use ($original, $path, $jsonDiff): void {
                 $jsonDiff->addRemovedKey($this->getItemPathAction->execute($path, $originalKey), $originalKey, $original[$originalKey]);
             });
 
         return $jsonDiff;
     }
-}
+}
diff --git a/src/Actions/CalculateAllDifferencesRespectiveToOriginalAction.php b/src/Actions/CalculateAllDifferencesRespectiveToOriginalAction.php
@@ -32,6 +32,7 @@ public function execute(array $original, array $new, string $path): Collection
 
         foreach ($original as $originalIndex => $originalValue) {
             $diffs = collect();
+
             foreach ($new as $newIndex => $newValue) {
                 $diffs->push(
                     new DiffMapping(
diff --git a/src/Actions/CalculateMinimalDiffOfListArrayAction.php b/src/Actions/CalculateMinimalDiffOfListArrayAction.php
@@ -4,8 +4,6 @@
 
 namespace Jet\JsonDiff\Actions;
 
-use Illuminate\Support\Collection;
-use Jet\JsonDiff\DiffMapping;
 use Jet\JsonDiff\JsonDiff;
 
 class CalculateMinimalDiffOfListArrayAction
@@ -106,4 +104,4 @@ public function execute(array $original, array $new, string $path): JsonDiff
             ->addRemovalsToJsonDiffAction
             ->execute($diffMappings, $original, $jsonDiff, $path);
     }
-}
+}
diff --git a/src/Actions/GetDiffsFromDiffMappingsAction.php b/src/Actions/GetDiffsFromDiffMappingsAction.php
@@ -11,18 +11,17 @@ class GetDiffsFromDiffMappingsAction
 {
     /**
      * @param Collection<DiffMapping> $diffMappings
-     * @return Collection
      */
     public function execute(Collection $diffMappings): Collection
     {
         $jsonDiffs = collect();
         $diffMappings
-            ->each(function (?DiffMapping $diffMapping) use (&$jsonDiffs) {
+            ->each(function (?DiffMapping $diffMapping) use (&$jsonDiffs): void {
                 if ($diffMapping) {
                     $jsonDiffs->push($diffMapping->getDiff());
                 }
             });
 
         return $jsonDiffs;
     }
-}
+}
diff --git a/src/Actions/GetItemPathAction.php b/src/Actions/GetItemPathAction.php
@@ -7,12 +7,10 @@
 class GetItemPathAction
 {
     /**
-     * @param string $currentPath
-     * @param string|int $key
-     * @return string
+     * @param int|string $key
      */
     public function execute(string $currentPath, $key): string
     {
         return "{$currentPath}{$key}";
     }
-}
+}
diff --git a/src/Actions/GetSortedOriginalDiffMappingsAction.php b/src/Actions/GetSortedOriginalDiffMappingsAction.php
@@ -6,12 +6,12 @@
 
 use Illuminate\Support\Collection;
 use Jet\JsonDiff\DiffMapping;
+use function count;
 
 class GetSortedOriginalDiffMappingsAction
 {
     /**
      * @param Collection<DiffMapping> $diffMappings
-     * @param array $original
      * @return Collection<DiffMapping>
      */
     public function execute(Collection $diffMappings, array $original): Collection
@@ -38,4 +38,4 @@ public function execute(Collection $diffMappings, array $original): Collection
             return $diffsB->first()->getDiff()->getNumberOfChanges() - $diffsA->first()->getDiff()->getNumberOfChanges();
         });
     }
-}
+}
diff --git a/src/Actions/GetTraversingPathAction.php b/src/Actions/GetTraversingPathAction.php
@@ -7,12 +7,10 @@
 class GetTraversingPathAction
 {
     /**
-     * @param string $currentPath
-     * @param string|int $key
-     * @return string
+     * @param int|string $key
      */
     public function execute(string $currentPath, $key): string
     {
         return "{$currentPath}{$key}.";
     }
-}
+}
diff --git a/src/Actions/GetUnmappedNewIndexesAction.php b/src/Actions/GetUnmappedNewIndexesAction.php
@@ -11,7 +11,6 @@ class GetUnmappedNewIndexesAction
 {
     /**
      * @param Collection<DiffMapping> $diffMappings
-     * @param array $new
      * @return Collection<int>
      */
     public function execute(Collection $diffMappings, array $new): Collection
@@ -25,4 +24,4 @@ public function execute(Collection $diffMappings, array $new): Collection
             )
             ->values();
     }
-}
+}
diff --git a/src/Actions/GetUnmappedOriginalIndexesAction.php b/src/Actions/GetUnmappedOriginalIndexesAction.php
@@ -11,7 +11,6 @@ class GetUnmappedOriginalIndexesAction
 {
     /**
      * @param Collection<DiffMapping> $diffMappings
-     * @param array $original
      * @return Collection<int>
      */
     public function execute(Collection $diffMappings, array $original): Collection
@@ -25,4 +24,4 @@ public function execute(Collection $diffMappings, array $original): Collection
             )
             ->values();
     }
-}
+}
diff --git a/src/Actions/MergeDiffsAction.php b/src/Actions/MergeDiffsAction.php
@@ -11,17 +11,16 @@ class MergeDiffsAction
 {
     /**
      * @param Collection<JsonDiff> $diffs
-     * @return JsonDiff
      */
     public function execute(Collection $diffs): JsonDiff
     {
         /** @var JsonDiff $mergedDiff */
         $mergedDiff = $diffs->shift();
         $diffs
-            ->each(function (JsonDiff $diff) use ($mergedDiff) {
+            ->each(function (JsonDiff $diff) use ($mergedDiff): void {
                 $mergedDiff->mergeChanges($diff);
             });
 
         return $mergedDiff;
     }
-}
+}
diff --git a/src/Actions/SelectMinimalOriginalDiffsAction.php b/src/Actions/SelectMinimalOriginalDiffsAction.php
@@ -21,15 +21,15 @@ public function execute(Collection $diffs): Collection
         do {
             $addedMapping = false;
 
-            $diffs->each(function (Collection $diffMappings) use (&$originalToNewIndexMapping, &$keysProcessedInNewArray, &$addedMapping) {
-                $diffMappings->each(function (DiffMapping $diffMapping) use (&$originalToNewIndexMapping, &$keysProcessedInNewArray, &$addedMapping) {
+            $diffs->each(function (Collection $diffMappings) use (&$originalToNewIndexMapping, &$keysProcessedInNewArray, &$addedMapping): void {
+                $diffMappings->each(function (DiffMapping $diffMapping) use (&$originalToNewIndexMapping, &$keysProcessedInNewArray, &$addedMapping): void {
                     // If we find a diff mapping with lesser changes than an existing mapping, replace it
                     if (
-                        $keysProcessedInNewArray->has($diffMapping->getNewIndex()) &&
-                        $diffMapping
+                        $keysProcessedInNewArray->has($diffMapping->getNewIndex())
+                        && $diffMapping
                             ->getDiff()
-                            ->getNumberOfChanges() >=
-                        $keysProcessedInNewArray
+                            ->getNumberOfChanges()
+                        >= $keysProcessedInNewArray
                             ->get($diffMapping->getNewIndex())
                             ->getDiff()
                             ->getNumberOfChanges()
@@ -40,11 +40,11 @@ public function execute(Collection $diffs): Collection
                     // If we have an existing diff mapping to the original index with lesser changes than the current
                     // diff mapping, skip replacing the mapping with the current index
                     if (
-                        $originalToNewIndexMapping->has($diffMapping->getOriginalIndex()) &&
-                        $diffMapping
+                        $originalToNewIndexMapping->has($diffMapping->getOriginalIndex())
+                        && $diffMapping
                             ->getDiff()
-                            ->getNumberOfChanges() >=
-                        $keysProcessedInNewArray
+                            ->getNumberOfChanges()
+                        >= $keysProcessedInNewArray
                             ->get($originalToNewIndexMapping->get($diffMapping->getOriginalIndex()))
                             ->getDiff()
                             ->getNumberOfChanges()
diff --git a/src/Actions/SortKeyDifferencesByNumberOfChangesAction.php b/src/Actions/SortKeyDifferencesByNumberOfChangesAction.php
@@ -29,4 +29,4 @@ public function execute(Collection $diffMappings): Collection
                     ->values();
             });
     }
-}
+}
diff --git a/src/DiffMapping.php b/src/DiffMapping.php
@@ -42,4 +42,4 @@ public function getDiff(): JsonDiff
     {
         return $this->diff;
     }
-}
+}
diff --git a/src/JsonDiff.php b/src/JsonDiff.php
@@ -9,6 +9,7 @@
 use Jet\JsonDiff\Actions\CalculateMinimalDiffOfListArrayAction;
 use Jet\JsonDiff\Actions\GetItemPathAction;
 use Jet\JsonDiff\Actions\GetTraversingPathAction;
+use function is_array;
 
 class JsonDiff
 {
@@ -97,19 +98,19 @@ protected function process(array $original, array $new, string $path = ''): void
         $newKeys = array_keys($new);
 
         $keysAdded = array_diff($newKeys, $originalKeys);
-        collect($keysAdded)->each(function ($key) use ($new, $path) {
+        collect($keysAdded)->each(function ($key) use ($new, $path): void {
             $this->addAddedKey($this->getItemPathAction->execute($path, $key), $key, $new[$key]);
         });
 
         $keysRemoved = array_diff($originalKeys, $newKeys);
-        collect($keysRemoved)->each(function ($key) use ($original, $path) {
+        collect($keysRemoved)->each(function ($key) use ($original, $path): void {
             $this->addRemovedKey($this->getItemPathAction->execute($path, $key), $key, $original[$key]);
         });
 
         $mutualKeys = array_intersect($originalKeys, $newKeys);
         // Check if value has changed
-        collect($mutualKeys)->each(function ($key) use ($new, $original, $path) {
-            // @todo if the value is an object, decide what to do
+        collect($mutualKeys)->each(function ($key) use ($new, $original, $path): void {
+            /** @todo if the value is an object, decide what to do */
             $currentOriginal = $original[$key];
             $currentNew = $new[$key];
 
@@ -124,10 +125,12 @@ protected function process(array $original, array $new, string $path = ''): void
                                 $this->getTraversingPathAction->execute($path, $key)
                             )
                     );
+
                     return;
                 }
 
                 $this->process($currentOriginal, $currentNew, $this->getTraversingPathAction->execute($path, $key));
+
                 return;
             }
 
@@ -140,12 +143,12 @@ protected function process(array $original, array $new, string $path = ''): void
     public function getNumberOfChanges(): int
     {
         return
-            $this->keysAdded->count() +
-            $this->keysRemoved->count() +
-            $this->valuesChanged->count();
+            $this->keysAdded->count()
+            + $this->keysRemoved->count()
+            + $this->valuesChanged->count();
     }
 
-    public function mergeChanges(JsonDiff $jsonDiff): void
+    public function mergeChanges(self $jsonDiff): void
     {
         $this->keysAdded = $this->keysAdded->merge($jsonDiff->getKeysAdded());
         $this->keysRemoved = $this->keysRemoved->merge($jsonDiff->getKeysRemoved());
@@ -155,12 +158,11 @@ public function mergeChanges(JsonDiff $jsonDiff): void
     }
 
     /**
-     * @param string $path
-     * @param string|int $keyName
+     * @param int|string $keyName
      * @param $value
      * @return $this
      */
-    public function addAddedKey(string $path, $keyName, $value): JsonDiff
+    public function addAddedKey(string $path, $keyName, $value): self
     {
         $this->keysAdded->push(new KeyAdded($path, $keyName));
         $this->valuesAdded->push(new ValueAdded($path, $value));
@@ -169,12 +171,11 @@ public function addAddedKey(string $path, $keyName, $value): JsonDiff
     }
 
     /**
-     * @param string $path
-     * @param string|int $name
+     * @param int|string $name
      * @param $value
      * @return $this
      */
-    public function addRemovedKey(string $path, $name, $value): JsonDiff
+    public function addRemovedKey(string $path, $name, $value): self
     {
         $this->keysRemoved->push(new KeyRemoved($path, $name));
         $this->valuesRemoved->push(new ValueRemoved($path, $value));
@@ -207,4 +208,3 @@ public function getValuesChanged(): Collection
         return $this->valuesChanged;
     }
 }
-
diff --git a/src/KeyAdded.php b/src/KeyAdded.php
@@ -12,7 +12,7 @@ class KeyAdded
     private $path;
 
     /**
-     * @var string|int
+     * @var int|string
      */
     private $name;
 
diff --git a/src/KeyRemoved.php b/src/KeyRemoved.php
@@ -11,7 +11,7 @@ class KeyRemoved
      */
     private $path;
     /**
-     * @var string|int
+     * @var int|string
      */
     private $name;
 
diff --git a/src/Support/polyfills.php b/src/Support/polyfills.php
@@ -8,18 +8,20 @@
  */
 
 /**
- * Introduced in PHP 8.1
+ * Introduced in PHP 8.1.
  * @see https://www.php.net/manual/en/function.array-is-list.php
  */
-if (!function_exists("array_is_list")) {
+if (! \function_exists('array_is_list')) {
     function array_is_list(array $array): bool
     {
         $i = 0;
+
         foreach ($array as $k => $v) {
             if ($k !== $i++) {
                 return false;
             }
         }
+
         return true;
     }
-}
+}
diff --git a/tests/Factories/AssociativeArrayFactory.php b/tests/Factories/AssociativeArrayFactory.php
diff --git a/tests/Factories/ListArrayFactory.php b/tests/Factories/ListArrayFactory.php
diff --git a/tests/Factories/SportsArrayFactory.php b/tests/Factories/SportsArrayFactory.php
diff --git a/tests/Feature/JsonDiffTest.php b/tests/Feature/JsonDiffTest.php
diff --git a/tests/Support/polyfills.php b/tests/Support/polyfills.php
diff --git a/tests/Traits/InteractsWithContainer.php b/tests/Traits/InteractsWithContainer.php
diff --git a/tests/Unit/Actions/GetUnmappedNewIndexesActionTest.php b/tests/Unit/Actions/GetUnmappedNewIndexesActionTest.php
diff --git a/tests/Unit/Actions/GetUnmappedOriginalIndexesActionTest.php b/tests/Unit/Actions/GetUnmappedOriginalIndexesActionTest.php

Original file line number	Diff line number	Diff line change
`@@ -11,18 +11,17 @@ class GetDiffsFromDiffMappingsAction`
`11`	`11`	`{`
`12`	`12`	`/**`
`13`	`13`	`* @param Collection<DiffMapping> $diffMappings`
`14`		`- * @return Collection`
`15`	`14`	`*/`
`16`	`15`	`public function execute(Collection $diffMappings): Collection`
`17`	`16`	`{`
`18`	`17`	`$jsonDiffs = collect();`
`19`	`18`	`$diffMappings`
`20`		`- ->each(function (?DiffMapping $diffMapping) use (&$jsonDiffs) {`
	`19`	`+ ->each(function (?DiffMapping $diffMapping) use (&$jsonDiffs): void {`
`21`	`20`	`if ($diffMapping) {`
`22`	`21`	`$jsonDiffs->push($diffMapping->getDiff());`
`23`	`22`	`}`
`24`	`23`	`});`
`25`	`24`
`26`	`25`	`return $jsonDiffs;`
`27`	`26`	`}`
`28`		`-}`
	`27`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -7,12 +7,10 @@`
`7`	`7`	`class GetItemPathAction`
`8`	`8`	`{`
`9`	`9`	`/**`
`10`		`- * @param string $currentPath`
`11`		`- * @param string\|int $key`
`12`		`- * @return string`
	`10`	`+ * @param int\|string $key`
`13`	`11`	`*/`
`14`	`12`	`public function execute(string $currentPath, $key): string`
`15`	`13`	`{`
`16`	`14`	`return "{$currentPath}{$key}";`
`17`	`15`	`}`
`18`		`-}`
	`16`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -7,12 +7,10 @@`
`7`	`7`	`class GetTraversingPathAction`
`8`	`8`	`{`
`9`	`9`	`/**`
`10`		`- * @param string $currentPath`
`11`		`- * @param string\|int $key`
`12`		`- * @return string`
	`10`	`+ * @param int\|string $key`
`13`	`11`	`*/`
`14`	`12`	`public function execute(string $currentPath, $key): string`
`15`	`13`	`{`
`16`	`14`	`return "{$currentPath}{$key}.";`
`17`	`15`	`}`
`18`		`-}`
	`16`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,6 @@ class GetUnmappedNewIndexesAction`
`11`	`11`	`{`
`12`	`12`	`/**`
`13`	`13`	`* @param Collection<DiffMapping> $diffMappings`
`14`		`- * @param array $new`
`15`	`14`	`* @return Collection<int>`
`16`	`15`	`*/`
`17`	`16`	`public function execute(Collection $diffMappings, array $new): Collection`
`@@ -25,4 +24,4 @@ public function execute(Collection $diffMappings, array $new): Collection`
`25`	`24`	`)`
`26`	`25`	`->values();`
`27`	`26`	`}`
`28`		`-}`
	`27`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,6 @@ class GetUnmappedOriginalIndexesAction`
`11`	`11`	`{`
`12`	`12`	`/**`
`13`	`13`	`* @param Collection<DiffMapping> $diffMappings`
`14`		`- * @param array $original`
`15`	`14`	`* @return Collection<int>`
`16`	`15`	`*/`
`17`	`16`	`public function execute(Collection $diffMappings, array $original): Collection`
`@@ -25,4 +24,4 @@ public function execute(Collection $diffMappings, array $original): Collection`
`25`	`24`	`)`
`26`	`25`	`->values();`
`27`	`26`	`}`
`28`		`-}`
	`27`	`+}`