Helldar\Support\Helpers\Arr

Complexity

Total Complexity

40

Size/Duplication

Total Lines	341
Duplicated Lines	0 %

Importance

Changes	6
Bugs	1	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	sortByKeys()	0	6	1
A	addUnique()	0	11	3
A	longestStringLength()	0	5	2
A	renameKeys()	0	11	2
A	renameKeysMap()	0	4	1
A	merge()	0	17	4
A	store()	0	5	2
A	only()	0	3	1
A	get()	0	3	1
A	map()	0	7	2
A	isArrayable()	0	3	3
A	wrap()	0	7	3
A	storeAsJson()	0	5	1
A	prepareToStore()	0	11	2
A	storeAsArray()	0	5	1
A	except()	0	7	2
A	exists()	0	7	2
A	toArray()	0	13	5
A	getKey()	0	3	2

<?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)) {

It seems like $values can also be of type array; however, parameter $value of Helldar\Support\Helpers\Arr::isArrayable() does only seem to accept null, maybe add an additional type check?

            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;
    }

    /**
     * If the given value is not an array and not null, wrap it in one.
     *
     * @param  null  $value

Are you sure the doc-type for parameter $value is correct as it would always require null to be passed?

     *
     * @return array
     */
    public function wrap($value = null): array
    {
        if (is_array($value)) {

The condition is_array($value) is always false.

            return $value;
        }

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

    /**
     * Get the instance as an array.
     *
     * @param  mixed  $value
     *
     * @return array
     */
    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;
    }

    /**
     * Determine if the given key exists in the provided array.
     *
     * @param  array|\ArrayAccess  $array
     * @param  mixed  $key
     *
     * @return bool
     */
    public function exists($array, $key): bool
    {
        if ($array instanceof ArrayAccess) {
            return $array->offsetExists($key);
        }

        return isset($array[$key]);
    }

    /**
     * Get an item from an array.
     *
     * @param  array|ArrayAccess  $array
     * @param  mixed  $key
     * @param  mixed|null  $default
     *
     * @return mixed|null
     */
    public function get($array, $key, $default = null)
    {
        return $array[$key] ?? $default;
    }

    /**
     * If the element key exists, then return the name of the key, otherwise the default value.
     *
     * @param  array|ArrayAccess  $array
     * @param  mixed  $key
     * @param  null  $default

Are you sure the doc-type for parameter $default is correct as it would always require null to be passed?

     *
     * @return mixed|null
     */
    public function getKey($array, $key, $default = null)
    {
        return $this->exists($array, $key) ? $key : $default;
    }

    /**
     * Get all of the given array except for a specified array of keys.
     *
     * @param  array|ArrayAccess  $array
     * @param $keys
     *
     * @return array
     */
    public function except($array, $keys): array
    {
        $keys = (array) $keys;

        return array_filter($array, static function ($key) use ($keys) {

It seems like $array can also be of type ArrayAccess; however, parameter $input of array_filter() does only seem to accept array, maybe add an additional type check?

            return empty($keys) || ! in_array($key, $keys);
        }, ARRAY_FILTER_USE_KEY);
    }

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

It seems like $array can also be of type ArrayAccess; however, parameter $array1 of array_intersect_key() does only seem to accept array, maybe add an additional type check?

    }

    /**
     * Applies the callback to the elements of the given arrays.
     *
     * @param  array|ArrayAccess  $array
     * @param  callable  $callback
     *
     * @return array
     */
    public function map($array, callable $callback): array
    {
        foreach ($array as $key => &$value) {
            $value = $callback($value, $key);
        }

        return $array;

The expression return $array could return the type ArrayAccess which is incompatible with the type-hinted return array. Consider adding an additional type-check to rule them out.

    }

    /**
     * Check if the item is an array.
     *
     * @param  null  $value

Are you sure the doc-type for parameter $value is correct as it would always require null to be passed?

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

    /**
     * Save array to php or json file.
     *
     * @param  array|ArrayAccess  $array
     * @param  string  $path
     * @param  bool  $is_json
     * @param  bool  $sort_keys
     */
    public function store($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);
    }

    /**
     * Save array to json file.
     *
     * @param  string  $path
     * @param  array|ArrayAccess  $array
     * @param  bool  $sort_keys
     */
    public function storeAsJson(string $path, $array, bool $sort_keys = false): void
    {
        $this->prepareToStore($path, StubTool::JSON, $array, static function (array $array) {

It seems like $array can also be of type ArrayAccess; however, parameter $array of Helldar\Support\Helpers\Arr::prepareToStore() does only seem to accept array, maybe add an additional type check?

            return json_encode($array);
        }, $sort_keys);
    }

    /**
     * Save array to php file.
     *
     * @param  string  $path
     * @param  array|ArrayAccess  $array
     * @param  bool  $sort_keys
     */
    public function storeAsArray(string $path, $array, bool $sort_keys = false): void
    {
        $this->prepareToStore($path, StubTool::PHP_ARRAY, $array, static function (array $array) {

It seems like $array can also be of type ArrayAccess; however, parameter $array of Helldar\Support\Helpers\Arr::prepareToStore() does only seem to accept array, maybe add an additional type check?

            return var_export($array, true);
        }, $sort_keys);
    }

    /**
     * Prepare an array for writing to a file.
     *
     * @param  string  $path
     * @param  string  $stub
     * @param  array  $array
     * @param  callable  $replace
     * @param  bool  $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);
    }
}