Arr::getValue() - Code Metrics - Inspection of "Adding Arr::getValue() (#3)" - starweb/starlit-utils - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0c7d27...704002 )

by Andreas

created 2016-09-01 14:49 UTC

Arr::getValue() A

↳ Parent: Arr

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
cc	2
eloc	2
nc	2
nop	3
crap	2

<?php
/**
 * Utils.
 *
 * @copyright Copyright (c) 2016 Starweb / Ehandelslogik i Lund AB
 * @license   BSD 3-Clause
 */

namespace Starlit\Utils;

/**
 * Array utilities.
 *
 * @author Andreas Nilsson <http://github.com/jandreasn>
 */
class Arr
{
    /**
     * If any of the provided values is in an array.
     * This is a convenient function for constructs like in_array('val1', $a) || in_array('val2, $a) etc.
     *
     * @param array|string $anyValue Array of needles (will try any for a match)
     * @param array        $array    Haystack array
     * @return bool
     */
    public static function anyIn($anyValue, $array)
    {
        if (is_array($anyValue)) {
            return (bool) array_intersect($anyValue, $array);
        }

        return in_array($anyValue, $array);
    }

    /**
     * If all of the provided values is in an array.
     * This is a convenient function for constructs like in_array('val1', $a) && in_array('val2, $a) etc.
     *
     * @param array|mixed $allValues Array of needles (will try all for a match)
     * @param array       $array     Haystack array
     * @return bool
     */
    public static function allIn($allValues, $array)
    {
        if (is_array($allValues)) {
            if (empty($allValues)) {
                return false;
            }

            foreach ($allValues as $value) {
                if (!in_array($value, $array)) {
                    return false;
                }
            }

            // A match was found for all values if we got here
            return true;
        }

        return in_array($allValues, $array);
    }

    /**
     * Get a new array with prefix applied to all values.
     *
     * @param array  $array
     * @param string $prefix
     * @return array
     */
    public static function valuesWithPrefix(array $array, $prefix)
    {
        $newArray = [];
        foreach ($array as $oldValue) {
            $newArray[] = $prefix . $oldValue;
        }


        return $newArray;
    }

    /**
     * Checks if all values in an array is empty (recursively).
     *
     * Doesn't consider other arrays with empty values non-empty as the normal
     * empty() function does.
     *
     * @param array|mixed $input
     * @return bool
     */
    public static function allEmpty($input)
    {
        if (is_array($input)) {
            foreach ($input as $value) {
                if (!self::allEmpty($value)) {
                    return false;
                }
            }

            return true;
        } else {
            return empty($input);
        }
    }

    /**
     * Filter associative array on keys, by provided keys, a callable or null (like  array_filter, but for keys).
     *
     * @param array               $inputArray
     * @param array|callable|null $keysOrCallable
     * @return array
     */
    public static function filterKeys(array $inputArray, $keysOrCallable = null)
    {
        // Get keys
        if (is_array($keysOrCallable)) {
            $filteredKeys = $keysOrCallable;
        } elseif (is_callable($keysOrCallable)) {
            $filteredKeys = array_filter(array_keys($inputArray), $keysOrCallable);
        } else {
            $filteredKeys = array_filter(array_keys($inputArray));
        }

        // Return associative array with only the the filtered keys
        return array_intersect_key($inputArray, array_flip($filteredKeys));
    }

    /**
     * collect values from method calls from an array of objects.
     *
     * Ee.g. get all product names from an array of products.
     *
     * @param array  $objectArray
     * @param string $methodName
     * @return array
     */
    public static function objectsMethodValues(array $objectArray, $methodName)
    {
        $methodValues = [];

        foreach ($objectArray as $object) {
            $methodValues[] = $object->$methodName();
        }

        return $methodValues;
    }

    /**
     * Get a new array with all values cast to type.
     *
     * @param array  $inputArray
     * @param string $type
     * @return array
     */
    public static function valuesWithType(array $inputArray, $type)
    {
        $newArray = [];
        foreach ($inputArray as $key => $value) {
            $newValue = $value;
            settype($newValue, $type);
            $newArray[$key] = $newValue;
        }

        return $newArray;
    }

    /**
     * Replaces values in array1 with values from array2 comparing keys and
     * discarding keys that doesn't exist in array1 .
     *
     * @param array $array1
     * @param array $array2
     * @param bool  $recursive
     * @return array
     */
    public static function replaceExisting(array $array1, array $array2, $recursive = false)
    {
        foreach ($array1 as $key => $value) {
            if (array_key_exists($key, $array2)) {
                $value2 = $array2[$key];
                if ($recursive && is_array($value)) {
                    $value2 = self::replaceExisting($value, $value2, $recursive);
                }
                $array1[$key] = $value2;
            }
        }

        return $array1;
    }

    /**
     * Sort by array.
     *
     * @param array $sortArray
     * @param array $mapArray
     * @return array
     */
    public static function sortByArray(array $sortArray, array $mapArray)
    {
        $sortedArray = [];
        foreach ((array) $mapArray as $id) {
            if (array_key_exists($id, $sortArray)) {
                $sortedArray[] = $sortArray[$id];
            }
        }

        return $sortedArray;
    }

    /**
     * @param array  $array
     * @param string $key
     * @param mixed  $default
     * @return array
     */
    public static function getValue(array $array, $key, $default = null)
    {
        return isset($array[$key]) ? $array[$key] : $default;
    }
}


1		<?php
2		/**
3		* Utils.
4		*
5		* @copyright Copyright (c) 2016 Starweb / Ehandelslogik i Lund AB
6		* @license BSD 3-Clause
7		*/
8
9		namespace Starlit\Utils;
10
11		/**
12		* Array utilities.
13		*
14		* @author Andreas Nilsson <http://github.com/jandreasn>
15		*/
16		class Arr
17		{
18		/**
19		* If any of the provided values is in an array.
20		* This is a convenient function for constructs like in_array('val1', $a) \|\| in_array('val2, $a) etc.
21		*
22		* @param array\|string $anyValue Array of needles (will try any for a match)
23		* @param array $array Haystack array
24		* @return bool
25		*/
26	2	public static function anyIn($anyValue, $array)
27		{
28	2	if (is_array($anyValue)) {
29	2	return (bool) array_intersect($anyValue, $array);
30		}
31
32	2	return in_array($anyValue, $array);
33		}
34
35		/**
36		* If all of the provided values is in an array.
37		* This is a convenient function for constructs like in_array('val1', $a) && in_array('val2, $a) etc.
38		*
39		* @param array\|mixed $allValues Array of needles (will try all for a match)
40		* @param array $array Haystack array
41		* @return bool
42		*/
43	2	public static function allIn($allValues, $array)
44		{
45	2	if (is_array($allValues)) {
46	2	if (empty($allValues)) {
47	1	return false;
48		}
49
50	2	foreach ($allValues as $value) {
51	2	if (!in_array($value, $array)) {
52	2	return false;
53		}
54	2	}
55
56		// A match was found for all values if we got here
57	1	return true;
58		}
59
60	1	return in_array($allValues, $array);
61		}
62
63		/**
64		* Get a new array with prefix applied to all values.
65		*
66		* @param array $array
67		* @param string $prefix
68		* @return array
69		*/
70	1	public static function valuesWithPrefix(array $array, $prefix)
71		{
72	1	$newArray = [];
73	1	foreach ($array as $oldValue) {
74	1	$newArray[] = $prefix . $oldValue;
75	1	}
76
77
78	1	return $newArray;
79		}
80
81		/**
82		* Checks if all values in an array is empty (recursively).
83		*
84		* Doesn't consider other arrays with empty values non-empty as the normal
85		* empty() function does.
86		*
87		* @param array\|mixed $input
88		* @return bool
89		*/
90	2	public static function allEmpty($input)
91		{
92	2	if (is_array($input)) {
93	2	foreach ($input as $value) {
94	2	if (!self::allEmpty($value)) {
95	1	return false;
96		}
97	2	}
98
99	1	return true;
100		} else {
101	2	return empty($input);
102		}
103		}
104
105		/**
106		* Filter associative array on keys, by provided keys, a callable or null (like array_filter, but for keys).
107		*
108		* @param array $inputArray
109		* @param array\|callable\|null $keysOrCallable
110		* @return array
111		*/
112	3	public static function filterKeys(array $inputArray, $keysOrCallable = null)
113		{
114		// Get keys
115	3	if (is_array($keysOrCallable)) {
116	1	$filteredKeys = $keysOrCallable;
117	3	} elseif (is_callable($keysOrCallable)) {
118	1	$filteredKeys = array_filter(array_keys($inputArray), $keysOrCallable);
119	1	} else {
120	1	$filteredKeys = array_filter(array_keys($inputArray));
121		}
122
123		// Return associative array with only the the filtered keys
124	3	return array_intersect_key($inputArray, array_flip($filteredKeys));
125		}
126
127		/**
128		* collect values from method calls from an array of objects.
129		*
130		* Ee.g. get all product names from an array of products.
131		*
132		* @param array $objectArray
133		* @param string $methodName
134		* @return array
135		*/
136	1	public static function objectsMethodValues(array $objectArray, $methodName)
137		{
138	1	$methodValues = [];
139
140	1	foreach ($objectArray as $object) {
141	1	$methodValues[] = $object->$methodName();
142	1	}
143
144	1	return $methodValues;
145		}
146
147		/**
148		* Get a new array with all values cast to type.
149		*
150		* @param array $inputArray
151		* @param string $type
152		* @return array
153		*/
154	1	public static function valuesWithType(array $inputArray, $type)
155		{
156	1	$newArray = [];
157	1	foreach ($inputArray as $key => $value) {
158	1	$newValue = $value;
159	1	settype($newValue, $type);
160	1	$newArray[$key] = $newValue;
161	1	}
162
163	1	return $newArray;
164		}
165
166		/**
167		* Replaces values in array1 with values from array2 comparing keys and
168		* discarding keys that doesn't exist in array1 .
169		*
170		* @param array $array1
171		* @param array $array2
172		* @param bool $recursive
173		* @return array
174		*/
175	3	public static function replaceExisting(array $array1, array $array2, $recursive = false)
176		{
177	3	foreach ($array1 as $key => $value) {
178	3	if (array_key_exists($key, $array2)) {
179	3	$value2 = $array2[$key];
180	3	if ($recursive && is_array($value)) {
181	1	$value2 = self::replaceExisting($value, $value2, $recursive);
182	1	}
183	3	$array1[$key] = $value2;
184	3	}
185	3	}
186
187	3	return $array1;
188		}
189
190		/**
191		* Sort by array.
192		*
193		* @param array $sortArray
194		* @param array $mapArray
195		* @return array
196		*/
197	1	public static function sortByArray(array $sortArray, array $mapArray)
198		{
199	1	$sortedArray = [];
200	1	foreach ((array) $mapArray as $id) {
201	1	if (array_key_exists($id, $sortArray)) {
202	1	$sortedArray[] = $sortArray[$id];
203	1	}
204	1	}
205
206	1	return $sortedArray;
207		}
208
209		/**
210		* @param array $array
211		* @param string $key
212		* @param mixed $default
213		* @return array
214		*/
215	2	public static function getValue(array $array, $key, $default = null)
216		{
217	2	return isset($array[$key]) ? $array[$key] : $default;
218		}
219		}
220

starweb / starlit-utils

Push — master ( 0c7d27...704002 )

Arr::getValue() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like