ArrayHelpers::except() - Code Metrics - Inspection of "v2.0 - remove 'array' prefix from `ArrayHelpers` m..." - sfneal/array-helpers - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#32)

by Stephen
created 2021-08-03 18:14 UTC
ArrayHelpers::except() A

↳ Parent: ArrayHelpers
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
rs	10
c	0
b	0
f	0
<?php

namespace Sfneal\Helpers\Arrays;

class ArrayHelpers
{
    // todo: remove 'array' prefix from method names

    /**
     * @var array
     */
    private $array;

    /**
     * ArrayHelpers constructor.
     *
     * @param array $array
     */
    public function __construct(array $array)
    {
        $this->array = $array;
    }

    /**
     * Returns a chunked array with calculated chunk size.
     *
     * @param int $min
     * @param int|null $max
     * @param bool $no_remainders
     * @param bool $preserve_keys
     * @return array
     */
    public function chunks(int $min = 0, int $max = null, bool $no_remainders = false, bool $preserve_keys = true): array
    {
        $chunks = array_chunk(
            $this->array,
            (new ChunkSizer(count($this->array), $min, $max))->execute(),
            $preserve_keys
        );

        // Check if the first chunk is the same length as the last chunk
        if ($no_remainders && count($chunks[0]) != count(array_reverse($chunks)[0])) {
            $remainder = array_pop($chunks);
            $last_chunk = array_pop($chunks);

            // Add the remainder chunk to the last equal sized chunk
            $chunks[] = array_merge($last_chunk, $remainder);
        }

        return $chunks;
    }

    /**
     * Flatten a multidimensional array into a 2D array without nested keys.
     *
     * @param bool $nest_keys
     * @return array
     */
    public function flattenKeys(bool $nest_keys = true): array
    {
        // todo: possible use while loop for multi level nesting?
        $flat = [];
        foreach (array_keys($this->array) as $key) {
            if (is_array($this->array[$key])) {
                // If the key is an array, add each children keys to flattened array
                foreach ($this->array[$key] as $k => $v) {
                    if ($nest_keys) {
                        $flat[$key.'_'.$k] = $v;
                    } else {
                        $flat[$k] = $v;
                    }
                }
            } else {
                $flat[$key] = $this->array[$key];
            }
        }

        return $flat;
    }

    /**
     * Remove particular keys from a multidimensional array.
     *
     * @param array|string $keys
     * @return array
     */
    public function removeKeys($keys): array
    {
        $all_keys = array_keys($this->array);
        foreach ((array) $keys as $key) {
            if (in_array($key, $all_keys)) {
                unset($this->array[$key]);
            }
        }

        return $this->array;
    }

    /**
     * Sum the values of two arrays.
     *
     * @param array $array2
     * @return array
     */
    public function sum(array $array2): array
    {
        // todo: add ability to pass array of arrays
        $array = [];
        foreach ($this->array as $index => $value) {
            $array[$index] = isset($array2[$index]) ? $array2[$index] + $value : $value;
        }

        return $array;
    }

    /**
     * Determine if all values in an array of key => value pairs are unique.
     *
     * @return bool
     */
    public function valuesUnique(): bool
    {
        try {
            // Count the number of unique array values
            // Check to see if there is more than unique array_value
            return count(array_unique(array_values($this->array))) >= count(array_values($this->array));
        }

        // Handle nested arrays by comparing number unique keys
        catch (\ErrorException $exception) {
            $values = [];
            $valueCount = 0;
            foreach (array_values($this->array) as $value) {
                $values = array_merge($values, $value);
                $valueCount += count($value);
            }

            return count($values) == $valueCount;
        }
    }

    /**
     * Determine if all array_values are equal to a certain value.
     *
     * @param mixed $value
     * @return bool
     */
    public function valuesEqual($value): bool
    {
        // Check if all array values are equal to a certain value
        return count(array_keys($this->array, $value)) == count($this->array);
    }

    /**
     * Determine if all array_values are NOT equal to a certain value.
     *
     * @param mixed $value
     * @return bool
     */
    public function valuesNotEqual($value): bool
    {
        return ! $this->valuesEqual($value);
    }

    /**
     * Determine if an array is multidimensional and has keys.
     *
     * @return bool
     */
    public function hasKeys(): bool
    {
        // Array doesn't have keys if the array is the same as the array values
        if ($this->array == array_values($this->array)) {
            return false;
        }

        return count($this->array) == count($this->array, COUNT_RECURSIVE);
    }

    /**
     * Remove specific arrays of keys without modifying the original array.
     *
     * @param array $except
     * @return array
     */
    public function except(array $except): array
    {
        return array_diff_key($this->array, array_flip((array) $except));
    }

    /**
     * Remove a key from an array & return the key's value.
     *
     * @param string $key
     * @return mixed
     */
    public function pop(string $key)
    {
        // Get the value
        $value = $this->array[$key];

        // Remove the value from the array
        unset($this->array[$key]);

        // Return the value
        return $value;
    }

    /**
     * Remove a key from an array & the new array without the key.
     *
     * @param array|string $keys
     * @return array
     */
    public function unset($keys): array
    {
        // Remove the values from the array
        foreach ((array) $keys as $key) {
            unset($this->array[$key]);
        }

        // Return the new array
        return $this->array;
    }

    /**
     * Determine if all values in an array are null.
     *
     * @return bool
     */
    public function valuesNull(): bool
    {
        return $this->valuesEqual(null);
    }

    /**
     * Retrieve a random array of elements.
     *
     * @param int $items
     * @return array
     */
    public function random(int $items): array
    {
        // Get a random array of keys
        $keys = array_rand($this->array, $items);

        // Return array with only the randomly selected keys
        return array_filter(
            $this->array,
            function ($value, $key) use ($keys) {
                return in_array($key, $keys);
                return in_array($key, /** @scrutinizer ignore-type */ $keys);
            },
            ARRAY_FILTER_USE_BOTH
        );
    }

    /**
     * Return a flat array of values that were found in the $first array that are not found in the $second.
     *
     * @param array $array
     * @param bool $toArray
     * @return \Illuminate\Support\Collection|array
     */
    public function diffFlat(array $array, bool $toArray = true)
    {
        $collection = collect($this->array)
            ->diff($array)
            ->flatten();

        // Return as array
        if ($toArray) {
            return $collection->toArray();
        }

        // Return as Collection
        return $collection;
    }
}

sfneal / array-helpers

Pull Request — master (#32)

ArrayHelpers::except() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
