Do not use array_unique() in the Unique rule

The default value of the second argument of `array_unique()` is
`SORT_STRING`. This means that it converts all values to strings. That
was the reason we were using `SORT_REGULAR`, but when using `SORT_REGULAR`,
the strings `14.1` and `14.10` are considered the same, even though
they're different.

This commit will change the `Unique` rule to implement its own way of
detecting uniqueness. This was necessary because `array_unique() 's
limitation is handling different types in the same array.

Co-authored-by: Henrique Moody <henriquemoody@gmail.com>

Author: dvdheiden

library/Rules/Unique.php

@@ -9,11 +9,10 @@
 
 namespace Respect\Validation\Rules;
 
-use function array_unique;
+use function array_is_list;
+use function in_array;
 use function is_array;
 
-use const SORT_REGULAR;
-
 /**
  * Validates whether the input array contains only unique values.
  *
@@ -32,6 +31,34 @@ public function validate($input): bool
             return false;
         }
 
-        return $input == array_unique($input, SORT_REGULAR);
+        return $input == $this->unique($input);
+    }
+
+    /**
+     * @param array<mixed, mixed> $input
+     *
+     * @return array<mixed, mixed>
+     */
+    private function unique(array $input): array
+    {
+        if (!array_is_list($input)) {
+            return $input;
+        }
+
+        $unique = [];
+        foreach ($input as $value) {
+            $comparedValue = $value;
+            if (is_array($comparedValue)) {
+                $comparedValue = $this->unique($comparedValue);
+            }
+
+            if (in_array($comparedValue, $unique, true)) {
+                continue;
+            }
+
+            $unique[] = $comparedValue;
+        }
+
+        return $unique;
     }
 }

tests/unit/Rules/UniqueTest.php

@@ -30,13 +30,24 @@ public static function providerForValidInput(): array
         $rule = new Unique();
 
         return [
-            [$rule, []],
-            [$rule, [1, 2, 3]],
-            [$rule, [true, false]],
-            [$rule, ['alpha', 'beta', 'gamma', 'delta']],
-            [$rule, [0, 2.71, 3.14]],
-            [$rule, [[], ['str'], [1]]],
-            [$rule, [(object) ['key' => 'value'], (object) ['other_key' => 'value']]],
+            'empty' => [$rule, []],
+            'integers' => [$rule, [1, 2, 3]],
+            'booleans' => [$rule, [true, false]],
+            'strings' => [$rule, ['alpha', 'beta', 'gamma', 'delta']],
+            'floats' => [$rule, [2.71, 1.3, 3.14]],
+            'numeric strings' => [$rule, ['14.0', '14.1', '14.10']],
+            'integers + booleans' => [$rule, [1, true]],
+            'integers + floats' => [$rule, [2.0, 2, 3.14]],
+            'integers + floats + strings' => [$rule, [14.0, '14', '14.0']],
+            'arrays' => [$rule, [[], ['str'], [1]]],
+            'arrays (multidimensional)' => [
+                $rule, [
+                    ['key' => ['id' => 123, 'name' => 'Something']],
+                    ['key' => ['id' => 122, 'name' => 'Something else']],
+                ],
+            ],
+            'objects' => [$rule, [(object) ['key' => 'value'], (object) ['other_key' => 'value']]],
+            'objects (same properties)' => [$rule, [(object) ['key' => 'value'], (object) ['key' => 'value']]],
         ];
     }
 
@@ -46,17 +57,23 @@ public static function providerForValidInput(): array
     public static function providerForInvalidInput(): array
     {
         $rule = new Unique();
+        $object = (object) ['key' => 'value'];
 
         return [
-            [$rule, 'test'],
-            [$rule, [1, 2, 2, 3]],
-            [$rule, [1, 2, 3, 1]],
-            [$rule, [true, false, false]],
-            [$rule, ['alpha', 'beta', 'gamma', 'delta', 'beta']],
-            [$rule, [0, 3.14, 2.71, 3.14]],
-            [$rule, [[], [1], [1]]],
-            [$rule, [(object) ['key' => 'value'], (object) ['key' => 'value']]],
-            [$rule, [1, true, 'test']], // PHP's array_unique treats 1 and true as equal
+            'string' => [$rule, 'test'],
+            'integers (2nd & 3rd)' => [$rule, [1, 2, 2, 3]],
+            'integers (2nd & 4th)' => [$rule, [1, 2, 3, 1]],
+            'booleans' => [$rule, [true, false, false]],
+            'strings' => [$rule, ['alpha', 'beta', 'gamma', 'delta', 'beta']],
+            'integers + floats' => [$rule, [0, 3.14, 2.71, 3.14]],
+            'arrays' => [$rule, [[], [1], [1]]],
+            'objects (single instance)' => [$rule, [$object, $object]],
+            'arrays (multidimensional)' => [
+                $rule, [
+                    ['key' => ['id' => 123, 'name' => 'Something']],
+                    ['key' => ['id' => 123, 'name' => 'Something']],
+                ],
+            ],
         ];
     }
 }