Arr::shuffle() - Code Metrics - Inspection of "add values on arr" - bavix/helpers - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( c7f67f...b7b336 )

by Бабичев

created 2017-09-25 12:04 UTC

Arr::shuffle() A

↳ Parent: Arr

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

<?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 \Traversable $iterator
     *
     * @return array
     */
    public static function iterator($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 int    $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 \Traversable $iterator
242		*
243		* @return array
244		*/
245	1	public static function iterator($iterator)
246		{
247	1	return \iterator_to_array($iterator);
248		}
249
250		/**
251		* @param array $storage
252		*
253		* @return array
254		*/
255	2	public static function getValues(array $storage)
256		{
257	2	return \array_values($storage);
258		}
259
260		/**
261		* @param array $storage
262		*
263		* @return array
264		*/
265	2	public static function getKeys(array $storage)
266		{
267	2	return \array_keys($storage);
268		}
269
270		/**
271		* @param string $offset
272		*
273		* @return array
274		*/
275	7	public static function keys($offset)
276		{
277	7	$offset = \trim($offset);
278	7	$offset = \preg_replace('~\[(?<s>[\'"]?)(.*?)(\k<s>)\]~u', '.$2', $offset);
279
280	7	return \explode('.', $offset);
281		}
282
283		/**
284		* @param array $storage
285		* @param string $key
286		*
287		* @return bool
288		*/
289	5	public static function keyExists(array $storage, $key)
290		{
291	5	return isset($storage[$key]) \|\| \array_key_exists($key, $storage);
292		}
293
294		/**
295		* @param array $storage
296		* @param string $key
297		*
298		* @return mixed
299		*/
300	1	public static function at(array $storage, $key)
301		{
302	1	return $storage[$key];
303		}
304
305		/**
306		* @param array $storage
307		* @param string $key
308		* @param int $value
309		*/
310	1	public static function initOrPush(array &$storage, $key, $value)
311		{
312	1	if (empty($storage[$key]))
313		{
314	1	$storage[$key] = [];
315		}
316
317	1	$storage[$key][] = $value;
318	1	}
319
320		/**
321		* @param array $storage
322		* @param string $path
323		* @param string $lastKey
324		*
325		* @return array
326		*/
327	2	protected static function &link(array &$storage, $path, &$lastKey)
328		{
329	2	$keys = static::keys($path);
330	2	$lastKey = \array_pop($keys);
331	2	$rows = &$storage;
332
333	2	foreach ($keys as $key)
334		{
335	1	if (!static::keyExists($rows, $key))
336		{
337	1	$rows[$key] = [];
338		}
339	1	$rows = &$rows[$key];
340		}
341
342	2	return $rows;
343		}
344
345		}
346

bavix / helpers

Push — master ( c7f67f...b7b336 )

Arr::shuffle() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like