Issues in Transform.php - New Issues - Inspection of "remove satic from function | change unDot" - narrowspark/arr - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( eb5437...e70327 )

by Daniel

created 2016-06-08 21:44 UTC

src/Arr/Transform.php (1 issue)

Labels

Documentation 1

Severity

Minor 1

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php
namespace Narrowspark\Arr;

class Transform
{
    /**
     * Dotted array cache.
     *
     * @var array
     */
    protected $dotted = [];

    /**
     * A instance of Access
     *
     * @var \Narrowspark\Arr\Access
     */
    protected $access;

    /**
     * A instance of Access
     *
     * @var \Narrowspark\Arr\Enumerator
     */
    protected $enumerator;

    public function __construct()
    {
        $this->access = new Access();
        $this->enumerator = new Enumerator();
    }

    /**
     * Pop value from sub array.
     *
     * @param array  $array
     * @param string $key
     *
     * @return mixed
     */
    public static function pop(array $array, $key)
    {
        $keys = explode('.', $key);

        foreach ($keys as $key) {
            if (! isset($array[$key])) {
                return;
            }

            $array = $array[$key];
        }

        if (! is_array($array)) {
            return;
        }

        return array_pop($array);
    }

    /**
     * Swap two elements between positions.
     *
     * @param array  $array array to swap
     * @param string $swapA
     * @param string $swapB
     *
     * @return array|null
     */
    public function swap(array $array, $swapA, $swapB)
    {
        list($array[$swapA], $array[$swapB]) = [$array[$swapB], $array[$swapA]];

        return $array;
    }

    /**
     * Create a new array consisting of every n-th element.
     *
     * @param array $array
     * @param int   $step
     * @param int   $offset
     *
     * @return array
     */
    public static function every($array, $step, $offset = 0)
    {
        $new = [];

        $position = 0;

        foreach ($array as $key => $item) {
            if ($position % $step === $offset) {
                $new[] = $item;
            }

            ++$position;
        }

        return $new;
    }

    /**
     * Indexes an array depending on the values it contains.
     *
     * @param array    $array
     * @param callable $callback  Function to combine values.
     * @param bool     $overwrite Should duplicate keys be overwritten?
     *
     * @return array Indexed values.
     */
    public function combine(array $array, callable $callback, $overwrite = true)
    {
        $combined = [];

        foreach ($array as $key => $value) {
            $combinator = call_user_func($callback, $value, $key);

            // fix for hhvm #1871 bug
            if (defined('HHVM_VERSION') && version_compare(HHVM_VERSION, '3.10.0', '<=')) {
                $combinator->next();
            }

            $index = $combinator->key();

            if ($overwrite || ! isset($combined[$index])) {
                $combined[$index] = $combinator->current();
            }
        }

        return $combined;
    }

    /**
     * Collapse a nested array down to an array of flat key=>value pairs
     */
    public function collapse(array $array)
    {
        $newArray = [];

        foreach ($array as $key => $value) {
            if (is_array($value)) {
                // strip any manually added '.'
                if (preg_match('/\./', $key)) {
                    $key = substr($key, 0, -2);
                }

                $this->recurseCollapse($value, $newArray, (array) $key);
            } else {
                $newArray[$key] = $value;
            }
        }

        return $newArray;
    }

    /**
     * Divide an array into two arrays. One with keys and the other with values.
     *
     * @param array $array
     *
     * @return array[]
     */
    public function divide($array)
    {
        return [array_keys($array), array_values($array)];
    }

    /**
     * Stripe all empty items.
     *
     * @param array $array
     *
     * @return array
     */
    public function stripEmpty(array $array)
    {
        return array_filter($array, function ($item) {
            if (is_null($item)) {
                return false;
            }

            if (! trim($item)) {
                return false;
            }

            return true;
        });
    }

    /**
     * Remove all instances of $ignore found in $elements (=== is used).
     *
     * @param array $array
     * @param array $ignore
     *
     * @return array
     */
    public function without(array $array, array $ignore)
    {
        foreach ($array as $key => $node) {
            if (in_array($node, $ignore, true)) {
                unset($array[$key]);
            }
        }

        return array_values($array);
    }

    /**
     * Reindexes a list of values.
     *
     * @param array $array
     * @param array $map      An map of correspondances of the form
     *                        ['currentIndex' => 'newIndex'].
     * @param bool  $unmapped Whether or not to keep keys that are not
     *                        remapped.
     *
     * @return array
     */
    public function reindex(array $array, array $map, $unmapped = true)
    {
        $reindexed = $unmapped
            ? $array
            : [];

        foreach ($map as $from => $to) {
            if (isset($array[$from])) {
                $reindexed[$to] = $array[$from];
            }
        }

        return $reindexed;
    }

    /**
     * Merges two or more arrays into one recursively.
     *
     * @param array $arrays.
     *
     * @return array
     */
    public function merge(array $arrays)
    {
        $args = func_get_args();
        $array = array_shift($args);

        while (! empty($args)) {
            $next = array_shift($args);

            foreach ($next as $key => $value) {
                if (is_int($key)) {
                    if (isset($array[$key])) {
                        $array[] = $value;
                    } else {
                        $array[$key] = $value;
                    }
                } elseif (is_array($value) && isset($array[$key]) && is_array($array[$key])) {
                    $array[$key] = $this->merge($array[$key], $value);
                } else {
                    $array[$key] = $value;
                }
            }
        }

        return $array;
    }

    /**
     *  Makes every value that is numerically indexed a key, given $default
     *  as value.
     *
     *  @param array $array
     *  @param mixed $default
     *
     *  @return array
     */
    public function normalize(array $array, $default)
    {
        $normalized = [];

        foreach ($array as $key => $value) {
            if (is_numeric($key)) {
                $key = $value;
                $value = $default;
            }

            $normalized[$key] = $value;
        }

        return $normalized;
    }

    /**
     * Extend one array with another.
     *
     * @param array $arrays
     *
     * @return array
     */
    public function extend(array $arrays)
    {
        $merged = [];

        foreach (func_get_args() as $array) {
            foreach ($array as $key => $value) {
                if (is_array($value) && $this->access->has($merged, $key) && is_array($merged[$key])) {
                    $merged[$key] = $this->extend($merged[$key], $value);
                } else {
                    $merged[$key] = $value;
                }
            }
        }

        return $merged;
    }

    /**
     * Transforms a 1-dimensional array into a multi-dimensional one,
     * exploding keys according to a separator.
     *
     * @param array $array
     *
     * @return array
     */
    public function asHierarchy(array $array)
    {
        $hierarchy = [];

        foreach ($array as $key => $value) {
            $segments = explode('.', $key);
            $valueSegment = array_pop($segments);
            $branch = &$hierarchy;

            foreach ($segments as $segment) {
                if (! isset($branch[$segment])) {
                    $branch[$segment] = [];
                }

                $branch = &$branch[$segment];
            }

            $branch[$valueSegment] = $value;
        }

        return $hierarchy;
    }

    /**
     * Separates elements from an array into groups.
     * The function maps an element to the key that will be used for grouping.
     * If no function is passed, the element itself will be used as key.
     *
     * @param array         $array
     * @param callable|null $callback
     *
     * @return array
     */
    public function groupBy(array $array, callable $callback = null)
    {
        $callback = $callback ?: function ($value) {
            return $value;
        };

        return array_reduce(
            $array,
            function ($buckets, $value) use ($callback) {
                $key = call_user_func($callback, $value);

                if (! array_key_exists($key, $buckets)) {
                    $buckets[$key] = [];
                }

                $buckets[$key][] = $value;

                return $buckets;
            },
            []
        );
    }

    /**
     * Flatten a multi-dimensional associative array with dots.
     *
     * @param array  $array
     * @param string $prepend
     *
     * @return array
     */
    public function dot($array, $prepend = '')
    {
        $cache = serialize(['array' => $array, 'prepend' => $prepend]);

        if (array_key_exists($cache, $this->dotted)) {
            return $this->dotted[$cache];
        }

        $results = [];

        foreach ($array as $key => $value) {
            if (is_array($value)) {
                $results = array_merge($results, $this->dot($value, $prepend . $key . '.'));
            } else {
                $results[$prepend . $key] = $value;
            }
        }

        return $this->dotted[$cache] = $results;
    }

    /**
     * Expand a dotted array. Acts the opposite way of Arr::dot().
     *
     * @param array $array
     * @param bool  $depth
     *
     * @return array
     */
    public function unDot($array, $depth = INF)
    {
        $results = [];

        foreach ($array as $key => $value) {
            if (count($dottedKeys = explode('.', $key, 2)) > 1) {
                $results[$dottedKeys[0]][$dottedKeys[1]] = $value;
            } else {
                $results[$key] = $value;
            }
        }

        foreach ($results as $key => $value) {
            if (is_array($value) && ! empty($value) && $depth > 1) {
                $results[$key] = $this->unDot($value, $depth - 1);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }
        }

        return $results;
    }

    /**
     * Flatten a nested array to a separated key.
     *
     * @param array       $array
     * @param string|null $separator
     * @param string      $prepend
     *
     * @return array
     */
    public function flatten(array $array, $separator = null, $prepend = '')
    {
        $flattened = [];

        foreach ($array as $key => $value) {
            if (is_array($value)) {
                $flattened = array_merge($flattened, $this->flatten($value, $separator, $prepend . $key . $separator));
            } else {
                $flattened[$prepend . $key] = $value;
            }
        }

        return $flattened;
    }

    /**
     * Expand a flattened array with dots to a multi-dimensional associative array.
     *
     * @param array  $array
     * @param string $prepend
     *
     * @return array
     */
    public function expand(array $array, $prepend = '')
    {
        $results = [];

        if ($prepend) {
            $prepend .= '.';
        }

        foreach ($array as $key => $value) {
            if ($prepend) {
                $pos = strpos($key, $prepend);

                if ($pos === 0) {
                    $key = substr($key, strlen($prepend));
                }
            }

            $results = $this->access->set($results, $key, $value);
        }

        return $results;
    }

    /**
     * Reset all numerical indexes of an array (start from zero).
     * Non-numerical indexes will stay untouched. Returns a new array.
     *
     * @param array      $array
     * @param bool|false $deep
     *
     * @return array
     */
    public function reset(array $array, $deep = false)
    {
        $target = [];

        foreach ($array as $key => $value) {
            if ($deep && is_array($value)) {
                $value = $this->reset($value);
            }

            if (is_numeric($key)) {
                $target[] = $value;
            } else {
                $target[$key] = $value;
            }
        }

        return $target;
    }

    /**
     * Extend one array with another. Non associative arrays will not be merged
     * but rather replaced.
     *
     * @param array $arrays
     *
     * @return array
     */
    public function extendDistinct(array $arrays)
    {
        $merged = [];

        foreach (func_get_args() as $array) {
            foreach ($array as $key => $value) {
                if (is_array($value) && $this->access->has($merged, $key) && is_array($merged[$key])) {
                    if ($this->enumerator->isAssoc($value) && $this->enumerator->isAssoc($merged[$key])) {
                        $merged[$key] = $this->extendDistinct($merged[$key], $value);

                        continue;
                    }
                }

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

        return $merged;
    }

    /**
     * Sort the array using the given callback.
     *
     * @param array    $array
     * @param callable $callback
     * @param int      $options
     * @param bool     $descending
     *
     * @return array
     */
    public function sort(array $array, callable $callback, $options = SORT_REGULAR, $descending = false)
    {
        $results = [];

        // First we will loop through the items and get the comparator from a callback
        // function which we were given. Then, we will sort the returned values and
        // and grab the corresponding values for the sorted keys from this array.
        foreach ($array as $key => $value) {
            $results[$key] = $callback($value, $key);
        }

        $descending ? arsort($results, $options)
                    : asort($results, $options);

        // Once we have sorted all of the keys in the array, we will loop through them
        // and grab the corresponding model so we can set the underlying items list
        // to the sorted version. Then we'll just return the collection instance.
        foreach (array_keys($results) as $key) {
            $results[$key] = $array[$key];
        }

        return $results;
    }

    /**
     * Recursively sort an array by keys and values.
     *
     * @param array $array
     *
     * @return array
     */
    public function sortRecursive(array $array)
    {
        foreach ($array as &$value) {
            if (is_array($value)) {
                $value = $this->sortRecursive($value);
            }
        }

        // sort associative array
        if ($this->enumerator->isAssoc($array)) {
            ksort($array);
            // sort regular array
        } else {
            sort($array);
        }

        return $array;
    }

    /**
     * Will turn each element in $arr into an array then appending
     * the associated indexs from the other arrays into this array as well.
     *
     * @param array $array
     * @param array $arrays
     *
     * @return array
     */
    public function zip(array $array, array $arrays)
    {
        $args = func_get_args();
        array_shift($args);

        foreach ($array as $key => $value) {
            $array[$key] = [$value];

            foreach ($args as $k => $v) {
                $array[$key][] = current($args[$k]);

                if (next($args[$k]) === false && $args[$k] !== [null]) {
                    $args[$k] = [null];
                }
            }
        }

        return $array;
    }

    /**
     * Recurse through an array, add the leaf items to the $newArray var
     *
     * @param array $subject
     * @param array &$newArray
     * @param array $stack
     *
     * @return string[]|null
     */
    private function recurseCollapse(array $subject, array &$newArray, $stack = [])
    {
        foreach ($subject as $key => $value) {
            $fstack = array_merge($stack, [$key]);

            if (is_array($value)) {
                $this->recurseCollapse($value, $newArray, $fstack);
            } else {
                $top = array_shift($fstack);
                $arrayPart = count($fstack) ? '.' . implode('.', $fstack) : '';
                $newArray[$top . $arrayPart] = $value;
            }
        }
    }
}


1			<?php
2			namespace Narrowspark\Arr;
3
4			class Transform
5			{
6			/**
7			* Dotted array cache.
8			*
9			* @var array
10			*/
11			protected $dotted = [];
12
13			/**
14			* A instance of Access
15			*
16			* @var \Narrowspark\Arr\Access
17			*/
18			protected $access;
19
20			/**
21			* A instance of Access
22			*
23			* @var \Narrowspark\Arr\Enumerator
24			*/
25			protected $enumerator;
26
27	50		public function __construct()
28			{
29	50		$this->access = new Access();
30	50		$this->enumerator = new Enumerator();
31	50		}
32
33			/**
34			* Pop value from sub array.
35			*
36			* @param array $array
37			* @param string $key
38			*
39			* @return mixed
40			*/
41	1		public static function pop(array $array, $key)
42			{
43	1		$keys = explode('.', $key);
44
45	1		foreach ($keys as $key) {
46	1		if (! isset($array[$key])) {
47	1		return;
48			}
49
50	1		$array = $array[$key];
51	1		}
52
53	1		if (! is_array($array)) {
54	1		return;
55			}
56
57	1		return array_pop($array);
58			}
59
60			/**
61			* Swap two elements between positions.
62			*
63			* @param array $array array to swap
64			* @param string $swapA
65			* @param string $swapB
66			*
67			* @return array\|null
68			*/
69	1		public function swap(array $array, $swapA, $swapB)
70			{
71	1		list($array[$swapA], $array[$swapB]) = [$array[$swapB], $array[$swapA]];
72
73	1		return $array;
74			}
75
76			/**
77			* Create a new array consisting of every n-th element.
78			*
79			* @param array $array
80			* @param int $step
81			* @param int $offset
82			*
83			* @return array
84			*/
85	1		public static function every($array, $step, $offset = 0)
86			{
87	1		$new = [];
88
89	1		$position = 0;
90
91	1		foreach ($array as $key => $item) {
92	1		if ($position % $step === $offset) {
93	1		$new[] = $item;
94	1		}
95
96	1		++$position;
97	1		}
98
99	1		return $new;
100			}
101
102			/**
103			* Indexes an array depending on the values it contains.
104			*
105			* @param array $array
106			* @param callable $callback Function to combine values.
107			* @param bool $overwrite Should duplicate keys be overwritten?
108			*
109			* @return array Indexed values.
110			*/
111	1		public function combine(array $array, callable $callback, $overwrite = true)
112			{
113	1		$combined = [];
114
115	1		foreach ($array as $key => $value) {
116	1		$combinator = call_user_func($callback, $value, $key);
117
118			// fix for hhvm #1871 bug
119	1		if (defined('HHVM_VERSION') && version_compare(HHVM_VERSION, '3.10.0', '<=')) {
120			$combinator->next();
121			}
122
123	1		$index = $combinator->key();
124
125	1		if ($overwrite \|\| ! isset($combined[$index])) {
126	1		$combined[$index] = $combinator->current();
127	1		}
128	1		}
129
130	1		return $combined;
131			}
132
133			/**
134			* Collapse a nested array down to an array of flat key=>value pairs
135			*/
136	3		public function collapse(array $array)
137			{
138	3		$newArray = [];
139
140	3		foreach ($array as $key => $value) {
141	3		if (is_array($value)) {
142			// strip any manually added '.'
143	3		if (preg_match('/\./', $key)) {
144	2		$key = substr($key, 0, -2);
145	2		}
146
147	3		$this->recurseCollapse($value, $newArray, (array) $key);
148	3		} else {
149	1		$newArray[$key] = $value;
150			}
151	3		}
152
153	3		return $newArray;
154			}
155
156			/**
157			* Divide an array into two arrays. One with keys and the other with values.
158			*
159			* @param array $array
160			*
161			* @return array[]
162			*/
163	1		public function divide($array)
164			{
165	1		return [array_keys($array), array_values($array)];
166			}
167
168			/**
169			* Stripe all empty items.
170			*
171			* @param array $array
172			*
173			* @return array
174			*/
175	1		public function stripEmpty(array $array)
176			{
177			return array_filter($array, function ($item) {
178	1		if (is_null($item)) {
179	1		return false;
180			}
181
182	1		if (! trim($item)) {
183	1		return false;
184			}
185
186	1		return true;
187	1		});
188			}
189
190			/**
191			* Remove all instances of $ignore found in $elements (=== is used).
192			*
193			* @param array $array
194			* @param array $ignore
195			*
196			* @return array
197			*/
198	1		public function without(array $array, array $ignore)
199			{
200	1		foreach ($array as $key => $node) {
201	1		if (in_array($node, $ignore, true)) {
202	1		unset($array[$key]);
203	1		}
204	1		}
205
206	1		return array_values($array);
207			}
208
209			/**
210			* Reindexes a list of values.
211			*
212			* @param array $array
213			* @param array $map An map of correspondances of the form
214			* ['currentIndex' => 'newIndex'].
215			* @param bool $unmapped Whether or not to keep keys that are not
216			* remapped.
217			*
218			* @return array
219			*/
220	1		public function reindex(array $array, array $map, $unmapped = true)
221			{
222			$reindexed = $unmapped
223	1		? $array
224	1		: [];
225
226	1		foreach ($map as $from => $to) {
227	1		if (isset($array[$from])) {
228	1		$reindexed[$to] = $array[$from];
229	1		}
230	1		}
231
232	1		return $reindexed;
233			}
234
235			/**
236			* Merges two or more arrays into one recursively.
237			*
238			* @param array $arrays.
239			*
240			* @return array
241			*/
242	4		public function merge(array $arrays)
243			{
244	4		$args = func_get_args();
245	4		$array = array_shift($args);
246
247	4		while (! empty($args)) {
248	4		$next = array_shift($args);
249
250	4		foreach ($next as $key => $value) {
251	4		if (is_int($key)) {
252	3		if (isset($array[$key])) {
253	2		$array[] = $value;
254	2		} else {
255	1		$array[$key] = $value;
256			}
257	4		} elseif (is_array($value) && isset($array[$key]) && is_array($array[$key])) {
258	1		$array[$key] = $this->merge($array[$key], $value);
259	1		} else {
260	2		$array[$key] = $value;
261			}
262	4		}
263	4		}
264
265	4		return $array;
266			}
267
268			/**
269			* Makes every value that is numerically indexed a key, given $default
270			* as value.
271			*
272			* @param array $array
273			* @param mixed $default
274			*
275			* @return array
276			*/
277	1		public function normalize(array $array, $default)
278			{
279	1		$normalized = [];
280
281	1		foreach ($array as $key => $value) {
282	1		if (is_numeric($key)) {
283	1		$key = $value;
284	1		$value = $default;
285	1		}
286
287	1		$normalized[$key] = $value;
288	1		}
289
290	1		return $normalized;
291			}
292
293			/**
294			* Extend one array with another.
295			*
296			* @param array $arrays
297			*
298			* @return array
299			*/
300	3		public function extend(array $arrays)
301			{
302	3		$merged = [];
303
304	3		foreach (func_get_args() as $array) {
305	3		foreach ($array as $key => $value) {
306	3		if (is_array($value) && $this->access->has($merged, $key) && is_array($merged[$key])) {
307	2		$merged[$key] = $this->extend($merged[$key], $value);
308	2		} else {
309	3		$merged[$key] = $value;
310			}
311	3		}
312	3		}
313
314	3		return $merged;
315			}
316
317			/**
318			* Transforms a 1-dimensional array into a multi-dimensional one,
319			* exploding keys according to a separator.
320			*
321			* @param array $array
322			*
323			* @return array
324			*/
325	1		public function asHierarchy(array $array)
326			{
327	1		$hierarchy = [];
328
329	1		foreach ($array as $key => $value) {
330	1		$segments = explode('.', $key);
331	1		$valueSegment = array_pop($segments);
332	1		$branch = &$hierarchy;
333
334	1		foreach ($segments as $segment) {
335	1		if (! isset($branch[$segment])) {
336	1		$branch[$segment] = [];
337	1		}
338
339	1		$branch = &$branch[$segment];
340	1		}
341
342	1		$branch[$valueSegment] = $value;
343	1		}
344
345	1		return $hierarchy;
346			}
347
348			/**
349			* Separates elements from an array into groups.
350			* The function maps an element to the key that will be used for grouping.
351			* If no function is passed, the element itself will be used as key.
352			*
353			* @param array $array
354			* @param callable\|null $callback
355			*
356			* @return array
357			*/
358	1		public function groupBy(array $array, callable $callback = null)
359			{
360			$callback = $callback ?: function ($value) {
361	1		return $value;
362	1		};
363
364	1		return array_reduce(
365	1		$array,
366	1		function ($buckets, $value) use ($callback) {
367	1		$key = call_user_func($callback, $value);
368
369	1		if (! array_key_exists($key, $buckets)) {
370	1		$buckets[$key] = [];
371	1		}
372
373	1		$buckets[$key][] = $value;
374
375	1		return $buckets;
376	1		},
377	1		[]
378	1		);
379			}
380
381			/**
382			* Flatten a multi-dimensional associative array with dots.
383			*
384			* @param array $array
385			* @param string $prepend
386			*
387			* @return array
388			*/
389	4		public function dot($array, $prepend = '')
390			{
391	4		$cache = serialize(['array' => $array, 'prepend' => $prepend]);
392
393	4		if (array_key_exists($cache, $this->dotted)) {
394	1		return $this->dotted[$cache];
395			}
396
397	4		$results = [];
398
399	4	View Code Duplication	foreach ($array as $key => $value) {
400	4		if (is_array($value)) {
401	2		$results = array_merge($results, $this->dot($value, $prepend . $key . '.'));
402	2		} else {
403	4		$results[$prepend . $key] = $value;
404			}
405	4		}
406
407	4		return $this->dotted[$cache] = $results;
408			}
409
410			/**
411			* Expand a dotted array. Acts the opposite way of Arr::dot().
412			*
413			* @param array $array
414			* @param bool $depth
415			*
416			* @return array
417			*/
418	10		public function unDot($array, $depth = INF)
419			{
420	10		$results = [];
421
422	10		foreach ($array as $key => $value) {
423	9		if (count($dottedKeys = explode('.', $key, 2)) > 1) {
424	9		$results[$dottedKeys[0]][$dottedKeys[1]] = $value;
425	9		} else {
426	6		$results[$key] = $value;
427			}
428	10		}
429
430	10		foreach ($results as $key => $value) {
431	9		if (is_array($value) && ! empty($value) && $depth > 1) {
432	7		$results[$key] = $this->unDot($value, $depth - 1);
			0 ignored issues – show Documentation introduced 2016-06-08 21:47 UTC by Report Bug Copy Issue Report Show Similar Issues like this `$depth - 1` is of type `integer\|double`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
433	7		}
434	10		}
435
436	10		return $results;
437			}
438
439			/**
440			* Flatten a nested array to a separated key.
441			*
442			* @param array $array
443			* @param string\|null $separator
444			* @param string $prepend
445			*
446			* @return array
447			*/
448	1		public function flatten(array $array, $separator = null, $prepend = '')
449			{
450	1		$flattened = [];
451
452	1	View Code Duplication	foreach ($array as $key => $value) {
453	1		if (is_array($value)) {
454	1		$flattened = array_merge($flattened, $this->flatten($value, $separator, $prepend . $key . $separator));
455	1		} else {
456	1		$flattened[$prepend . $key] = $value;
457			}
458	1		}
459
460	1		return $flattened;
461			}
462
463			/**
464			* Expand a flattened array with dots to a multi-dimensional associative array.
465			*
466			* @param array $array
467			* @param string $prepend
468			*
469			* @return array
470			*/
471	4		public function expand(array $array, $prepend = '')
472			{
473	4		$results = [];
474
475	4		if ($prepend) {
476	2		$prepend .= '.';
477	2		}
478
479	4		foreach ($array as $key => $value) {
480	4		if ($prepend) {
481	2		$pos = strpos($key, $prepend);
482
483	2		if ($pos === 0) {
484	1		$key = substr($key, strlen($prepend));
485	1		}
486	2		}
487
488	4		$results = $this->access->set($results, $key, $value);
489	4		}
490
491	4		return $results;
492			}
493
494			/**
495			* Reset all numerical indexes of an array (start from zero).
496			* Non-numerical indexes will stay untouched. Returns a new array.
497			*
498			* @param array $array
499			* @param bool\|false $deep
500			*
501			* @return array
502			*/
503	3		public function reset(array $array, $deep = false)
504			{
505	3		$target = [];
506
507	3		foreach ($array as $key => $value) {
508	3		if ($deep && is_array($value)) {
509	1		$value = $this->reset($value);
510	1		}
511
512	3		if (is_numeric($key)) {
513	3		$target[] = $value;
514	3		} else {
515	3		$target[$key] = $value;
516			}
517	3		}
518
519	3		return $target;
520			}
521
522			/**
523			* Extend one array with another. Non associative arrays will not be merged
524			* but rather replaced.
525			*
526			* @param array $arrays
527			*
528			* @return array
529			*/
530	4		public function extendDistinct(array $arrays)
531			{
532	4		$merged = [];
533
534	4		foreach (func_get_args() as $array) {
535	4		foreach ($array as $key => $value) {
536	4		if (is_array($value) && $this->access->has($merged, $key) && is_array($merged[$key])) {
537	3		if ($this->enumerator->isAssoc($value) && $this->enumerator->isAssoc($merged[$key])) {
538	2		$merged[$key] = $this->extendDistinct($merged[$key], $value);
539
540	2		continue;
541			}
542	2		}
543
544	4		$merged[$key] = $value;
545	4		}
546	4		}
547
548	4		return $merged;
549			}
550
551			/**
552			* Sort the array using the given callback.
553			*
554			* @param array $array
555			* @param callable $callback
556			* @param int $options
557			* @param bool $descending
558			*
559			* @return array
560			*/
561	1		public function sort(array $array, callable $callback, $options = SORT_REGULAR, $descending = false)
562			{
563	1		$results = [];
564
565			// First we will loop through the items and get the comparator from a callback
566			// function which we were given. Then, we will sort the returned values and
567			// and grab the corresponding values for the sorted keys from this array.
568	1		foreach ($array as $key => $value) {
569	1		$results[$key] = $callback($value, $key);
570	1		}
571
572	1		$descending ? arsort($results, $options)
573	1		: asort($results, $options);
574
575			// Once we have sorted all of the keys in the array, we will loop through them
576			// and grab the corresponding model so we can set the underlying items list
577			// to the sorted version. Then we'll just return the collection instance.
578	1		foreach (array_keys($results) as $key) {
579	1		$results[$key] = $array[$key];
580	1		}
581
582	1		return $results;
583			}
584
585			/**
586			* Recursively sort an array by keys and values.
587			*
588			* @param array $array
589			*
590			* @return array
591			*/
592	1		public function sortRecursive(array $array)
593			{
594	1		foreach ($array as &$value) {
595	1		if (is_array($value)) {
596	1		$value = $this->sortRecursive($value);
597	1		}
598	1		}
599
600			// sort associative array
601	1		if ($this->enumerator->isAssoc($array)) {
602	1		ksort($array);
603			// sort regular array
604	1		} else {
605	1		sort($array);
606			}
607
608	1		return $array;
609			}
610
611			/**
612			* Will turn each element in $arr into an array then appending
613			* the associated indexs from the other arrays into this array as well.
614			*
615			* @param array $array
616			* @param array $arrays
617			*
618			* @return array
619			*/
620	2		public function zip(array $array, array $arrays)
621			{
622	2		$args = func_get_args();
623	2		array_shift($args);
624
625	2		foreach ($array as $key => $value) {
626	2		$array[$key] = [$value];
627
628	2		foreach ($args as $k => $v) {
629	2		$array[$key][] = current($args[$k]);
630
631	2		if (next($args[$k]) === false && $args[$k] !== [null]) {
632	1		$args[$k] = [null];
633	1		}
634	2		}
635	2		}
636
637	2		return $array;
638			}
639
640			/**
641			* Recurse through an array, add the leaf items to the $newArray var
642			*
643			* @param array $subject
644			* @param array &$newArray
645			* @param array $stack
646			*
647			* @return string[]\|null
648			*/
649	3		private function recurseCollapse(array $subject, array &$newArray, $stack = [])
650			{
651	3		foreach ($subject as $key => $value) {
652	3		$fstack = array_merge($stack, [$key]);
653
654	3		if (is_array($value)) {
655	3		$this->recurseCollapse($value, $newArray, $fstack);
656	3		} else {
657	3		$top = array_shift($fstack);
658	3		$arrayPart = count($fstack) ? '.' . implode('.', $fstack) : '';
659	3		$newArray[$top . $arrayPart] = $value;
660			}
661	3		}
662	3		}
663			}
664

narrowspark / arr

Push — master ( eb5437...e70327 )

src/Arr/Transform.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like