Arr::in() - Code Metrics - bavix/helpers - Measure and Improve Code Quality continuously with Scrutinizer

Arr::in() A
last analyzed 2019-06-03 08:35 UTC

↳ Parent: Arr

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

<?php

namespace Bavix\Helpers;

use Bavix\Exceptions;
use Bavix\Exceptions\NotFound;

class Arr
{

    /**
     * @param array    $storage
     * @param callable $callback
     *
     * @return bool
     */
    public static function walkRecursive(array &$storage, callable $callback)
    {
        return \array_walk_recursive($storage, $callback);
    }

    /**
     * @param array    $storage
     * @param callable $callback
     *
     * @return array
     */
    public static function map(array $storage, $callback)
    {
        return \array_map($callback, $storage);
    }

    /**
     * @param array $storage
     * @param int   $offset
     * @param int   $length
     *
     * @return array
     */
    public static function slice(array $storage, $offset, $length = null)
    {
        return \array_slice($storage, $offset, $length);
    }

    /**
     * @param array   $first
     * @param array[] ...$second
     *
     * @return array
     */
    public static function merge(array $first, array ...$second)
    {
        return \array_merge($first, ...$second);
    }

    /**
     * @param array    $storage
     * @param callable $callback
     *
     * @return array
     */
    public static function filter(array $storage, $callback)
    {
        return \array_filter($storage, $callback, ARRAY_FILTER_USE_BOTH);
    }

    /**
     * @param     $string
     * @param     $length
     * @param int $start
     *
     * @return array
     */
    public static function fill($string, $length, $start = 0)
    {
        return \array_fill($start, $length, $string);
    }

    /**
     * @param mixed $begin
     * @param mixed $end
     * @param int   $step
     *
     * @return array
     */
    public static function range($begin, $end, $step = 1)
    {
        return \range($begin, $end, $step);
    }

    /**
     * @param array $storage
     * @param mixed $needle
     * @param bool  $strict
     *
     * @return bool
     */
    public static function in(array $storage, $needle, $strict = true)
    {
        return \in_array($needle, $storage, $strict);
    }

    /**
     * @param array $storage
     *
     * @return bool
     */
    public static function shuffle(array &$storage)
    {
        return \shuffle($storage);
    }

    /**
     * @param array  $storage
     * @param string $path
     * @param mixed  $value
     */
    public static function set(array &$storage, $path, $value)
    {
        $rows           = &static::link($storage, $path, $lastKey);
        $rows[$lastKey] = $value;
    }

    /**
     * @param array  $storage
     * @param string $path
     */
    public static function remove(array &$storage, $path)
    {
        $rows = &static::link($storage, $path, $lastKey);
        unset($rows[$lastKey]);
    }

    /**
     * @param array $storage
     * @param string $key
     *
     * @return array|mixed
     *
     * @throws NotFound\Path
     * @throws Exceptions\Blank
     */
    public static function getRequired(array $storage, $key)
    {
        return static::findPath($storage, static::keys($key));
    }

    /**
     * @param array $storage
     * @param array $keys
     *
     * @return array|mixed
     *
     * @throws NotFound\Path
     * @throws Exceptions\Blank
     */
    protected static function findPath(array $storage, array $keys)
    {
        if (!count($keys) || $keys[0] === '')
        {
            throw new Exceptions\Blank('Not found keys');
        }

        $rows = &$storage;

        foreach ($keys as $key)
        {
            if (!static::keyExists($rows, $key))
            {
                throw new NotFound\Path('Path `' . implode('.', $keys) . '` not found');
            }

            $rows = &$rows[$key];
        }

        return $rows;
    }

    /**
     * @param array $storage
     * @param       $mixed
     *
     * @return int
     */
    public static function push(array &$storage, $mixed)
    {
        return \array_push($storage, $mixed);
    }

    /**
     * @param array $storage
     *
     * @return mixed
     */
    public static function pop(array &$storage)
    {
        return \array_pop($storage);
    }

    /**
     * @param array $storage
     *
     * @return mixed
     */
    public static function shift(array &$storage)
    {
        return \array_shift($storage);
    }

    /**
     * @param array $storage
     * @param       $mixed
     *
     * @return int
     */
    public static function unShift(array &$storage, $mixed)
    {
        return \array_unshift($storage, $mixed);
    }

    /**
     * @param array  $storage
     * @param string $key
     * @param mixed  $default
     *
     * @return mixed
     */
    public static function get(array $storage, $key, $default = null)
    {
        try
        {
            return static::findPath($storage, static::keys($key));
        }
        catch (\InvalidArgumentException $argumentException)
        {
            return $default;
        }
    }

    /**
     * @param array|\Traversable $iterator
     *
     * @return array
     */
    public static function iterator($iterator)
    {
        if (\is_array($iterator))
        {
            return $iterator;
        }
        
        return \iterator_to_array($iterator);
    }
    
    /**
     * @param array $storage
     *
     * @return array
     */
    public static function getValues(array $storage)
    {
        return \array_values($storage);
    }

    /**
     * @param array $storage
     *
     * @return array
     */
    public static function getKeys(array $storage)
    {
        return \array_keys($storage);
    }

    /**
     * @param string $offset
     *
     * @return array
     */
    public static function keys($offset)
    {
        $offset = \trim($offset);
        $offset = \preg_replace('~\[(?<s>[\'"]?)(.*?)(\k<s>)\]~u', '.$2', $offset);

        return \explode('.', $offset);
    }

    /**
     * @param array  $storage
     * @param string $key
     *
     * @return bool
     */
    public static function keyExists(array $storage, $key)
    {
        return isset($storage[$key]) || \array_key_exists($key, $storage);
    }

    /**
     * @param array  $storage
     * @param string $key
     *
     * @return mixed
     */
    public static function at(array $storage, $key)
    {
        return $storage[$key];
    }

    /**
     * @param array  $storage
     * @param string $key
     * @param mixed  $value
     */
    public static function initOrPush(array &$storage, $key, $value)
    {
        if (empty($storage[$key]))
        {
            $storage[$key] = [];
        }

        $storage[$key][] = $value;
    }

    /**
     * @param array  $storage
     * @param string $path
     * @param string $lastKey
     *
     * @return array
     */
    protected static function &link(array &$storage, $path, &$lastKey)
    {
        $keys    = static::keys($path);
        $lastKey = \array_pop($keys);
        $rows    = &$storage;

        foreach ($keys as $key)
        {
            if (!static::keyExists($rows, $key))
            {
                $rows[$key] = [];
            }
            $rows = &$rows[$key];
        }

        return $rows;
    }

}


1		<?php
2
3		namespace Bavix\Helpers;
4
5		use Bavix\Exceptions;
6		use Bavix\Exceptions\NotFound;
7
8		class Arr
9		{
10
11		/**
12		* @param array $storage
13		* @param callable $callback
14		*
15		* @return bool
16		*/
17	1	public static function walkRecursive(array &$storage, callable $callback)
18		{
19	1	return \array_walk_recursive($storage, $callback);
20		}
21
22		/**
23		* @param array $storage
24		* @param callable $callback
25		*
26		* @return array
27		*/
28	1	public static function map(array $storage, $callback)
29		{
30	1	return \array_map($callback, $storage);
31		}
32
33		/**
34		* @param array $storage
35		* @param int $offset
36		* @param int $length
37		*
38		* @return array
39		*/
40	1	public static function slice(array $storage, $offset, $length = null)
41		{
42	1	return \array_slice($storage, $offset, $length);
43		}
44
45		/**
46		* @param array $first
47		* @param array[] ...$second
48		*
49		* @return array
50		*/
51	1	public static function merge(array $first, array ...$second)
52		{
53	1	return \array_merge($first, ...$second);
54		}
55
56		/**
57		* @param array $storage
58		* @param callable $callback
59		*
60		* @return array
61		*/
62	1	public static function filter(array $storage, $callback)
63		{
64	1	return \array_filter($storage, $callback, ARRAY_FILTER_USE_BOTH);
65		}
66
67		/**
68		* @param $string
69		* @param $length
70		* @param int $start
71		*
72		* @return array
73		*/
74	1	public static function fill($string, $length, $start = 0)
75		{
76	1	return \array_fill($start, $length, $string);
77		}
78
79		/**
80		* @param mixed $begin
81		* @param mixed $end
82		* @param int $step
83		*
84		* @return array
85		*/
86	1	public static function range($begin, $end, $step = 1)
87		{
88	1	return \range($begin, $end, $step);
89		}
90
91		/**
92		* @param array $storage
93		* @param mixed $needle
94		* @param bool $strict
95		*
96		* @return bool
97		*/
98	1	public static function in(array $storage, $needle, $strict = true)
99		{
100	1	return \in_array($needle, $storage, $strict);
101		}
102
103		/**
104		* @param array $storage
105		*
106		* @return bool
107		*/
108	1	public static function shuffle(array &$storage)
109		{
110	1	return \shuffle($storage);
111		}
112
113		/**
114		* @param array $storage
115		* @param string $path
116		* @param mixed $value
117		*/
118	1	public static function set(array &$storage, $path, $value)
119		{
120	1	$rows = &static::link($storage, $path, $lastKey);
121	1	$rows[$lastKey] = $value;
122	1	}
123
124		/**
125		* @param array $storage
126		* @param string $path
127		*/
128	1	public static function remove(array &$storage, $path)
129		{
130	1	$rows = &static::link($storage, $path, $lastKey);
131	1	unset($rows[$lastKey]);
132	1	}
133
134		/**
135		* @param array $storage
136		* @param string $key
137		*
138		* @return array\|mixed
139		*
140		* @throws NotFound\Path
141		* @throws Exceptions\Blank
142		*/
143	3	public static function getRequired(array $storage, $key)
144		{
145	3	return static::findPath($storage, static::keys($key));
146		}
147
148		/**
149		* @param array $storage
150		* @param array $keys
151		*
152		* @return array\|mixed
153		*
154		* @throws NotFound\Path
155		* @throws Exceptions\Blank
156		*/
157	6	protected static function findPath(array $storage, array $keys)
158		{
159	6	if (!count($keys) \|\| $keys[0] === '')
160		{
161	1	throw new Exceptions\Blank('Not found keys');
162		}
163
164	5	$rows = &$storage;
165
166	5	foreach ($keys as $key)
167		{
168	5	if (!static::keyExists($rows, $key))
169		{
170	2	throw new NotFound\Path('Path `' . implode('.', $keys) . '` not found');
171		}
172
173	4	$rows = &$rows[$key];
174		}
175
176	4	return $rows;
177		}
178
179		/**
180		* @param array $storage
181		* @param $mixed
182		*
183		* @return int
184		*/
185	1	public static function push(array &$storage, $mixed)
186		{
187	1	return \array_push($storage, $mixed);
188		}
189
190		/**
191		* @param array $storage
192		*
193		* @return mixed
194		*/
195	1	public static function pop(array &$storage)
196		{
197	1	return \array_pop($storage);
198		}
199
200		/**
201		* @param array $storage
202		*
203		* @return mixed
204		*/
205	1	public static function shift(array &$storage)
206		{
207	1	return \array_shift($storage);
208		}
209
210		/**
211		* @param array $storage
212		* @param $mixed
213		*
214		* @return int
215		*/
216	1	public static function unShift(array &$storage, $mixed)
217		{
218	1	return \array_unshift($storage, $mixed);
219		}
220
221		/**
222		* @param array $storage
223		* @param string $key
224		* @param mixed $default
225		*
226		* @return mixed
227		*/
228	3	public static function get(array $storage, $key, $default = null)
229		{
230		try
231		{
232	3	return static::findPath($storage, static::keys($key));
233		}
234	1	catch (\InvalidArgumentException $argumentException)
235		{
236	1	return $default;
237		}
238		}
239
240		/**
241		* @param array\|\Traversable $iterator
242		*
243		* @return array
244		*/
245	1	public static function iterator($iterator)
246		{
247	1	if (\is_array($iterator))
248		{
249		return $iterator;
250		}
251
252	1	return \iterator_to_array($iterator);
253		}
254
255		/**
256		* @param array $storage
257		*
258		* @return array
259		*/
260	2	public static function getValues(array $storage)
261		{
262	2	return \array_values($storage);
263		}
264
265		/**
266		* @param array $storage
267		*
268		* @return array
269		*/
270	2	public static function getKeys(array $storage)
271		{
272	2	return \array_keys($storage);
273		}
274
275		/**
276		* @param string $offset
277		*
278		* @return array
279		*/
280	7	public static function keys($offset)
281		{
282	7	$offset = \trim($offset);
283	7	$offset = \preg_replace('~\[(?<s>[\'"]?)(.*?)(\k<s>)\]~u', '.$2', $offset);
284
285	7	return \explode('.', $offset);
286		}
287
288		/**
289		* @param array $storage
290		* @param string $key
291		*
292		* @return bool
293		*/
294	7	public static function keyExists(array $storage, $key)
295		{
296	7	return isset($storage[$key]) \|\| \array_key_exists($key, $storage);
297		}
298
299		/**
300		* @param array $storage
301		* @param string $key
302		*
303		* @return mixed
304		*/
305	1	public static function at(array $storage, $key)
306		{
307	1	return $storage[$key];
308		}
309
310		/**
311		* @param array $storage
312		* @param string $key
313		* @param mixed $value
314		*/
315	1	public static function initOrPush(array &$storage, $key, $value)
316		{
317	1	if (empty($storage[$key]))
318		{
319	1	$storage[$key] = [];
320		}
321
322	1	$storage[$key][] = $value;
323	1	}
324
325		/**
326		* @param array $storage
327		* @param string $path
328		* @param string $lastKey
329		*
330		* @return array
331		*/
332	2	protected static function &link(array &$storage, $path, &$lastKey)
333		{
334	2	$keys = static::keys($path);
335	2	$lastKey = \array_pop($keys);
336	2	$rows = &$storage;
337
338	2	foreach ($keys as $key)
339		{
340	1	if (!static::keyExists($rows, $key))
341		{
342	1	$rows[$key] = [];
343		}
344	1	$rows = &$rows[$key];
345		}
346
347	2	return $rows;
348		}
349
350		}
351

bavix / helpers

Arr::in() A last analyzed 2019-06-03 08:35 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Arr::in() A
last analyzed 2019-06-03 08:35 UTC