Underscore\Methods\ArraysMethods

Complexity

Total Complexity

69

Size/Duplication

Total Lines	678
Duplicated Lines	0 %

Importance

Changes	8
Bugs	1	Features	1

37 Methods

Rating	Name	Duplication	Size	Complexity
A	intersects()	0	6	1
A	last()	0	7	2
A	contains()	0	3	1
A	first()	0	7	2
A	removeFirst()	0	5	1
A	without()	0	11	3
A	at()	0	7	2
A	intersection()	0	6	1
A	removeLast()	0	5	1
A	unique()	0	9	2
A	search()	0	3	1
A	matches()	0	12	2
A	random()	0	9	2
A	find()	0	9	3
A	average()	0	3	1
A	max()	0	8	2
A	initial()	0	5	1
A	invoke()	0	13	3
A	rest()	0	3	1
A	replaceValue()	0	4	1
A	range()	0	12	2
A	implode()	0	3	1
A	repeat()	0	8	2
A	min()	0	8	2
A	replaceKeys()	0	5	1
A	filter()	0	7	2
A	size()	0	3	1
A	clean()	0	4	1
A	removeValue()	0	16	5
A	each()	0	7	2
A	sortKeys()	0	11	3
A	shuffle()	0	5	1
A	prepend()	0	5	1
A	reject()	0	11	3
A	matchesAny()	0	12	2
A	append()	0	5	1
A	flatten()	0	28	6

<?php

/*
 * This file is part of Underscore.php
 *
 * (c) Maxime Fabre <ehtnam6@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Underscore\Methods;

use Closure;

/**
 * Methods to manage arrays.
 */
class ArraysMethods extends CollectionMethods
{

    ////////////////////////////////////////////////////////////////////
    ///////////////////////////// GENERATE /////////////////////////////
    ////////////////////////////////////////////////////////////////////

    //<editor-fold desc="*** Methods ***">
    /**
     * Generate an array from a range.
     *
     * @param int $_base The base number
     * @param int $stop  The stopping point
     * @param int $step  How many to increment of
     *
     * @return array
     */
    public static function range($_base, $stop = null, $step = 1) : array
    {
        // Dynamic arguments
        if ($stop !== null) {
            $start = $_base;
        }
        else {
            $start = 1;
            $stop  = $_base;
        }

        return range($start, $stop, $step);
    }

    /**
     * Fill an array with $times times some $data.
     *
     * @param mixed $data
     * @param int   $times
     *
     * @return array
     */
    public static function repeat($data, int $times) : array
    {
        $times = (int)(abs($times));
        if ($times === 0) {
            return [];
        }

        return array_fill(0, $times, $data);
    }

    ////////////////////////////////////////////////////////////////////
    ///////////////////////////// ANALYZE //////////////////////////////
    ////////////////////////////////////////////////////////////////////

    /**
     * Search for the index of a value in an array.
     *
     * @param array  $array
     * @param string $value
     *
     * @return mixed
     */
    public static function search($array, $value)
    {
        return array_search($value, $array, true);
    }

    /**
     * Check if all items in an array match a truth test.
     *
     * @param array    $array
     * @param callable $closure
     *
     * @return bool
     */
    public static function matches($array, callable $closure) : bool
    {
        // Reduce the array to only booleans
        $array = static::each($array, $closure);

        // Check the results
        if (\count($array) === 0) {
            return true;
        }
        $array = array_search(false, $array, false);

        return \is_bool($array);
    }

    /**
     * Check if any item in an array matches a truth test.
     *
     * @param array    $array
     * @param callable $closure
     *
     * @return bool
     */
    public static function matchesAny(array $array, callable $closure) : bool
    {
        // Reduce the array to only booleans
        $array = static::each($array, $closure);

        // Check the results
        if (\count($array) === 0) {
            return true;
        }
        $array = array_search(true, $array, false);

        return \is_int($array);
    }

    /**
     * Check if an item is in an array.
     *
     * @param $array
     * @param $value
     *
     * @return bool
     */
    public static function contains($array, $value) : bool
    {
        return \in_array($value, $array, true);
    }

    /**
     * Returns the average value of an array.
     *
     * @param array $array    The source array
     * @param int   $decimals The number of decimals to return
     *
     * @return float The average value
     */
    public static function average(array $array, int $decimals = 0) : float
    {
        return round((array_sum($array) / \count($array)), $decimals);
    }

    /**
     * Get the size of an array.
     *
     * @param array $array
     *
     * @return int
     */
    public static function size(array $array) : int
    {
        return \count($array);
    }

    /**
     * Get the max value from an array.
     *
     * @param array        $array
     * @param Closure|null $closure
     *
     * @return mixed
     */
    public static function max(array $array, $closure = null)
    {
        // If we have a closure, apply it to the array
        if ($closure) {
            $array = static::each($array, $closure);
        }

        return max($array);
    }

    /**
     * Get the min value from an array.
     *
     * @param array        $array
     * @param Closure|null $closure
     *
     * @return mixed
     */
    public static function min(array $array, $closure = null)
    {
        // If we have a closure, apply it to the array
        if ($closure) {
            $array = static::each($array, $closure);
        }

        return min($array);
    }

    ////////////////////////////////////////////////////////////////////
    //////////////////////////// FETCH FROM ////////////////////////////
    ////////////////////////////////////////////////////////////////////

    /**
     * Find the first item in an array that passes the truth test.
     *
     * @param array   $array
     * @param Closure $closure
     *
     * @return mixed|void
     */
    public static function find(array $array, Closure $closure)
    {
        foreach ($array as $key => $value) {
            if ($closure($value, $key)) {
                return $value;
            }
        }

        return;
    }

    /**
     * Clean all falsy values from an array.
     *
     * @param array $array
     *
     * @return array|mixed
     */
    public static function clean(array $array)
    {
        return static::filter($array, function($value) {
            return (bool)$value;
        });
    }

    /**
     * Get a random string from an array.
     *
     * @param array    $array
     * @param int|null $take
     *
     * @return array|mixed
     */
    public static function random(array $array, int $take = null)
    {
        if ( ! $take) {

The expression $take of type integer|null is loosely compared to false; this is ambiguous if the integer can be 0. You might want to explicitly use === null instead.

            return $array[array_rand($array)];
        }

        shuffle($array);

        return static::first($array, $take);
    }

    /**
     * Return an array without all instances of certain values.
     */
    public static function without()
    {
        $arguments = \func_get_args();
        $array     = array_shift($arguments);
        // if singular argument and is an array treat this AS the array to run without agains
        if (\is_array($arguments[0]) && \count($arguments) === 1) {
            $arguments = $arguments[0];
        }

        return static::filter($array, function($value) use ($arguments) {
            return ! \in_array($value, $arguments, true);
        });
    }

    /**
     * Return an array with all elements found in both input arrays.
     *
     * @param array $a
     * @param array $b
     *
     * @return array
     */
    public static function intersection(array $a, array $b) : array
    {
        $a = (array)$a;
        $b = (array)$b;

        return array_values(array_intersect($a, $b));
    }

    /**
     * Return a boolean flag which indicates whether the two input arrays have any common elements.
     *
     * @param array $a
     * @param array $b
     *
     * @return bool
     */
    public static function intersects(array $a, array $b) : bool
    {
        $a = (array)$a;
        $b = (array)$b;

        return \count(self::intersection($a, $b)) > 0;
    }

    ////////////////////////////////////////////////////////////////////
    ///////////////////////////// SLICERS //////////////////////////////
    ////////////////////////////////////////////////////////////////////

    /**
     * Get the first value from an array.
     *
     * @param array    $array
     * @param int|null $take
     *
     * @return array|mixed
     */
    public static function first(array $array, int $take = null)
    {
        if ( ! $take) {

The expression $take of type integer|null is loosely compared to false; this is ambiguous if the integer can be 0. You might want to explicitly use === null instead.

            return array_shift($array);
        }

        return array_splice($array, 0, $take, true);
    }

    /**
     * Get the last value from an array.
     *
     * @param array    $array
     * @param int|null $take
     *
     * @return array|mixed
     */
    public static function last(array $array, int $take = null)
    {
        if ( ! $take) {

The expression $take of type integer|null is loosely compared to false; this is ambiguous if the integer can be 0. You might want to explicitly use === null instead.

            return array_pop($array);
        }

        return static::rest($array, -$take);
    }

    /**
     * Get everything but the last $to items.
     *
     * @param array $array
     * @param int   $to
     *
     * @return array|mixed
     */
    public static function initial(array $array, $to = 1)
    {
        $slice = \count($array) - $to;

        return static::first($array, $slice);
    }

    /**
     * Get the last elements from index $from.
     *
     * @param array $array
     * @param int   $from
     *
     * @return array
     */
    public static function rest(array $array, $from = 1) : array
    {
        return array_splice($array, $from);
    }

    ////////////////////////////////////////////////////////////////////
    ///////////////////////////// ACT UPON /////////////////////////////
    ////////////////////////////////////////////////////////////////////

    /**
     * Iterate over an array and execute a callback for each loop.
     *
     * @param array   $array
     * @param Closure $closure
     *
     * @return array
     */
    public static function at(array $array, Closure $closure) : array
    {
        foreach ($array as $key => $value) {
            $closure($value, $key);
        }

        return $array;
    }

    ////////////////////////////////////////////////////////////////////
    ////////////////////////////// ALTER ///////////////////////////////
    ////////////////////////////////////////////////////////////////////

    /**
     * Replace a value in an array.
     *
     * @param array  $array   The array
     * @param string $replace The string to replace
     * @param string $with    What to replace it with
     *
     * @return array
     */
    public static function replaceValue(array $array, string $replace, string $with) : array
    {
        return static::each($array, function($value) use ($replace, $with) {
            return str_replace($replace, $with, $value);
        });
    }

    /**
     * Replace the keys in an array with another set.
     *
     * @param array $array The array
     * @param array $keys  An array of keys matching the array's size
     *
     * @return array
     */
    public static function replaceKeys(array $array, array $keys) : array
    {
        $values = array_values($array);

        return array_combine($keys, $values);

The expression return array_combine($keys, $values) could return the type false which is incompatible with the type-hinted return array. Consider adding an additional type-check to rule them out.

    }

    /**
     * Iterate over an array and modify the array's value.
     *
     * @param array   $array
     * @param Closure $closure
     *
     * @return array
     */
    public static function each(array $array, Closure $closure) : array
    {
        foreach ($array as $key => $value) {
            $array[$key] = $closure($value, $key);
        }

        return $array;
    }

    /**
     * Shuffle an array.
     *
     * @param array $array
     *
     * @return array
     */
    public static function shuffle(array $array) : array
    {
        shuffle($array);

        return $array;
    }

    /**
     * Sort an array by key.
     *
     * @param array  $array
     * @param string $direction
     *
     * @return array
     */
    public static function sortKeys(array $array, string $direction = 'ASC') : array
    {
        $direction = (strtolower($direction) === 'desc') ? SORT_DESC : SORT_ASC;
        if ($direction === SORT_ASC) {
            ksort($array);
        }
        else {
            krsort($array);
        }

        return $array;
    }

    /**
     * Implodes an array.
     *
     * @param array  $array The array
     * @param string $with  What to implode it with
     *
     * @return string
     */
    public static function implode($array, $with = '') : string
    {
        return implode($with, $array);
    }

    /**
     * Find all items in an array that pass the truth test.
     *
     * @param array         $array
     * @param callable|null $closure
     *
     * @return array|mixed
     */
    public static function filter(array $array, $closure = null)
    {
        if ( ! $closure) {
            return static::clean($array);
        }

        return array_filter($array, $closure);
    }

    /**
     * Flattens an array to dot notation.
     *
     * @param array  $array     An array
     * @param string $separator The characater to flatten with
     * @param string $parent    The parent passed to the child (private)
     *
     * @return string|array Flattened array to one level
     */
    public static function flatten(array $array, string $separator = '.', string $parent = null)
    {
        $_flattened = [];

        // Rewrite keys
        foreach ($array as $key => $value) {
            if ($parent) {
                $key = $parent.$separator.$key;
            }
            if ( ! \is_array($value)) {
                $_flattened[$key] = $value;
                continue;
            }
            $_flattened[$key] = static::flatten($value, $separator, $key);
        }

        // Flatten
        $flattened = [];
        foreach ($_flattened as $key => $value) {
            if (\is_array($value)) {
                $flattened = array_merge($flattened, $value);
            }
            else {
                $flattened[$key] = $value;
            }
        }

        return $flattened;
    }

    /**
     * Invoke a function on all of an array's values.
     *
     * @param array        $array
     * @param callable     $callable
     * @param array|string $arguments
     *
     * @return array
     */
    public static function invoke(array $array, $callable, $arguments = []) : array
    {
        // If one argument given for each iteration, create an array for it
        if ( ! \is_array($arguments)) {
            $arguments = static::repeat($arguments, \count($array));
        }

        // If the callable has arguments, pass them
        if ($arguments) {
            return array_map($callable, $array, $arguments);
        }

        return array_map($callable, $array);
    }

    /**
     * Return all items that fail the truth test.
     *
     * @param array   $array
     * @param Closure $closure
     *
     * @return array
     */
    public static function reject(array $array, Closure $closure) : array
    {
        $filtered = [];

        foreach ($array as $key => $value) {
            if ( ! $closure($value, $key)) {
                $filtered[$key] = $value;
            }
        }

        return $filtered;
    }

    /**
     * Remove the first value from an array.
     *
     * @param array $array
     *
     * @return array
     */
    public static function removeFirst(array $array) : array
    {
        array_shift($array);

        return $array;
    }

    /**
     * Remove the last value from an array.
     *
     * @param array $array
     *
     * @return array
     */
    public static function removeLast(array $array) : array
    {
        array_pop($array);

        return $array;
    }

    /**
     * Removes a particular value from an array (numeric or associative).
     *
     * @param array  $array
     * @param string $value
     *
     * @return array
     */
    public static function removeValue(array $array, string $value) : array
    {
        $isNumericArray = true;
        foreach ($array as $key => $item) {
            if ($item === $value) {
                if ( ! \is_int($key)) {
                    $isNumericArray = false;
                }
                unset($array[$key]);
            }
        }
        if ($isNumericArray) {
            $array = array_values($array);
        }

        return $array;
    }

    /**
     * Prepend a value to an array.
     *
     * @param array  $array
     * @param string $value
     *
     * @return array
     */
    public static function prepend($array, $value) : array
    {
        array_unshift($array, $value);

        return $array;
    }

    /**
     * Append a value to an array.
     *
     * @param array  $array
     * @param string $value
     *
     * @return array
     */
    public static function append($array, $value) : array
    {
        $array[] = $value;

        return $array;
    }

    /*
     *  Return a duplicate free copy of an array
     * */
    /**
     * @param array $array
     *
     * @return array
     */
    public static function unique($array) : array
    {
        return array_reduce($array, function($resultArray, $value) {
            if ( ! static::contains($resultArray, $value)) {
                $resultArray[] = $value;
            }

            return $resultArray;
        }, []);
    }
    //</editor-fold desc="*** Methods ***">
}