Arr::uniqueInt() - Code Metrics - Inspection of "v5.10.0 release" - pryley/site-reviews - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b318ac...f0530b )

by Paul

created 2021-04-26 17:45 UTC

Arr::uniqueInt() A

↳ Parent: Arr

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	2
c	0
b	0
f	0
nc	1
nop	1
dl	0
loc	4
ccs	3
cts	3
cp	1
crap	1
rs	10

<?php

namespace GeminiLabs\SiteReviews\Helpers;

use GeminiLabs\SiteReviews\Arguments;
use GeminiLabs\SiteReviews\Helper;
use GeminiLabs\SiteReviews\Helpers\Cast;

class Arr
{
    /**
     * @return bool
     */
    public static function compare(array $arr1, array $arr2)
    {
        sort($arr1);
        sort($arr2);
        return $arr1 == $arr2;
    }

    /**
     * Returns an empty array if value is scalar
     * @param mixed $value
     * @return array
     */
    public static function consolidate($value)
    {
        if ($value instanceof Arguments) {
            return $value->toArray();
        }
        if (is_object($value)) {
            $values = get_object_vars($value);
            $value = Helper::ifEmpty($values, (array) $value, $strict = true);
        }
        return is_array($value) ? $value : [];
    }

    /**
     * @return array
     */
    public static function convertFromDotNotation(array $array)
    {
        $results = [];
        foreach ($array as $path => $value) {
            $results = static::set($results, $path, $value);
        }
        return $results;
    }

    /**
     * @param mixed $value
     * @param mixed $callback
     * @return array
     */
    public static function convertFromString($value, $callback = null)
    {
        if (is_scalar($value)) {
            $value = array_map('trim', explode(',', Cast::toString($value)));
        }
        $callback = Helper::ifEmpty(Cast::toString($callback), Helper::class.'::isNotEmpty');
        return static::reindex(array_filter((array) $value, $callback));
    }

    /**
     * @param bool $flattenValue
     * @param string $prefix
     * @return array
     */
    public static function flatten(array $array, $flattenValue = false, $prefix = '')
    {
        $result = [];
        foreach ($array as $key => $value) {
            $newKey = ltrim($prefix.'.'.$key, '.');
            if (static::isIndexedAndFlat($value)) {
                $value = Helper::ifTrue(!$flattenValue, $value, function () use ($value) {
                    return '['.implode(', ', $value).']';
                });
            } elseif (is_array($value)) {
                $result = array_merge($result, static::flatten($value, $flattenValue, $newKey));
                continue;
            }
            $result[$newKey] = $value;
        }
        return $result;
    }

    /**
     * Get a value from an array of values using a dot-notation path as reference.
     * @param mixed $data
     * @param string|int $path
     * @param mixed $fallback
     * @return mixed
     */
    public static function get($data, $path = '', $fallback = '')
    {
        $data = static::consolidate($data);
        $keys = explode('.', $path);
        $result = $fallback;
        foreach ($keys as $key) {
            if (!isset($data[$key])) {
                return $fallback;
            }
            if (is_object($data[$key])) {
                $result = $data[$key];
                $data = static::consolidate($result);
                continue;
            }
            $result = $data[$key];
            $data = $result;
        }
        return $result;
    }

    /**
     * @param string|int $key
     * @return array
     */
    public static function insertAfter($key, array $array, array $insert)
    {
        return static::insert($array, $insert, $key, 'after');
    }

    /**
     * @param string|int $key
     * @return array
     */
    public static function insertBefore($key, array $array, array $insert)
    {
        return static::insert($array, $insert, $key, 'before');
    }

    /**
     * @param string|int $key
     * @param string $position
     * @return array
     */
    public static function insert(array $array, array $insert, $key, $position = 'before')
    {
        $keyPosition = array_search($key, array_keys($array));
        if (false !== $keyPosition) {
            $keyPosition = Cast::toInt($keyPosition);
            if ('after' == $position) {
                ++$keyPosition;
            }
            $result = array_slice($array, 0, $keyPosition);
            $result = array_merge($result, $insert);
            return array_merge($result, array_slice($array, $keyPosition));
        }
        return array_merge($array, $insert);
    }

    /**
     * @param mixed $array
     * @return bool
     */
    public static function isIndexedAndFlat($array)
    {
        if (!is_array($array) || array_filter($array, 'is_array')) {
            return false;
        }
        return wp_is_numeric_array($array);
    }

    /**
     * @param bool $prefixed
     * @return array
     */
    public static function prefixKeys(array $values, $prefix = '_', $prefixed = true)
    {
        $trim = Helper::ifTrue($prefixed, $prefix, '');
        $prefixed = [];
        foreach ($values as $key => $value) {
            $key = trim($key);
            if (0 === strpos($key, $prefix)) {
                $key = substr($key, strlen($prefix));
            }
            $prefixed[$trim.$key] = $value;
        }
        return $prefixed;
    }

    /**
     * @param array $array
     * @param mixed $value
     * @param mixed $key
     * @return array
     */
    public static function prepend($array, $value, $key = null)
    {
        if (!is_null($key)) {
            return [$key => $value] + $array;
        }
        array_unshift($array, $value);
        return $array;
    }

    /**
     * @param mixed $array
     * @return array
     */
    public static function reindex($array)
    {
        return static::isIndexedAndFlat($array) ? array_values($array) : $array;
    }

    /**
     * Unset a value from an array of values using a dot-notation path as reference.
     * @param mixed $data
     * @param string $path
     * @return array
     */
    public static function remove($data, $path = '')
    {
        $data = static::consolidate($data);
        $keys = explode('.', $path);
        $last = array_pop($keys);
        $pointer = &$data;
        foreach ($keys as $key) {
            if (is_array(static::get($pointer, $key))) {
                $pointer = &$pointer[$key];
            }
        }
        unset($pointer[$last]);
        return $data;
    }

    /**
     * @return array
     */
    public static function removeEmptyValues(array $array)
    {
        $result = [];
        foreach ($array as $key => $value) {
            if (Helper::isEmpty($value)) {
                continue;
            }
            $result[$key] = Helper::ifTrue(!is_array($value), $value, function () use ($value) {
                return static::removeEmptyValues($value);
            });
        }
        return $result;
    }

    /**
     * Search a multidimensional array by key value
     * @param mixed $needle
     * @param array $haystack
     * @param int|string $key
     * @return array|false
     */
    public static function searchByKey($needle, $haystack, $key)
    {
        if (!is_array($haystack) || array_diff_key($haystack, array_filter($haystack, 'is_array'))) {
            return false;
        }
        $index = array_search($needle, wp_list_pluck($haystack, $key));
        if (false !== $index) {
            return $haystack[$index];
        }
        return false;
    }

    /**
     * Set a value to an array of values using a dot-notation path as reference.
     * @param mixed $data
     * @param string $path
     * @param mixed $value
     * @return array
     */
    public static function set($data, $path, $value)
    {
        $token = strtok($path, '.');
        $ref = &$data;
        while (false !== $token) {
            if (is_object($ref)) {
                $ref = &$ref->$token;
            } else {
                $ref = static::consolidate($ref);
                $ref = &$ref[$token];
            }
            $token = strtok('.');
        }
        $ref = $value;
        return $data;
    }

    /**
     * @return array
     */
    public static function unique(array $values)
    {
        return Helper::ifTrue(!static::isIndexedAndFlat($values), $values, function () use ($values) {
            return array_filter(array_unique($values));
        });
    }

    /**
     * @param array|string $values
     * @return array
     */
    public static function uniqueInt($values)
    {
        $values = array_filter(static::convertFromString($values), 'is_numeric');
        return static::reindex(static::unique(array_values(array_map('absint', $values))));
    }

    /**
     * @return array
     */
    public static function unprefixKeys(array $values, $prefix = '_')
    {
        return static::prefixKeys($values, $prefix, false);
    }
}


1		<?php
2
3		namespace GeminiLabs\SiteReviews\Helpers;
4
5		use GeminiLabs\SiteReviews\Arguments;
6		use GeminiLabs\SiteReviews\Helper;
7		use GeminiLabs\SiteReviews\Helpers\Cast;
8
9		class Arr
10		{
11		/**
12		* @return bool
13		*/
14	8	public static function compare(array $arr1, array $arr2)
15		{
16	8	sort($arr1);
17	8	sort($arr2);
18	8	return $arr1 == $arr2;
19		}
20
21		/**
22		* Returns an empty array if value is scalar
23		* @param mixed $value
24		* @return array
25		*/
26	46	public static function consolidate($value)
27		{
28	46	if ($value instanceof Arguments) {
29	6	return $value->toArray();
30		}
31	46	if (is_object($value)) {
32	18	$values = get_object_vars($value);
33	18	$value = Helper::ifEmpty($values, (array) $value, $strict = true);
34		}
35	46	return is_array($value) ? $value : [];
36		}
37
38		/**
39		* @return array
40		*/
41	11	public static function convertFromDotNotation(array $array)
42		{
43	11	$results = [];
44	11	foreach ($array as $path => $value) {
45	11	$results = static::set($results, $path, $value);
46		}
47	11	return $results;
48		}
49
50		/**
51		* @param mixed $value
52		* @param mixed $callback
53		* @return array
54		*/
55	43	public static function convertFromString($value, $callback = null)
56		{
57	43	if (is_scalar($value)) {
58	42	$value = array_map('trim', explode(',', Cast::toString($value)));
59		}
60	43	$callback = Helper::ifEmpty(Cast::toString($callback), Helper::class.'::isNotEmpty');
61	43	return static::reindex(array_filter((array) $value, $callback));
62		}
63
64		/**
65		* @param bool $flattenValue
66		* @param string $prefix
67		* @return array
68		*/
69	8	public static function flatten(array $array, $flattenValue = false, $prefix = '')
70		{
71	8	$result = [];
72	8	foreach ($array as $key => $value) {
73	1	$newKey = ltrim($prefix.'.'.$key, '.');
74	1	if (static::isIndexedAndFlat($value)) {
75		$value = Helper::ifTrue(!$flattenValue, $value, function () use ($value) {
76	1	return '['.implode(', ', $value).']';
77	1	});
78	1	} elseif (is_array($value)) {
79	1	$result = array_merge($result, static::flatten($value, $flattenValue, $newKey));
80	1	continue;
81		}
82	1	$result[$newKey] = $value;
83		}
84	8	return $result;
85		}
86
87		/**
88		* Get a value from an array of values using a dot-notation path as reference.
89		* @param mixed $data
90		* @param string\|int $path
91		* @param mixed $fallback
92		* @return mixed
93		*/
94	30	public static function get($data, $path = '', $fallback = '')
95		{
96	30	$data = static::consolidate($data);
97	30	$keys = explode('.', $path);
98	30	$result = $fallback;
99	30	foreach ($keys as $key) {
100	30	if (!isset($data[$key])) {
101	27	return $fallback;
102		}
103	30	if (is_object($data[$key])) {
104	7	$result = $data[$key];
105	7	$data = static::consolidate($result);
106	7	continue;
107		}
108	30	$result = $data[$key];
109	30	$data = $result;
110		}
111	30	return $result;
112		}
113
114		/**
115		* @param string\|int $key
116		* @return array
117		*/
118	1	public static function insertAfter($key, array $array, array $insert)
119		{
120	1	return static::insert($array, $insert, $key, 'after');
121		}
122
123		/**
124		* @param string\|int $key
125		* @return array
126		*/
127	1	public static function insertBefore($key, array $array, array $insert)
128		{
129	1	return static::insert($array, $insert, $key, 'before');
130		}
131
132		/**
133		* @param string\|int $key
134		* @param string $position
135		* @return array
136		*/
137	2	public static function insert(array $array, array $insert, $key, $position = 'before')
138		{
139	2	$keyPosition = array_search($key, array_keys($array));
140	2	if (false !== $keyPosition) {
141	2	$keyPosition = Cast::toInt($keyPosition);
142	2	if ('after' == $position) {
143	1	++$keyPosition;
144		}
145	2	$result = array_slice($array, 0, $keyPosition);
146	2	$result = array_merge($result, $insert);
147	2	return array_merge($result, array_slice($array, $keyPosition));
148		}
149	2	return array_merge($array, $insert);
150		}
151
152		/**
153		* @param mixed $array
154		* @return bool
155		*/
156	55	public static function isIndexedAndFlat($array)
157		{
158	55	if (!is_array($array) \|\| array_filter($array, 'is_array')) {
159	50	return false;
160		}
161	54	return wp_is_numeric_array($array);
162		}
163
164		/**
165		* @param bool $prefixed
166		* @return array
167		*/
168	16	public static function prefixKeys(array $values, $prefix = '_', $prefixed = true)
169		{
170	16	$trim = Helper::ifTrue($prefixed, $prefix, '');
171	16	$prefixed = [];
172	16	foreach ($values as $key => $value) {
173	3	$key = trim($key);
174	3	if (0 === strpos($key, $prefix)) {
175	3	$key = substr($key, strlen($prefix));
176		}
177	3	$prefixed[$trim.$key] = $value;
178		}
179	16	return $prefixed;
180		}
181
182		/**
183		* @param array $array
184		* @param mixed $value
185		* @param mixed $key
186		* @return array
187		*/
188	15	public static function prepend($array, $value, $key = null)
189		{
190	15	if (!is_null($key)) {
191	8	return [$key => $value] + $array;
192		}
193	13	array_unshift($array, $value);
194	13	return $array;
195		}
196
197		/**
198		* @param mixed $array
199		* @return array
200		*/
201	44	public static function reindex($array)
202		{
203	44	return static::isIndexedAndFlat($array) ? array_values($array) : $array;
204		}
205
206		/**
207		* Unset a value from an array of values using a dot-notation path as reference.
208		* @param mixed $data
209		* @param string $path
210		* @return array
211		*/
212	8	public static function remove($data, $path = '')
213		{
214	8	$data = static::consolidate($data);
215	8	$keys = explode('.', $path);
216	8	$last = array_pop($keys);
217	8	$pointer = &$data;
218	8	foreach ($keys as $key) {
219	8	if (is_array(static::get($pointer, $key))) {
220	8	$pointer = &$pointer[$key];
221		}
222		}
223	8	unset($pointer[$last]);
224	8	return $data;
225		}
226
227		/**
228		* @return array
229		*/
230	2	public static function removeEmptyValues(array $array)
231		{
232	2	$result = [];
233	2	foreach ($array as $key => $value) {
234	2	if (Helper::isEmpty($value)) {
235	2	continue;
236		}
237		$result[$key] = Helper::ifTrue(!is_array($value), $value, function () use ($value) {
238	1	return static::removeEmptyValues($value);
239	2	});
240		}
241	2	return $result;
242		}
243
244		/**
245		* Search a multidimensional array by key value
246		* @param mixed $needle
247		* @param array $haystack
248		* @param int\|string $key
249		* @return array\|false
250		*/
251	12	public static function searchByKey($needle, $haystack, $key)
252		{
253	12	if (!is_array($haystack) \|\| array_diff_key($haystack, array_filter($haystack, 'is_array'))) {
254		return false;
255		}
256	12	$index = array_search($needle, wp_list_pluck($haystack, $key));
257	12	if (false !== $index) {
258		return $haystack[$index];
259		}
260	12	return false;
261		}
262
263		/**
264		* Set a value to an array of values using a dot-notation path as reference.
265		* @param mixed $data
266		* @param string $path
267		* @param mixed $value
268		* @return array
269		*/
270	25	public static function set($data, $path, $value)
271		{
272	25	$token = strtok($path, '.');
273	25	$ref = &$data;
274	25	while (false !== $token) {
275	25	if (is_object($ref)) {
276	1	$ref = &$ref->$token;
277		} else {
278	25	$ref = static::consolidate($ref);
279	25	$ref = &$ref[$token];
280		}
281	25	$token = strtok('.');
282		}
283	25	$ref = $value;
284	25	return $data;
285		}
286
287		/**
288		* @return array
289		*/
290	27	public static function unique(array $values)
291		{
292		return Helper::ifTrue(!static::isIndexedAndFlat($values), $values, function () use ($values) {
293	27	return array_filter(array_unique($values));
294	27	});
295		}
296
297		/**
298		* @param array\|string $values
299		* @return array
300		*/
301	26	public static function uniqueInt($values)
302		{
303	26	$values = array_filter(static::convertFromString($values), 'is_numeric');
304	26	return static::reindex(static::unique(array_values(array_map('absint', $values))));
305		}
306
307		/**
308		* @return array
309		*/
310	15	public static function unprefixKeys(array $values, $prefix = '_')
311		{
312	15	return static::prefixKeys($values, $prefix, false);
313		}
314		}
315

pryley / site-reviews

Push — master ( b318ac...f0530b )

Arr::uniqueInt() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like