Fix on ConsistencyChecker

mauretto78 · Jan 10, 2018 · f607925 · f607925
1 parent 87b45c0
commit f607925
Show file tree

Hide file tree

Showing 11 changed files with 248 additions and 77 deletions.
diff --git a/README.md b/README.md
@@ -279,14 +279,14 @@ $qb = QueryBuilder::create($array);
 $qb
     ->addCriterion('name as n', 'Ervin Howell')
     ->addCriterion('username as user', 'Antonette')
-    ->addCriterion('address.street as add', 'Victor Plains');
+    ->addCriterion('address.street as street', 'Victor Plains');
 
 foreach ($qb->getResults() as $element){
     // ...
     // now you have
     // $element['n']
     // $element['user']
-    // $element['add']['street']
+    // $element['street']
 }
 ```
 

diff --git a/src/Filters/AbstractFilter.php b/src/Filters/AbstractFilter.php
@@ -12,7 +12,7 @@
 
 use ArrayQuery\Constants;
 use ArrayQuery\Exceptions\NotValidKeyElementInArrayException;
-use ArrayQuery\Helpers\ArrayConverter;
+use ArrayQuery\Helpers\ArrayHelper;
 
 abstract class AbstractFilter
 {
@@ -25,29 +25,10 @@ protected static function getArrayElementValueFromKey($key, $arrayElement)
     {
         return self::getValueFromKeysArray(
             explode(Constants::ARRAY_SEPARATOR, $key),
-            (is_object($arrayElement)) ? self::convertObjectToArray($arrayElement) : $arrayElement
+            (is_object($arrayElement)) ? ArrayHelper::convertObjectToArray($arrayElement) : $arrayElement
         );
     }
 
-    /**
-     * @param $arrayElement
-     * @return array
-     */
-    private static function convertObjectToArray($arrayElement)
-    {
-        $convertedArray = [];
-
-        foreach (ArrayConverter::convertToPlainArray($arrayElement) as $key => $element) {
-            $key = explode("\\", $key);
-            $key = end($key);
-            $key = explode("\000", $key);
-
-            $convertedArray[end($key)] = $element;
-        }
-
-        return $convertedArray;
-    }
-
     /**
      * @param $keysArray
      * @param $arrayElement
@@ -59,7 +40,7 @@ private static function getValueFromKeysArray($keysArray, $arrayElement)
         if (count($keysArray)>1) {
             $key = array_shift($keysArray);
 
-            return self::getValueFromKeysArray($keysArray, ArrayConverter::convertToPlainArray($arrayElement[$key]));
+            return self::getValueFromKeysArray($keysArray, ArrayHelper::convertToPlainArray($arrayElement[$key]));
         }
 
         if (!isset($arrayElement[$keysArray[0]])) {

diff --git a/src/Filters/Criterion/InArrayFilter.php b/src/Filters/Criterion/InArrayFilter.php
@@ -10,7 +10,7 @@
 
 namespace ArrayQuery\Filters\Criterion;
 
-use ArrayQuery\Helpers\ArrayConverter;
+use ArrayQuery\Helpers\ArrayHelper;
 
 class InArrayFilter implements FilterInterface
 {
@@ -21,6 +21,6 @@ class InArrayFilter implements FilterInterface
      */
     public function match($value, $valueToCompare, $dateFormat = null)
     {
-        return in_array($value, ArrayConverter::convertToPlainArray($valueToCompare));
+        return in_array($value, ArrayHelper::convertToPlainArray($valueToCompare));
     }
 }
diff --git a/src/Filters/Criterion/InArrayInversedFilter.php b/src/Filters/Criterion/InArrayInversedFilter.php
@@ -10,7 +10,7 @@
 
 namespace ArrayQuery\Filters\Criterion;
 
-use ArrayQuery\Helpers\ArrayConverter;
+use ArrayQuery\Helpers\ArrayHelper;
 
 class InArrayInversedFilter implements FilterInterface
 {
@@ -21,6 +21,6 @@ class InArrayInversedFilter implements FilterInterface
      */
     public function match($value, $valueToCompare, $dateFormat = null)
     {
-        return in_array($valueToCompare, ArrayConverter::convertToPlainArray($value));
+        return in_array($valueToCompare, ArrayHelper::convertToPlainArray($value));
     }
 }
diff --git a/src/Helpers/ArrayConverter.php b/src/Helpers/ArrayConverter.php
diff --git a/src/Helpers/ArrayHelper.php b/src/Helpers/ArrayHelper.php
@@ -0,0 +1,111 @@
+<?php
+/**
+ * This file is part of the ArrayQuery package.
+ *
+ * (c) Mauro Cassani<https://github.com/mauretto78>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace ArrayQuery\Helpers;
+
+class ArrayHelper
+{
+    /**
+     * @param $firstArray
+     * @param $secondArray
+     * @return bool
+     */
+    public static function checkIfTwoArraysAreConsistent($firstArray, $secondArray)
+    {
+        if (count(array_diff($firstArray, $secondArray)) > 0 || count(array_diff($secondArray, $firstArray)) > 0) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @param $itemToCompare
+     * @param $element
+     * @return bool
+     */
+    public static function compareElementToItemKeyMap($itemToCompare, $element)
+    {
+        foreach ($itemToCompare as $key => $item){
+            if(is_array($item) && ArrayHelper::isAnAssociativeArray($item)){
+                if (false === ArrayHelper::checkIfTwoArraysAreConsistent(array_keys($item), array_keys($element[$key]))) {
+                    return false;
+                }
+
+                return self::compareElementToItemKeyMap($item, $element[$key]);
+            }
+        }
+    }
+
+    /**
+     * @param $arrayElement
+     * @return array
+     */
+    public static function convertObjectToArray($arrayElement)
+    {
+        $convertedArray = [];
+
+        foreach (self::convertToPlainArray($arrayElement) as $key => $element) {
+            $key = explode("\\", $key);
+            $key = end($key);
+            $key = explode("\000", $key);
+
+            $convertedArray[end($key)] = $element;
+        }
+
+        return $convertedArray;
+    }
+
+    /**
+     * @param $array
+     * @return mixed
+     */
+    public static function convertToObjectArray($array)
+    {
+        return json_decode(json_encode($array));
+    }
+
+    /**
+     * @param $array
+     * @return mixed
+     */
+    public static function convertToPlainArray($array)
+    {
+        return json_decode(json_encode($array), true);
+    }
+
+    /**
+     * @param $key
+     * @param $array
+     * @return mixed
+     */
+    public static function getValueFromNestedArray(array $key, array $array)
+    {
+        array_shift($key);
+        $value = $array[$key[0]];
+
+        if(is_array($value)){
+            return self::getValueFromNestedArray($key, $value);
+        }
+
+        return $value;
+    }
+
+    /**
+     * @param array $array
+     * @return bool
+     */
+    public static function isAnAssociativeArray(array $array)
+    {
+        if ([] === $array) return false;
+
+        return array_keys($array) !== range(0, count($array) - 1);
+    }
+}
diff --git a/src/Helpers/ConsistencyChecker.php b/src/Helpers/ConsistencyChecker.php
@@ -21,18 +21,21 @@ public static function isElementValid($element, $array)
     {
         foreach ($array as $key => $item) {
             if (is_object($item)) {
-                $array[$key] = ArrayConverter::convertToPlainArray($item);
+                $array[$key] = ArrayHelper::convertToPlainArray($item);
             }
         }
 
         if (is_object($element)) {
-            $element = ArrayConverter::convertToPlainArray($element);
+            $element = ArrayHelper::convertToPlainArray($element);
         }
 
-        $FirstItemKeyMap = array_keys(current($array));
-        $ItemKeyMap = array_keys($element);
+        $firstItem = current($array);
 
-        if (count(array_diff($FirstItemKeyMap, $ItemKeyMap)) > 0 || count(array_diff($ItemKeyMap, $FirstItemKeyMap)) > 0) {
+        if (false === ArrayHelper::checkIfTwoArraysAreConsistent(array_keys($firstItem), array_keys($element))) {
+            return false;
+        }
+
+        if(false === ArrayHelper::compareElementToItemKeyMap($firstItem, $element)) {
             return false;
         }
 

diff --git a/src/QueryBuilder.php b/src/QueryBuilder.php
@@ -22,7 +22,7 @@
 use ArrayQuery\Filters\JoinFilter;
 use ArrayQuery\Filters\SortingFilter;
 use ArrayQuery\Filters\LimitFilter;
-use ArrayQuery\Helpers\ArrayConverter;
+use ArrayQuery\Helpers\ArrayHelper;
 use ArrayQuery\Helpers\ConsistencyChecker;
 
 class QueryBuilder
@@ -239,7 +239,7 @@ public function getResults()
     {
         $results = $this->applySortingFilter($this->applyLimitFilter($this->applyCriteriaFilter($this->applyJoinFilter())));
 
-        return array_map([ArrayConverter::class, 'convertToPlainArray'], $results);
+        return array_map([ArrayHelper::class, 'convertToPlainArray'], $results);
     }
 
     /**
@@ -334,10 +334,12 @@ private function applyCriteriaFilter(array $array)
                     $oldkey = explode(Constants::ARRAY_SEPARATOR, $key[0]);
                     $newkey = $key[1];
 
-                    $result = ArrayConverter::convertToPlainArray($result);
-                    $result[$newkey] = $result[$oldkey[0]];
-                    unset($result[$oldkey[0]]);
+                    $result = ArrayHelper::convertToPlainArray($result);
+                    $oldResult = $result[$oldkey[0]];
+
+                    $result[$newkey] = (count($oldkey) > 1) ? ArrayHelper::getValueFromNestedArray($oldkey, $oldResult) : $oldResult;
                 }
+
                 return $result;
             }, $results);
         }

diff --git a/tests/ArrayConverterTest.php b/tests/ArrayConverterTest.php
@@ -10,7 +10,7 @@
 
 namespace ArrayQuery\Tests;
 
-use ArrayQuery\Helpers\ArrayConverter;
+use ArrayQuery\Helpers\ArrayHelper;
 use PHPUnit\Framework\TestCase;
 
 class ArrayConverterTest extends TestCase
@@ -45,7 +45,7 @@ public function it_converts_a_plain_array_in_an_object_array()
             ],
         ];
 
-        $objectArray = ArrayConverter::convertToObjectArray($array);
+        $objectArray = ArrayHelper::convertToObjectArray($array);
         foreach ($objectArray as $item) {
             $this->assertInstanceOf(\stdClass::class, $item);
         }
@@ -71,7 +71,7 @@ public function it_converts_an_object_array_in_a_plain_array()
             $b
         ];
 
-        $plainArray = ArrayConverter::convertToPlainArray($array);
+        $plainArray = ArrayHelper::convertToPlainArray($array);
         foreach ($plainArray as $item) {
             $this->assertTrue(is_array($item));
         }

diff --git a/tests/ConsistencyCheckerTest.php b/tests/ConsistencyCheckerTest.php
@@ -60,6 +60,51 @@ public function it_returns_false_if_an_not_consistent_array_is_provided()
         $this->assertFalse(ConsistencyChecker::isValid($array));
     }
 
+    /**
+     * @test
+     */
+    public function it_returns_false_if_an_not_consistent_array_with_nested_keys_is_provided()
+    {
+        $array = [
+            [
+                'id' => 1,
+                'name' => 'Mauro Cassani',
+                'skills' => [
+                    'web' => [
+                        'php' => 5,
+                        'web_design' => 5,
+                        'css' => 4,
+                    ]
+                ],
+            ],
+            [
+                'id' => 2,
+                'name' => 'John Doe',
+                'skills' => [
+                    'web' => [
+                        'php' => 3,
+                        'web_design' => 1,
+                        'css' => 5,
+                    ]
+                ],
+            ],
+            [
+                'id' => 3,
+                'name' => 'Maria Callas',
+                'skills' => [
+                    'web' => [
+                        'php' => 1,
+                        'web_design' => 3,
+                        'css' => 3,
+                        'extra' => 55,
+                    ]
+                ],
+            ],
+        ];
+
+        $this->assertFalse(ConsistencyChecker::isValid($array));
+    }
+
     /**
      * @test
      */