Arr::store() - Code Metrics - Inspection of "Upgrade project" - andrey-helldar/support - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#22)

by Andrey

created 2020-12-28 21:19 UTC

Arr::store() A

↳ Parent: Arr

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
cc	2
eloc	3
nc	2
nop	4
dl	0
loc	5
rs	10
c	1
b	1
f	0

<?php

namespace Helldar\Support\Helpers;

use ArrayAccess;
use Helldar\Support\Facades\Helpers\Filesystem\File;
use Helldar\Support\Facades\Tools\Stub;
use Helldar\Support\Tools\Stub as StubTool;

class Arr
{
    /**
     * Renaming array keys.
     * As the second parameter, a callback function is passed, which determines the actions for processing the value.
     * The output of the function must be a string with a name.
     *
     * @param  array  $array
     * @param  callable  $callback
     *
     * @return array
     */
    public function renameKeys(array $array, callable $callback): array
    {
        $result = [];

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

            $result[$new] = $value;
        }

        return $result;
    }

    /**
     * Renaming array keys with map.
     *
     * @param  array  $array
     * @param  array  $map
     *
     * @return array
     */
    public function renameKeysMap(array $array, array $map): array
    {
        return $this->renameKeys($array, static function ($key) use ($map) {
            return $map[$key] ?? $key;
        });
    }

    /**
     * Get the size of the longest text element of the array.
     *
     * @param  array  $array
     *
     * @return int
     */
    public function longestStringLength(array $array): int
    {
        return ! empty($array)
            ? max(array_map('mb_strlen', $array))
            : 0;
    }

    /**
     * Push one a unique element onto the end of array.
     *
     * @param  array  $array
     * @param  array|mixed  $values
     *
     * @return array
     */
    public function addUnique(array $array, $values): array
    {
        if ($this->isArrayable($values)) {
            foreach ($values as $value) {
                $array = $this->addUnique($array, $value);
            }
        } else {
            array_push($array, $values);
        }

        return array_values(array_unique($array));
    }

    /**
     * Sort an associative array in the order specified by an array of keys.
     *
     * Example:
     *
     *  $arr = ['q' => 1, 'r' => 2, 's' => 5, 'w' => 123];
     *
     *  Arr::sortByKeys($arr, ['q', 'w', 'e']);
     *
     * print_r($arr);
     *
     *   Array
     *   (
     *     [q] => 1
     *     [w] => 123
     *     [r] => 2
     *     [s] => 5
     *   )
     *
     * @see https://gist.github.com/Ellrion/a3145621f936aa9416f4c04987533d8d#file-helper-php
     *
     * @param  array  $array
     * @param  array  $sorter
     *
     * @return array
     */
    public function sortByKeys(array $array, array $sorter): array
    {
        $sorter = array_intersect($sorter, array_keys($array));
        $array  = array_merge(array_flip($sorter), $array);

        return $array;
    }

    /**
     * Merge one or more arrays recursively.
     * Don't forget that numeric keys NOT will be renumbered!
     *
     * @param  array[]  ...$arrays
     *
     * @return array
     */
    public function merge(...$arrays): array
    {
        $result = [];

        foreach ($arrays as $array) {
            foreach ($array as $key => $value) {
                if (is_array($value)) {
                    $value = $this->merge($result[$key] ?? [], $value);
                }

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

        ksort($result);

        return $result;
    }

    public function wrap($value = null): array
    {
        if (is_array($value)) {
            return $value;
        }

        return ! empty($value) ? [$value] : [];
    }

    public function toArray($value = null): array
    {
        if (is_object($value)) {
            $value = method_exists($value, 'toArray') ? $value->toArray() : get_object_vars($value);
        }

        $array = $this->wrap($value);

        foreach ($array as &$item) {
            $item = $this->isArrayable($item) ? $this->toArray($item) : $item;
        }

        return $array;
    }

    /**
     * @param  array|\ArrayAccess  $array
     * @param  mixed  $key
     *
     * @return bool
     */
    public function exists($array, $key): bool
    {
        return $array instanceof ArrayAccess
            ? $array->offsetExists($key)
            : isset($array[$key]);
    }

    public function get(array $array, $key, $default = null)
    {
        // TODO: $array[$key] ?? $default;
        return $this->exists($array, $key) ? $array[$key] : $default;
    }

    public function getKey(array $array, $key, $default = null)
    {
        return isset($array[$key]) ? $key : $default;
    }

    public function except(array $array, $keys): array
    {
        $keys = (array) $keys;

        return array_filter($array, static function ($key) use ($keys) {
            return empty($keys) || ! in_array($key, $keys);
        }, ARRAY_FILTER_USE_KEY);
    }

    /**
     * Get a subset of the items from the given array.
     *
     * @param  array  $array
     * @param  array|string  $keys
     *
     * @return array
     */
    public function only(array $array, $keys): array
    {
        return array_intersect_key($array, array_flip((array) $keys));
    }

    public function map(array $array, callable $callback): array
    {
        foreach ($array as $key => &$value) {
            $value = $callback($value, $key);
        }

        return $array;
    }

    public function isArrayable($value = null): bool
    {
        return is_array($value) || is_object($value) || $value instanceof ArrayAccess;
    }

    public function store(array $array, string $path, bool $is_json = false, bool $sort_keys = false): void
    {
        $is_json
            ? $this->storeAsJson($path, $array, $sort_keys)
            : $this->storeAsArray($path, $array, $sort_keys);
    }

    public function storeAsJson(string $path, array $array, bool $sort_keys = false): void
    {
        $this->prepareToStore($path, StubTool::JSON, $array, static function (array $array) {
            return json_encode($array);
        }, $sort_keys);
    }

    public function storeAsArray(string $path, array $array, bool $sort_keys = false): void
    {
        $this->prepareToStore($path, StubTool::PHP_ARRAY, $array, static function (array $array) {
            return var_export($array, true);
        }, $sort_keys);
    }

    protected function prepareToStore(string $path, string $stub, array $array, callable $replace, bool $sort_keys = false): void
    {
        if ($sort_keys) {
            ksort($array);
        }

        $content = Stub::replace($stub, [
            '{{slot}}' => $replace($array),
        ]);

        File::store($path, $content);
    }
}


1			<?php
2
3			namespace Helldar\Support\Helpers;
4
5			use ArrayAccess;
6			use Helldar\Support\Facades\Helpers\Filesystem\File;
7			use Helldar\Support\Facades\Tools\Stub;
8			use Helldar\Support\Tools\Stub as StubTool;
9
10			class Arr
11			{
12			/**
13			* Renaming array keys.
14			* As the second parameter, a callback function is passed, which determines the actions for processing the value.
15			* The output of the function must be a string with a name.
16			*
17			* @param array $array
18			* @param callable $callback
19			*
20			* @return array
21			*/
22			public function renameKeys(array $array, callable $callback): array
23			{
24			$result = [];
25
26			foreach ($array as $key => $value) {
27			$new = $callback($key, $value);
28
29			$result[$new] = $value;
30			}
31
32			return $result;
33			}
34
35			/**
36			* Renaming array keys with map.
37			*
38			* @param array $array
39			* @param array $map
40			*
41			* @return array
42			*/
43			public function renameKeysMap(array $array, array $map): array
44			{
45			return $this->renameKeys($array, static function ($key) use ($map) {
46			return $map[$key] ?? $key;
47			});
48			}
49
50			/**
51			* Get the size of the longest text element of the array.
52			*
53			* @param array $array
54			*
55			* @return int
56			*/
57			public function longestStringLength(array $array): int
58			{
59			return ! empty($array)
60			? max(array_map('mb_strlen', $array))
61			: 0;
62			}
63
64			/**
65			* Push one a unique element onto the end of array.
66			*
67			* @param array $array
68			* @param array\|mixed $values
69			*
70			* @return array
71			*/
72			public function addUnique(array $array, $values): array
73			{
74			if ($this->isArrayable($values)) {
75			foreach ($values as $value) {
76			$array = $this->addUnique($array, $value);
77			}
78			} else {
79			array_push($array, $values);
80			}
81
82			return array_values(array_unique($array));
83			}
84
85			/**
86			* Sort an associative array in the order specified by an array of keys.
87			*
88			* Example:
89			*
90			* $arr = ['q' => 1, 'r' => 2, 's' => 5, 'w' => 123];
91			*
92			* Arr::sortByKeys($arr, ['q', 'w', 'e']);
93			*
94			* print_r($arr);
95			*
96			* Array
97			* (
98			* [q] => 1
99			* [w] => 123
100			* [r] => 2
101			* [s] => 5
102			* )
103			*
104			* @see https://gist.github.com/Ellrion/a3145621f936aa9416f4c04987533d8d#file-helper-php
105			*
106			* @param array $array
107			* @param array $sorter
108			*
109			* @return array
110			*/
111			public function sortByKeys(array $array, array $sorter): array
112			{
113			$sorter = array_intersect($sorter, array_keys($array));
114			$array = array_merge(array_flip($sorter), $array);
115
116			return $array;
117			}
118
119			/**
120			* Merge one or more arrays recursively.
121			* Don't forget that numeric keys NOT will be renumbered!
122			*
123			* @param array[] ...$arrays
124			*
125			* @return array
126			*/
127			public function merge(...$arrays): array
128			{
129			$result = [];
130
131			foreach ($arrays as $array) {
132			foreach ($array as $key => $value) {
133			if (is_array($value)) {
134			$value = $this->merge($result[$key] ?? [], $value);
135			}
136
137			$result[$key] = $value;
138			}
139			}
140
141			ksort($result);
142
143			return $result;
144			}
145
146			public function wrap($value = null): array
147			{
148			if (is_array($value)) {
149			return $value;
150			}
151
152			return ! empty($value) ? [$value] : [];
153			}
154
155			public function toArray($value = null): array
156			{
157			if (is_object($value)) {
158			$value = method_exists($value, 'toArray') ? $value->toArray() : get_object_vars($value);
159			}
160
161			$array = $this->wrap($value);
162
163			foreach ($array as &$item) {
164			$item = $this->isArrayable($item) ? $this->toArray($item) : $item;
165			}
166
167			return $array;
168			}
169
170			/**
171			* @param array\|\ArrayAccess $array
172			* @param mixed $key
173			*
174			* @return bool
175			*/
176			public function exists($array, $key): bool
177			{
178			return $array instanceof ArrayAccess
179			? $array->offsetExists($key)
180			: isset($array[$key]);
181			}
182
183			public function get(array $array, $key, $default = null)
184			{
185			// TODO: $array[$key] ?? $default;
186			return $this->exists($array, $key) ? $array[$key] : $default;
187			}
188
189			public function getKey(array $array, $key, $default = null)
190			{
191			return isset($array[$key]) ? $key : $default;
192			}
193
194			public function except(array $array, $keys): array
195			{
196			$keys = (array) $keys;
197
198			return array_filter($array, static function ($key) use ($keys) {
199			return empty($keys) \|\| ! in_array($key, $keys);
200			}, ARRAY_FILTER_USE_KEY);
201			}
202
203			/**
204			* Get a subset of the items from the given array.
205			*
206			* @param array $array
207			* @param array\|string $keys
208			*
209			* @return array
210			*/
211			public function only(array $array, $keys): array
212			{
213			return array_intersect_key($array, array_flip((array) $keys));
214			}
215
216			public function map(array $array, callable $callback): array
217			{
218			foreach ($array as $key => &$value) {
219			$value = $callback($value, $key);
220			}
221
222			return $array;
223			}
224
225			public function isArrayable($value = null): bool
226			{
227			return is_array($value) \|\| is_object($value) \|\| $value instanceof ArrayAccess;
228			}
229
230			public function store(array $array, string $path, bool $is_json = false, bool $sort_keys = false): void
231			{
232			$is_json
233			? $this->storeAsJson($path, $array, $sort_keys)
234			: $this->storeAsArray($path, $array, $sort_keys);
235			}
236
237			public function storeAsJson(string $path, array $array, bool $sort_keys = false): void
238			{
239			$this->prepareToStore($path, StubTool::JSON, $array, static function (array $array) {
240			return json_encode($array);
241			}, $sort_keys);
242			}
243
244			public function storeAsArray(string $path, array $array, bool $sort_keys = false): void
245			{
246			$this->prepareToStore($path, StubTool::PHP_ARRAY, $array, static function (array $array) {
247			return var_export($array, true);
248			}, $sort_keys);
249			}
250
251			protected function prepareToStore(string $path, string $stub, array $array, callable $replace, bool $sort_keys = false): void
252			{
253			if ($sort_keys) {
254			ksort($array);
255			}
256
257			$content = Stub::replace($stub, [
258			'{{slot}}' => $replace($array),
259			]);
260
261			File::store($path, $content);
262			}
263			}
264

andrey-helldar / support

Pull Request — main (#22)

Arr::store() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like