mariosvasiliou / underscore_php

src/Parse.php

Spacing +7 added lines, -7 removed lines

@@ -113,7 +113,7 @@ 
 
         // Convert objects to arrays
         if (\is_object($data)) {
-            $data = (array) $data;
+            $data = (array)$data;
         }
 
         // Don't convert if it's not an array
@@ -137,7 +137,7 @@ 
 
             // Else add values
             foreach ($row as $key => $value) {
-                $row[$key] = '"'.stripslashes((string) $value).'"';
+                $row[$key] = '"'.stripslashes((string)$value).'"';
             }
 
             $csv[] = implode($delimiter, $row);
@@ -161,7 +161,7 @@ 
             $data = $data->toArray();
         }
 
-        return (array) $data;
+        return (array)$data;
     }
 
     /**
@@ -177,7 +177,7 @@ 
             return static::toJSON($data);
         }
 
-        return (string) $data;
+        return (string)$data;
     }
 
     /**
@@ -197,7 +197,7 @@ 
             return \strlen($data);
         }
 
-        return (int) $data;
+        return (int)$data;
     }
 
     /**
@@ -207,7 +207,7 @@ 
      */
     public static function toBoolean(mixed $data) : bool
     {
-        return (bool) $data;
+        return (bool)$data;
     }
 
     /**
@@ -217,7 +217,7 @@ 
      */
     public static function toObject(mixed $data) : object
     {
-        return (object) $data;
+        return (object)$data;
     }
 
     ////////////////////////////////////////////////////////////////////

src/Methods/ArraysMethods.php

Spacing +6 added lines, -6 removed lines

@@ -66,7 +66,7 @@ 
      * @param  string  $value
      *
      */
-    public static function search(array $array, mixed $value) : int|string|bool
+    public static function search(array $array, mixed $value) : int | string | bool
     {
         return array_search($value, $array, true);
     }
@@ -199,7 +199,7 @@ 
      */
     public static function clean(array $array) : mixed
     {
-        return static::filter($array, fn($value) : bool => (bool) $value);
+        return static::filter($array, fn($value) : bool => (bool)$value);
     }
 
     /**
@@ -224,7 +224,7 @@ 
      */
     public static function without(...$arguments): mixed
     {
-        $array     = array_shift($arguments);
+        $array = array_shift($arguments);
         // if singular argument and is an array treat this AS the array to run without agains
         if (\is_array($arguments[0]) && \count($arguments) === 1) {
             $arguments = $arguments[0];
@@ -332,7 +332,7 @@ 
      */
     public static function replaceValue(array $array, string $replace, string $with) : array
     {
-        return static::each($array, fn($value) : string|array => str_replace($replace, $with, (string) $value));
+        return static::each($array, fn($value) : string | array => str_replace($replace, $with, (string)$value));
     }
 
     /**
@@ -458,7 +458,7 @@ 
      * @param  array  $arguments
      *
      */
-    public static function invoke(array $array, Closure|string $callable, mixed $arguments = []) : array
+    public static function invoke(array $array, Closure | string $callable, mixed $arguments = []) : array
     {
         // If one argument given for each iteration, create an array for it
         if ( ! \is_array($arguments)) {
@@ -564,7 +564,7 @@ 
      */
     public static function unique(array $array) : array
     {
-        return array_reduce($array, function (array $resultArray, $value) : array {
+        return array_reduce($array, function(array $resultArray, $value) : array {
             if ( ! static::contains($resultArray, $value)) {
                 $resultArray[] = $value;
             }

src/Methods/FunctionsMethods.php

Spacing +11 added lines, -14 removed lines

@@ -66,9 +66,9 @@ 
         $unique = random_int(0, mt_getrandmax());
 
         // Create a closure that check if the function was already called
-        return function (...$arguments) use ($function, $canBeCalledTimes, $unique) {
+        return function(...$arguments) use ($function, $canBeCalledTimes, $unique) {
 
-            $signature = FunctionsMethods::getSignature((string) $unique, $function, $arguments);
+            $signature = FunctionsMethods::getSignature((string)$unique, $function, $arguments);
 
             // Get counter
             $numberOfTimesCalled = FunctionsMethods::hasBeenCalledTimes($signature);
@@ -77,9 +77,7 @@ 
             // Else, increment the count
             if ($numberOfTimesCalled >= $canBeCalledTimes) {
                 return false;
-            }
-
-            ++FunctionsMethods::$canBeCalledTimes[$signature];
+            }++FunctionsMethods::$canBeCalledTimes[$signature];
 
             return \call_user_func_array($function, $arguments);
         };
@@ -97,16 +95,15 @@ 
         $unique = random_int(0, mt_getrandmax());
 
         // Create a closure that check if the function was already called
-        return function (...$arguments) use ($function, $times, $unique) {
+        return function(...$arguments) use ($function, $times, $unique) {
 
-            $signature = FunctionsMethods::getSignature((string) $unique, $function, $arguments);
+            $signature = FunctionsMethods::getSignature((string)$unique, $function, $arguments);
 
             // Get counter
             $called = FunctionsMethods::hasBeenCalledTimes($signature);
 
             // Prevent calling before a certain number
-            if ($called < $times) {
-                ++FunctionsMethods::$canBeCalledTimes[$signature];
+            if ($called < $times) {++FunctionsMethods::$canBeCalledTimes[$signature];
 
                 return false;
             }
@@ -126,9 +123,9 @@ 
     {
         $unique = random_int(0, mt_getrandmax());
 
-        return function (...$arguments) use ($function, $unique) {
+        return function(...$arguments) use ($function, $unique) {
 
-            $signature = FunctionsMethods::getSignature((string) $unique, $function, $arguments);
+            $signature = FunctionsMethods::getSignature((string)$unique, $function, $arguments);
 
             if (isset(FunctionsMethods::$cached[$signature])) {
                 return FunctionsMethods::$cached[$signature];
@@ -152,9 +149,9 @@ 
     {
         $unique = random_int(0, mt_getrandmax());
 
-        return function (...$arguments) use ($function, $ms, $unique) {
+        return function(...$arguments) use ($function, $ms, $unique) {
 
-            $signature = FunctionsMethods::getSignature((string) $unique, $function, $arguments);
+            $signature = FunctionsMethods::getSignature((string)$unique, $function, $arguments);
 
             // Check last called time and update it if necessary
             $last       = FunctionsMethods::getLastCalledTime($signature);
@@ -227,7 +224,7 @@ 
      */
     public static function getSignature(string $unique, Closure $function, array $arguments) : string
     {
-        $function  = var_export($function, true);
+        $function = var_export($function, true);
         $argumentsStr = var_export($arguments, true);
 
         return md5($unique.'_'.$function.'_'.$argumentsStr);

src/Methods/StringsMethods.php

Spacing +22 added lines, -22 removed lines

@@ -170,10 +170,10 @@ 
      *
      *
      */
-    public static function endsWith(string $haystack, array|string $needles) : bool
+    public static function endsWith(string $haystack, array | string $needles) : bool
     {
-        foreach ((array) $needles as $needle) {
-            if (str_ends_with($haystack, (string) $needle)) {
+        foreach ((array)$needles as $needle) {
+            if (str_ends_with($haystack, (string)$needle)) {
                 return true;
             }
         }
@@ -218,10 +218,10 @@ 
      *
      *
      */
-    public static function startsWith(string $haystack, array|string $needles) : bool
+    public static function startsWith(string $haystack, array | string $needles) : bool
     {
-        foreach ((array) $needles as $needle) {
-            if ($needle !== '' && str_starts_with($haystack, (string) $needle)) {
+        foreach ((array)$needles as $needle) {
+            if ($needle !== '' && str_starts_with($haystack, (string)$needle)) {
                 return true;
             }
         }
@@ -244,8 +244,8 @@ 
      * @return bool Found or not
      */
     public static function find(
-        array|string $string,
-        array|string $needle,
+        array | string $string,
+        array | string $needle,
         bool $caseSensitive = false,
         bool $absolute = false
     ) : bool
@@ -271,7 +271,7 @@ 
         }
 
         // If not case sensitive
-        if (!$caseSensitive) {
+        if ( ! $caseSensitive) {
             $string = strtolower($string);
             $needle = strtolower($needle);
         }
@@ -304,11 +304,11 @@ 
      *
      * @return false|string
      */
-    public static function sliceFrom($string, $slice) : bool|string
+    public static function sliceFrom($string, $slice) : bool | string
     {
-        $slice = strpos((string) $string, (string) $slice);
+        $slice = strpos((string)$string, (string)$slice);
 
-        return substr((string) $string, $slice);
+        return substr((string)$string, $slice);
     }
 
     /**
@@ -319,11 +319,11 @@ 
      *
      * @return false|string
      */
-    public static function sliceTo($string, $slice) : bool|string
+    public static function sliceTo($string, $slice) : bool | string
     {
-        $slice = strpos((string) $string, (string) $slice);
+        $slice = strpos((string)$string, (string)$slice);
 
-        return substr((string) $string, 0, $slice);
+        return substr((string)$string, 0, $slice);
     }
 
     /**
@@ -388,7 +388,7 @@ 
     public static function remove($string, $remove) : string
     {
         if (\is_array($remove)) {
-            $string = preg_replace('#('.implode('|', $remove).')#', '', (string) $string);
+            $string = preg_replace('#('.implode('|', $remove).')#', '', (string)$string);
         }
 
         // Trim and return
@@ -404,7 +404,7 @@ 
      *
      * @return string|string[]
      */
-    public static function replace($string, $replace, $with) : array|string
+    public static function replace($string, $replace, $with) : array | string
     {
         return str_replace($replace, $with, $string);
     }
@@ -445,12 +445,12 @@ 
         $title = preg_replace('!['.preg_quote($flip).']+!u', $separator, $title);
 
         // Remove all characters that are not the separator, letters, numbers, or whitespace.
-        $title = preg_replace('![^'.preg_quote($separator).'\pL\pN\s]+!u', '', mb_strtolower((string) $title));
+        $title = preg_replace('![^'.preg_quote($separator).'\pL\pN\s]+!u', '', mb_strtolower((string)$title));
 
         // Replace all separator characters and whitespace by a single separator
-        $title = preg_replace('!['.preg_quote($separator).'\s]+!u', $separator, (string) $title);
+        $title = preg_replace('!['.preg_quote($separator).'\s]+!u', $separator, (string)$title);
 
-        return trim((string) $title, $separator);
+        return trim((string)$title, $separator);
     }
 
     /**
@@ -476,10 +476,10 @@ 
     public static function explode($string, $with, $limit = null) : array
     {
         if ( ! $limit) {
-            return explode($with, (string) $string);
+            return explode($with, (string)$string);
         }
 
-        return explode($with, (string) $string, $limit);
+        return explode($with, (string)$string, $limit);
     }
 
     /**

src/Methods/CollectionMethods.php

Spacing +28 added lines, -28 removed lines

@@ -53,17 +53,17 @@ 
             return $collection;
         }
 
-        $collection = (array) $collection;
+        $collection = (array)$collection;
 
         if (isset($collection[$key])) {
             return $collection[$key];
         }
 
         // Crawl through collection, get key according to object or not
-        foreach (explode('.', (string) $key) as $segment) {
-            $collection = (array) $collection;
+        foreach (explode('.', (string)$key) as $segment) {
+            $collection = (array)$collection;
 
-            if (!isset($collection[$segment])) {
+            if ( ! isset($collection[$segment])) {
                 return $default instanceof Closure ? $default() : $default;
             }
 
@@ -97,7 +97,7 @@ 
     public static function setAndGet(mixed &$collection, string $key, mixed $default = null) : mixed
     {
         // If the key doesn't exist, set it
-        if (!static::has($collection, $key)) {
+        if ( ! static::has($collection, $key)) {
             $collection = static::set($collection, $key, $default);
         }
 
@@ -109,7 +109,7 @@ 
      *
      *
      */
-    public static function remove(mixed $collection, string|array $key) : mixed
+    public static function remove(mixed $collection, string | array $key) : mixed
     {
         // Recursive call
         if (\is_array($key)) {
@@ -131,13 +131,13 @@ 
      * @param $collection
      * @param $property
      */
-    public static function pluck($collection, $property) : object|array
+    public static function pluck($collection, $property) : object | array
     {
-        $plucked = array_map(fn($value): mixed => ArraysMethods::get($value, $property), (array) $collection);
+        $plucked = array_map(fn($value): mixed => ArraysMethods::get($value, $property), (array)$collection);
 
         // Convert back to object if necessary
         if (\is_object($collection)) {
-            return (object) $plucked;
+            return (object)$plucked;
         }
 
         return $plucked;
@@ -152,9 +152,9 @@ 
      *
      */
     public static function filterBy($collection, string $property, mixed $value, string $comparisonOp = null) :
-    object|array
+    object | array
     {
-        if (!$comparisonOp) {
+        if ( ! $comparisonOp) {
             $comparisonOp = \is_array($value) ? 'contains' : 'eq';
         }
 
@@ -165,32 +165,32 @@ 
             'lt'          => fn($item, $prop, $value) : bool => $item[$prop] < $value,
             'lte'         => fn($item, $prop, $value) : bool => $item[$prop] <= $value,
             'ne'          => fn($item, $prop, $value) : bool => $item[$prop] !== $value,
-            'contains'    => fn($item, $prop, $value) : bool => \in_array($item[$prop], (array) $value, true),
-            'notContains' => fn($item, $prop, $value) : bool => ! \in_array($item[$prop], (array) $value, true),
+            'contains'    => fn($item, $prop, $value) : bool => \in_array($item[$prop], (array)$value, true),
+            'notContains' => fn($item, $prop, $value) : bool => ! \in_array($item[$prop], (array)$value, true),
             'newer'       => fn(
                 $item,
                 $prop,
                 $value
-            ) : bool => strtotime((string) $item[$prop]) > strtotime((string) $value),
+            ) : bool => strtotime((string)$item[$prop]) > strtotime((string)$value),
             'older'       => fn(
                 $item,
                 $prop,
                 $value
-            ) : bool => strtotime((string) $item[$prop]) < strtotime((string) $value),
+            ) : bool => strtotime((string)$item[$prop]) < strtotime((string)$value),
         ];
-        $result = array_values(array_filter((array) $collection, function ($item) use (
+        $result = array_values(array_filter((array)$collection, function($item) use (
             $property,
             $value,
             $ops,
             $comparisonOp
         ): bool {
-            $item = (array) $item;
+            $item = (array)$item;
             $item[$property] = static::get($item, $property, []);
 
             return $ops[$comparisonOp]($item, $property, $value);
         }));
         if (\is_object($collection)) {
-            return (object) $result;
+            return (object)$result;
         }
 
         return $result;
@@ -207,7 +207,7 @@ 
     {
         $filtered = static::filterBy($collection, $property, $value, $comparisonOp);
 
-        return ArraysMethods::first(\is_array($filtered) ? $filtered : (array) $filtered);
+        return ArraysMethods::first(\is_array($filtered) ? $filtered : (array)$filtered);
     }
 
     ////////////////////////////////////////////////////////////////////
@@ -220,7 +220,7 @@ 
      */
     public static function keys($collection) : array
     {
-        return array_keys((array) $collection);
+        return array_keys((array)$collection);
     }
 
     /**
@@ -230,7 +230,7 @@ 
      */
     public static function values($collection) : array
     {
-        return array_values((array) $collection);
+        return array_values((array)$collection);
     }
 
     ////////////////////////////////////////////////////////////////////
@@ -241,7 +241,7 @@ 
      *
      *
      */
-    public static function replace(array|object $collection, string $replace, string $key, mixed $value) : mixed
+    public static function replace(array | object $collection, string $replace, string $key, mixed $value) : mixed
     {
         $collection = static::remove($collection, $replace);
 
@@ -255,10 +255,10 @@ 
      * @param  string|callable|null  $sorter
      *
      */
-    public static function sort(array|object $collection, string|callable $sorter = null, string $direction = 'asc') :
+    public static function sort(array | object $collection, string | callable $sorter = null, string $direction = 'asc') :
     array
     {
-        $collection = (array) $collection;
+        $collection = (array)$collection;
 
         // Get correct PHP constant for direction
         $directionNumber = (strtolower($direction) === 'desc') ? SORT_DESC : SORT_ASC;
@@ -286,9 +286,9 @@ 
      * @param      $grouper
      *
      */
-    public static function group(mixed $collection, callable|string $grouper, bool $saveKeys = false) : array
+    public static function group(mixed $collection, callable | string $grouper, bool $saveKeys = false) : array
     {
-        $collection = (array) $collection;
+        $collection = (array)$collection;
         $result     = [];
 
         // Iterate over values, group by property/results from closure
@@ -326,7 +326,7 @@ 
         }
 
         // Explode the keys
-        $keys = explode('.', (string) $key);
+        $keys = explode('.', (string)$key);
 
         // Crawl through the keys
         while (\count($keys) > 1) {
@@ -360,7 +360,7 @@ 
      * @param  string  $key
      *
      */
-    protected static function internalRemove(array|object &$collection, mixed $key) : bool
+    protected static function internalRemove(array | object &$collection, mixed $key) : bool
     {
         // Explode keys
         $keys = explode('.', $key);