Arrays::project() - Code Metrics - dominionenterprises/util-arrays-php - Measure and Improve Code Quality continuously with Scrutinizer

Arrays::project() C
last analyzed 2017-08-07 20:23 UTC

↳ Parent: Arrays

Complexity

Conditions	7
Paths	6

Size

Total Lines	22
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	22
rs	6.9811
c	0
b	0
f	0
cc	7
eloc	12
nc	6
nop	3

<?php
/**
 * Defines the \DominionEnterprises\Util\Arrays class.
 */

namespace DominionEnterprises\Util;

/**
 * Class of static array utility functions.
 */
final class Arrays
{
    /**
     * Const for lower cased array keys.
     *
     * @const integer
     */
    const CASE_LOWER = 1;

    /**
     * Const for upper cased array keys.
     *
     * @const integer
     */
    const CASE_UPPER = 2;

    /**
     * Const for camel caps cased array keys.
     *
     * @const integer
     */
    const CASE_CAMEL_CAPS = 4;

    /**
     * Const for underscored cased array keys.
     *
     * @const integer
     */
    const CASE_UNDERSCORE = 8;

    /**
     * Simply returns an array value if the key exist or null if it does not.
     *
     * @param array $array the array to be searched
     * @param string|integer $key the key to search for
     * @param mixed $default the value to return if the $key is not found in $array
     *
     * @return mixed array value or given default value
     */
    public static function get(array $array, $key, $default = null)
    {
        return array_key_exists($key, $array) ? $array[$key] : $default;
    }

    /**
     * Simply returns an array value if the key isset,4 $default if it is not
     *
     * @param array $array the array to be searched
     * @param string|integer $key the key to search for
     * @param mixed $default the value to return if the $key is not found in $array or if the value of $key element is
     *                       null
     *
     * @return mixed array value or given default value
     */
    public static function getIfSet(array $array, $key, $default = null)
    {
        return isset($array[$key]) ? $array[$key] : $default;
    }

    /**
     * Sets destination array values to be the source values if the source key exist in the source array.
     *
     * @param array $source
     * @param array &$dest
     * @param array $keyMap mapping of dest keys to source keys. If $keyMap is associative, the keys will be the
     *                      destination keys. If numeric the values will be the destination keys
     *
     * @return void
     */
    public static function copyIfKeysExist(array $source, array &$dest, array $keyMap)

    {
        foreach ($keyMap as $destKey => $sourceKey) {
            if (is_int($destKey)) {
                $destKey = $sourceKey;
            }

            if (array_key_exists($sourceKey, $source)) {
                $dest[$destKey] = $source[$sourceKey];
            }
        }
    }

    /**
     * Sets destination array values to be the source values if the source key is set in the source array.
     *
     * @param array $source
     * @param array &$dest
     * @param array $keyMap mapping of dest keys to source keys. If $keyMap is associative, the keys will be the
     *                      destination keys. If numeric the values will be the destination keys
     *
     * @return void
     */
    public static function copyIfSet(array $source, array &$dest, array $keyMap)

    {
        foreach ($keyMap as $destKey => $sourceKey) {
            if (is_int($destKey)) {
                $destKey = $sourceKey;
            }

            if (isset($source[$sourceKey])) {
                $dest[$destKey] = $source[$sourceKey];
            }
        }
    }

    /**
     * Returns true and fills $value if $key exists in $array, otherwise fills $value with null and returns false
     *
     * @param array $array The array to pull from
     * @param string|integer $key The key to get
     * @param mixed &$value The value to set
     *
     * @return bool true if $key was found and filled in $value, false if $key was not found and $value was set to null
     */
    public static function tryGet(array $array, $key, &$value)
    {
        if ((is_string($key) || is_int($key)) && array_key_exists($key, $array)) {
            $value = $array[$key];
            return true;
        }

        $value = null;
        return false;
    }

    /**
     * Projects values of a key into an array.
     *
     * if $input = [
     *     ['key 1' => 'item 1 value 1', 'key 2' => 'item 1 value 2'],
     *     ['key 1' => 'item 2 value 1', 'key 2' => 'item 2 value 2'],
     *     ['key 1' => 'item 3 value 1'],
     * ]
     * and $key = 'key 2'
     * and $strictKeyCheck = false
     *
     * then return ['item 1 value 2', 'item 2 value 2']
     *
     * but if $strictKeyCheck = true then an InvalidArgumentException occurs since 'key 2' wasnt in item 3
     *
     * @param array $input the array to project from
     * @param string|integer $key the key which values we are to project
     * @param boolean $strictKeyCheck ensure key is in each $input array or not
     *
     * @return array the projection
     *
     * @throws \InvalidArgumentException if $strictKeyCheck was not a bool
     * @throws \InvalidArgumentException if a value in $input was not an array
     * @throws \InvalidArgumentException if a key was not in one of the $input arrays
     */
    public static function project(array $input, $key, $strictKeyCheck = true)
    {
        if ($strictKeyCheck !== false && $strictKeyCheck !== true) {
            throw new \InvalidArgumentException('$strictKeyCheck was not a bool');
        }

        $projection = [];

        foreach ($input as $itemKey => $item) {
            if (!is_array($item)) {
                throw new \InvalidArgumentException('a value in $input was not an array');
            }

            if (array_key_exists($key, $item)) {
                $projection[$itemKey] = $item[$key];
            } elseif ($strictKeyCheck) {
                throw new \InvalidArgumentException('key was not in one of the $input arrays');
            }
        }

        return $projection;
    }

    /**
     * Returns a sub set of the given $array based on the given $conditions
     *
     * @param array[] $array an array of arrays to be checked
     * @param array $conditions array of key/value pairs to filter by
     *
     * @return array the subset
     *
     * @throws \InvalidArgumentException if a value in $array was not an array
     */
    public static function where(array $array, array $conditions)
    {
        $result = [];
        foreach ($array as $item) {
            if (!is_array($item)) {
                throw new \InvalidArgumentException('a value in $array was not an array');
            }

            foreach ($conditions as $key => $value) {
                if (!array_key_exists($key, $item) || $item[$key] !== $value) {
                    continue 2; // continue to the next item in $array
                }
            }

            $result[] = $item;
        }

        return $result;
    }

    /**
     * Takes each item and embeds it into the destination array, returning the result.
     *
     * Each item's key is used as the key in the destination array so that keys are preserved.  Each resulting item in
     * the destination will be embedded into a field named by $fieldName.  Any items that don't have an entry in
     * destination already will be added, not skipped.
     *
     * For example, embedInto(['Joe', 'Sue'], 'lastName', [['firstName' => 'Billy'], ['firstName' => 'Bobby']]) will
     * return [['firstName' => 'Billy', 'lastName' => 'Joe'], ['firstName' => 'Bobby', 'lastName' => 'Sue']]
     *
     * @param array $items The items to embed into the result.
     * @param string $fieldName The name of the field to embed the items into.  This field must not exist in the
     *                          destination items already.
     * @param array $destination An optional array of arrays to embed the items into.  If this is not provided then
     *                           empty records are assumed and the new record will be created only containing
     *                           $fieldName.
     * @param bool $overwrite whether to overwrite $fieldName in $destination array
     *
     * @return array $destination, with all items in $items added using their keys, but underneath a nested $fieldName
     *               key.
     *
     * @throws \InvalidArgumentException if $fieldName was not a string
     * @throws \InvalidArgumentException if a value in $destination was not an array
     * @throws \Exception if $fieldName key already exists in a $destination array
     */
    public static function embedInto(array $items, $fieldName, array $destination = [], $overwrite = false)
    {
        if (!is_string($fieldName)) {
            throw new \InvalidArgumentException('$fieldName was not a string');
        }

        if ($overwrite !== false && $overwrite !== true) {
            throw new \InvalidArgumentException('$overwrite was not a bool');
        }

        foreach ($items as $key => $item) {
            if (!array_key_exists($key, $destination)) {
                $destination[$key] = [$fieldName => $item];
                continue;
            }

            if (!is_array($destination[$key])) {
                throw new \InvalidArgumentException('a value in $destination was not an array');
            }

            if (!$overwrite && array_key_exists($fieldName, $destination[$key])) {
                throw new \Exception('$fieldName key already exists in a $destination array');
            }

            $destination[$key][$fieldName] = $item;
        }

        return $destination;
    }

    /**
     * Fills the given $template array with values from the $source array
     *
     * @param array $template the array to be filled
     * @param array $source the array to fetch values from
     *
     * @return array Returns a filled version of $template
     */
    public static function fillIfKeysExist(array $template, array $source)
    {
        $result = $template;
        foreach ($template as $key => $value) {
            if (array_key_exists($key, $source)) {
                $result[$key] = $source[$key];
            }
        }

        return $result;
    }

    /**
     * Extracts an associative array from the given multi-dimensional array.
     *
     * @param array $input The multi-dimensional array.
     * @param string|int $keyIndex The index to be used as the key of the resulting single dimensional result array.
     * @param string|int $valueIndex The index to be used as the value of the resulting single dimensional result array.
     *                               If a sub array does not contain this element null will be used as the value.
     * @param string $duplicateBehavior Instruct how to handle duplicate resulting values, 'takeFirst', 'takeLast',
     *                                  'throw'
     *
     * @return array an associative array
     *
     * @throws \InvalidArgumentException Thrown if $input is not an multi-dimensional array
     * @throws \InvalidArgumentException Thrown if $keyIndex is not an int or string
     * @throws \InvalidArgumentException Thrown if $valueIndex is not an int or string
     * @throws \InvalidArgumentException Thrown if $duplicateBehavior is not 'takeFirst', 'takeLast', 'throw'
     * @throws \UnexpectedValueException Thrown if a $keyIndex value is not a string or integer
     * @throws \Exception Thrown if $duplicatedBehavior is 'throw' and duplicate entries are found.
     */
    public static function extract(array $input, $keyIndex, $valueIndex, $duplicateBehavior = 'takeLast')
    {
        if (!in_array($duplicateBehavior, ['takeFirst', 'takeLast', 'throw'])) {
            throw new \InvalidArgumentException("\$duplicateBehavior was not 'takeFirst', 'takeLast', or 'throw'");
        }

        if (!is_string($keyIndex) && !is_int($keyIndex)) {
            throw new \InvalidArgumentException('$keyIndex was not a string or integer');
        }

        if (!is_string($valueIndex) && !is_int($valueIndex)) {
            throw new \InvalidArgumentException('$valueIndex was not a string or integer');
        }

        $result = [];
        foreach ($input as $index => $array) {
            if (!is_array($array)) {
                throw new \InvalidArgumentException('$arrays was not a multi-dimensional array');
            }

            $key = self::get($array, $keyIndex);
            if (!is_string($key) && !is_int($key)) {
                throw new \UnexpectedValueException(
                    "Value for \$arrays[{$index}][{$keyIndex}] was not a string or integer"
                );
            }

            $value = self::get($array, $valueIndex);
            if (!array_key_exists($key, $result)) {
                $result[$key] = $value;
                continue;
            }

            if ($duplicateBehavior === 'throw') {
                throw new \Exception("Duplicate entry for '{$key}' found.");
            }

            if ($duplicateBehavior === 'takeLast') {
                $result[$key] = $value;
            }
        }

        return $result;
    }

    /**
     * Returns the first set {@see isset()} value specified by the given array of keys.
     *
     * @param array $array The array containing the possible values.
     * @param array $keys Array of keys to search for. The first set value will be returned.
     * @param mixed $default The default value to return if no set value was found in the array.
     *
     * @return mixed Returns the found set value or the given default value.
     */
    public static function getFirstSet(array $array, array $keys, $default = null)
    {
        foreach ($keys as $key) {
            if (isset($array[$key])) {
                return $array[$key];
            }
        }

        return $default;
    }

    /**
     * Partitions the given $input array into an array of $partitionCount sub arrays.
     *
     * This is a slight modification of the function suggested on
     * http://php.net/manual/en/function.array-chunk.php#75022. This method does not pad with empty partitions and
     * ensures positive partition count.
     *
     * @param array $input The array to partition.
     * @param int $partitionCount The maximum number of partitions to create.
     * @param bool $preserveKeys Flag to preserve numeric array indexes. Associative indexes are preserved by default.
     *
     * @return array A multi-dimensional array containing $partitionCount sub arrays.
     *
     * @throws \InvalidArgumentException Thrown if $partitionCount is not a positive integer.
     * @throws \InvalidArgumentException Thrown if $preserveKeys is not a boolean value.
     */
    public static function partition(array $input, $partitionCount, $preserveKeys = false)
    {
        if (!is_int($partitionCount) || $partitionCount < 1) {
            throw new \InvalidArgumentException('$partitionCount must be a positive integer');
        }

        if ($preserveKeys !== false && $preserveKeys !== true) {
            throw new \InvalidArgumentException('$preserveKeys must be a boolean value');
        }

        $inputLength = count($input);
        $partitionLength = floor($inputLength / $partitionCount);
        $partitionRemainder = $inputLength % $partitionCount;
        $partitions = [];
        $sliceOffset = 0;
        for ($partitionIndex = 0; $partitionIndex < $partitionCount && $sliceOffset < $inputLength; $partitionIndex++) {
            $sliceLength = ($partitionIndex < $partitionRemainder) ? $partitionLength + 1 : $partitionLength;
            $partitions[$partitionIndex] = array_slice($input, $sliceOffset, $sliceLength, $preserveKeys);
            $sliceOffset += $sliceLength;
        }

        return $partitions;
    }

    /**
     * Unsets all elements in the given $array specified by $keys
     *
     * @param array &$array The array containing the elements to unset.
     * @param array $keys Array of keys to unset.
     *
     * @return void
     */
    public static function unsetAll(array &$array, array $keys)
    {
        foreach ($keys as $key) {
            unset($array[$key]);
        }
    }

    /**
     * Convert all empty strings or strings that contain only whitespace to null in the given array
     *
     * @param array &$array The array containing empty strings
     *
     * @return void
     */
    public static function nullifyEmptyStrings(array &$array)
    {
        foreach ($array as &$value) {
            if (is_string($value) && trim($value) === '') {
                $value = null;
            }
        }
    }

    /**
     * Traverses the given $array using the key path specified by $delimitedKey and returns the final value.
     *
     * Example:
     * <br />
     * <pre>
     * use DominionEnterprises\Util\Arrays;
     * $array = [
     *     'db' => [
     *         'host' => 'localhost',
     *         'login' => [
     *             'username' => 'scott',
     *             'password' => 'tiger',
     *         ],
     *     ],
     * ];
     * echo Arrays::getNested($array, 'db.login.username');
     * </pre>
     * <br />
     * Output:
     * <pre>
     * scott
     * </pre>
     *
     * @param array  $array        The array to traverse.
     * @param string $delimitedKey A string of keys to traverse into the array.
     * @param string $delimiter    A string specifiying how the keys are delimited. The default is '.'.
     *
     * @return mixed The value at the inner most key or null if a key does not exist.
     */
    final public static function getNested(array $array, $delimitedKey, $delimiter = '.')
    {
        $pointer = $array;
        foreach (explode($delimiter, $delimitedKey) as $key) {
            if (is_array($pointer) && array_key_exists($key, $pointer)) {
                $pointer = $pointer[$key];
                continue;
            }

            return null;
        }

        return $pointer;
    }

    /**
     * Changes the case of all keys in an array. Numbered indices are left as is.
     *
     * @param array   $input The array to work on.
     * @param integer $case  The case to which the keys should be set.
     *
     * @return array Returns an array with its keys case changed.
     */
    public static function changeKeyCase(array $input, $case = self::CASE_LOWER)
    {
        if ($case & self::CASE_UNDERSCORE) {
            $copy = [];
            foreach ($input as $key => $value) {
                $copy[preg_replace("/([a-z])([A-Z0-9])/", '$1_$2', $key)] = $value;
            }

            $input = $copy;
        }

        if ($case & self::CASE_CAMEL_CAPS) {
            $copy = [];
            foreach ($input as $key => $value) {
                $key = implode(' ', array_filter(preg_split('/[^a-z0-9]/i', $key)));
                $key = lcfirst(str_replace(' ', '', ucwords(strtolower($key))));
                $copy[$key] = $value;
            }

            $input = $copy;
        }

        unset($copy); //gc

        if ($case & self::CASE_UPPER) {
            $input = array_change_key_case($input, \CASE_UPPER);
        }

        if ($case & self::CASE_LOWER) {
            $input = array_change_key_case($input, \CASE_LOWER);
        }

        return $input;
    }

    /**
     * Converts a multi-dimensional array into a single associative array whose keys are the concatinated keys
     *
     * @param array  $input     The array to flatten
     * @param string $delimiter The separator for the concatinated keys.
     *
     * @return array The flattened array
     */
    final public static function flatten(array $input, $delimiter = '.')
    {
        $args = func_get_args();
        $prefix = count($args) === 3 ? array_pop($args) : '';
        $result = [];
        foreach ($input as $key => $value) {
            $newKey = $prefix . (empty($prefix) ? '' : $delimiter) . $key;
            if (is_array($value)) {
                $result = array_merge($result, self::flatten($value, $delimiter, $newKey));
                continue;
            }

            $result[$newKey] = $value;
        }

        return $result;
    }

    /**
     * Returns all elements in the given $input array which contain the specifed $targetKey index.
     *
     * @param array          $input     The multi-dimensional array to check.
     * @param string|integer $targetKey The key to search for.
     *
     * @return array All elements of $input which contained $targetKey element with original keys preserved.
     */
    final public static function getAllWhereKeyExists(array $input, $targetKey)
    {
        $result = [];
        foreach ($input as $key => $value) {
            if (array_key_exists($targetKey, $value)) {
                $result[$key] = $value;
            }
        }

        return $result;
    }
}


1		<?php
2		/**
3		* Defines the \DominionEnterprises\Util\Arrays class.
4		*/
5
6		namespace DominionEnterprises\Util;
7
8		/**
9		* Class of static array utility functions.
10		*/
11		final class Arrays
12		{
13		/**
14		* Const for lower cased array keys.
15		*
16		* @const integer
17		*/
18		const CASE_LOWER = 1;
19
20		/**
21		* Const for upper cased array keys.
22		*
23		* @const integer
24		*/
25		const CASE_UPPER = 2;
26
27		/**
28		* Const for camel caps cased array keys.
29		*
30		* @const integer
31		*/
32		const CASE_CAMEL_CAPS = 4;
33
34		/**
35		* Const for underscored cased array keys.
36		*
37		* @const integer
38		*/
39		const CASE_UNDERSCORE = 8;
40
41		/**
42		* Simply returns an array value if the key exist or null if it does not.
43		*
44		* @param array $array the array to be searched
45		* @param string\|integer $key the key to search for
46		* @param mixed $default the value to return if the $key is not found in $array
47		*
48		* @return mixed array value or given default value
49		*/
50		public static function get(array $array, $key, $default = null)
51		{
52		return array_key_exists($key, $array) ? $array[$key] : $default;
53		}
54
55		/**
56		* Simply returns an array value if the key isset,4 $default if it is not
57		*
58		* @param array $array the array to be searched
59		* @param string\|integer $key the key to search for
60		* @param mixed $default the value to return if the $key is not found in $array or if the value of $key element is
61		* null
62		*
63		* @return mixed array value or given default value
64		*/
65		public static function getIfSet(array $array, $key, $default = null)
66		{
67		return isset($array[$key]) ? $array[$key] : $default;
68		}
69
70		/**
71		* Sets destination array values to be the source values if the source key exist in the source array.
72		*
73		* @param array $source
74		* @param array &$dest
75		* @param array $keyMap mapping of dest keys to source keys. If $keyMap is associative, the keys will be the
76		* destination keys. If numeric the values will be the destination keys
77		*
78		* @return void
79		*/
80	View Code Duplication	public static function copyIfKeysExist(array $source, array &$dest, array $keyMap)
		0 ignored issues – show Duplication introduced 2016-01-04 21:19 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
81		{
82		foreach ($keyMap as $destKey => $sourceKey) {
83		if (is_int($destKey)) {
84		$destKey = $sourceKey;
85		}
86
87		if (array_key_exists($sourceKey, $source)) {
88		$dest[$destKey] = $source[$sourceKey];
89		}
90		}
91		}
92
93		/**
94		* Sets destination array values to be the source values if the source key is set in the source array.
95		*
96		* @param array $source
97		* @param array &$dest
98		* @param array $keyMap mapping of dest keys to source keys. If $keyMap is associative, the keys will be the
99		* destination keys. If numeric the values will be the destination keys
100		*
101		* @return void
102		*/
103	View Code Duplication	public static function copyIfSet(array $source, array &$dest, array $keyMap)
		0 ignored issues – show Duplication introduced 2016-01-04 21:19 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
104		{
105		foreach ($keyMap as $destKey => $sourceKey) {
106		if (is_int($destKey)) {
107		$destKey = $sourceKey;
108		}
109
110		if (isset($source[$sourceKey])) {
111		$dest[$destKey] = $source[$sourceKey];
112		}
113		}
114		}
115
116		/**
117		* Returns true and fills $value if $key exists in $array, otherwise fills $value with null and returns false
118		*
119		* @param array $array The array to pull from
120		* @param string\|integer $key The key to get
121		* @param mixed &$value The value to set
122		*
123		* @return bool true if $key was found and filled in $value, false if $key was not found and $value was set to null
124		*/
125		public static function tryGet(array $array, $key, &$value)
126		{
127		if ((is_string($key) \|\| is_int($key)) && array_key_exists($key, $array)) {
128		$value = $array[$key];
129		return true;
130		}
131
132		$value = null;
133		return false;
134		}
135
136		/**
137		* Projects values of a key into an array.
138		*
139		* if $input = [
140		* ['key 1' => 'item 1 value 1', 'key 2' => 'item 1 value 2'],
141		* ['key 1' => 'item 2 value 1', 'key 2' => 'item 2 value 2'],
142		* ['key 1' => 'item 3 value 1'],
143		* ]
144		* and $key = 'key 2'
145		* and $strictKeyCheck = false
146		*
147		* then return ['item 1 value 2', 'item 2 value 2']
148		*
149		* but if $strictKeyCheck = true then an InvalidArgumentException occurs since 'key 2' wasnt in item 3
150		*
151		* @param array $input the array to project from
152		* @param string\|integer $key the key which values we are to project
153		* @param boolean $strictKeyCheck ensure key is in each $input array or not
154		*
155		* @return array the projection
156		*
157		* @throws \InvalidArgumentException if $strictKeyCheck was not a bool
158		* @throws \InvalidArgumentException if a value in $input was not an array
159		* @throws \InvalidArgumentException if a key was not in one of the $input arrays
160		*/
161		public static function project(array $input, $key, $strictKeyCheck = true)
162		{
163		if ($strictKeyCheck !== false && $strictKeyCheck !== true) {
164		throw new \InvalidArgumentException('$strictKeyCheck was not a bool');
165		}
166
167		$projection = [];
168
169		foreach ($input as $itemKey => $item) {
170		if (!is_array($item)) {
171		throw new \InvalidArgumentException('a value in $input was not an array');
172		}
173
174		if (array_key_exists($key, $item)) {
175		$projection[$itemKey] = $item[$key];
176		} elseif ($strictKeyCheck) {
177		throw new \InvalidArgumentException('key was not in one of the $input arrays');
178		}
179		}
180
181		return $projection;
182		}
183
184		/**
185		* Returns a sub set of the given $array based on the given $conditions
186		*
187		* @param array[] $array an array of arrays to be checked
188		* @param array $conditions array of key/value pairs to filter by
189		*
190		* @return array the subset
191		*
192		* @throws \InvalidArgumentException if a value in $array was not an array
193		*/
194		public static function where(array $array, array $conditions)
195		{
196		$result = [];
197		foreach ($array as $item) {
198		if (!is_array($item)) {
199		throw new \InvalidArgumentException('a value in $array was not an array');
200		}
201
202		foreach ($conditions as $key => $value) {
203		if (!array_key_exists($key, $item) \|\| $item[$key] !== $value) {
204		continue 2; // continue to the next item in $array
205		}
206		}
207
208		$result[] = $item;
209		}
210
211		return $result;
212		}
213
214		/**
215		* Takes each item and embeds it into the destination array, returning the result.
216		*
217		* Each item's key is used as the key in the destination array so that keys are preserved. Each resulting item in
218		* the destination will be embedded into a field named by $fieldName. Any items that don't have an entry in
219		* destination already will be added, not skipped.
220		*
221		* For example, embedInto(['Joe', 'Sue'], 'lastName', [['firstName' => 'Billy'], ['firstName' => 'Bobby']]) will
222		* return [['firstName' => 'Billy', 'lastName' => 'Joe'], ['firstName' => 'Bobby', 'lastName' => 'Sue']]
223		*
224		* @param array $items The items to embed into the result.
225		* @param string $fieldName The name of the field to embed the items into. This field must not exist in the
226		* destination items already.
227		* @param array $destination An optional array of arrays to embed the items into. If this is not provided then
228		* empty records are assumed and the new record will be created only containing
229		* $fieldName.
230		* @param bool $overwrite whether to overwrite $fieldName in $destination array
231		*
232		* @return array $destination, with all items in $items added using their keys, but underneath a nested $fieldName
233		* key.
234		*
235		* @throws \InvalidArgumentException if $fieldName was not a string
236		* @throws \InvalidArgumentException if a value in $destination was not an array
237		* @throws \Exception if $fieldName key already exists in a $destination array
238		*/
239		public static function embedInto(array $items, $fieldName, array $destination = [], $overwrite = false)
240		{
241		if (!is_string($fieldName)) {
242		throw new \InvalidArgumentException('$fieldName was not a string');
243		}
244
245		if ($overwrite !== false && $overwrite !== true) {
246		throw new \InvalidArgumentException('$overwrite was not a bool');
247		}
248
249		foreach ($items as $key => $item) {
250		if (!array_key_exists($key, $destination)) {
251		$destination[$key] = [$fieldName => $item];
252		continue;
253		}
254
255		if (!is_array($destination[$key])) {
256		throw new \InvalidArgumentException('a value in $destination was not an array');
257		}
258
259		if (!$overwrite && array_key_exists($fieldName, $destination[$key])) {
260		throw new \Exception('$fieldName key already exists in a $destination array');
261		}
262
263		$destination[$key][$fieldName] = $item;
264		}
265
266		return $destination;
267		}
268
269		/**
270		* Fills the given $template array with values from the $source array
271		*
272		* @param array $template the array to be filled
273		* @param array $source the array to fetch values from
274		*
275		* @return array Returns a filled version of $template
276		*/
277		public static function fillIfKeysExist(array $template, array $source)
278		{
279		$result = $template;
280		foreach ($template as $key => $value) {
281		if (array_key_exists($key, $source)) {
282		$result[$key] = $source[$key];
283		}
284		}
285
286		return $result;
287		}
288
289		/**
290		* Extracts an associative array from the given multi-dimensional array.
291		*
292		* @param array $input The multi-dimensional array.
293		* @param string\|int $keyIndex The index to be used as the key of the resulting single dimensional result array.
294		* @param string\|int $valueIndex The index to be used as the value of the resulting single dimensional result array.
295		* If a sub array does not contain this element null will be used as the value.
296		* @param string $duplicateBehavior Instruct how to handle duplicate resulting values, 'takeFirst', 'takeLast',
297		* 'throw'
298		*
299		* @return array an associative array
300		*
301		* @throws \InvalidArgumentException Thrown if $input is not an multi-dimensional array
302		* @throws \InvalidArgumentException Thrown if $keyIndex is not an int or string
303		* @throws \InvalidArgumentException Thrown if $valueIndex is not an int or string
304		* @throws \InvalidArgumentException Thrown if $duplicateBehavior is not 'takeFirst', 'takeLast', 'throw'
305		* @throws \UnexpectedValueException Thrown if a $keyIndex value is not a string or integer
306		* @throws \Exception Thrown if $duplicatedBehavior is 'throw' and duplicate entries are found.
307		*/
308		public static function extract(array $input, $keyIndex, $valueIndex, $duplicateBehavior = 'takeLast')
309		{
310		if (!in_array($duplicateBehavior, ['takeFirst', 'takeLast', 'throw'])) {
311		throw new \InvalidArgumentException("\$duplicateBehavior was not 'takeFirst', 'takeLast', or 'throw'");
312		}
313
314		if (!is_string($keyIndex) && !is_int($keyIndex)) {
315		throw new \InvalidArgumentException('$keyIndex was not a string or integer');
316		}
317
318		if (!is_string($valueIndex) && !is_int($valueIndex)) {
319		throw new \InvalidArgumentException('$valueIndex was not a string or integer');
320		}
321
322		$result = [];
323		foreach ($input as $index => $array) {
324		if (!is_array($array)) {
325		throw new \InvalidArgumentException('$arrays was not a multi-dimensional array');
326		}
327
328		$key = self::get($array, $keyIndex);
329		if (!is_string($key) && !is_int($key)) {
330		throw new \UnexpectedValueException(
331		"Value for \$arrays[{$index}][{$keyIndex}] was not a string or integer"
332		);
333		}
334
335		$value = self::get($array, $valueIndex);
336		if (!array_key_exists($key, $result)) {
337		$result[$key] = $value;
338		continue;
339		}
340
341		if ($duplicateBehavior === 'throw') {
342		throw new \Exception("Duplicate entry for '{$key}' found.");
343		}
344
345		if ($duplicateBehavior === 'takeLast') {
346		$result[$key] = $value;
347		}
348		}
349
350		return $result;
351		}
352
353		/**
354		* Returns the first set {@see isset()} value specified by the given array of keys.
355		*
356		* @param array $array The array containing the possible values.
357		* @param array $keys Array of keys to search for. The first set value will be returned.
358		* @param mixed $default The default value to return if no set value was found in the array.
359		*
360		* @return mixed Returns the found set value or the given default value.
361		*/
362		public static function getFirstSet(array $array, array $keys, $default = null)
363		{
364		foreach ($keys as $key) {
365		if (isset($array[$key])) {
366		return $array[$key];
367		}
368		}
369
370		return $default;
371		}
372
373		/**
374		* Partitions the given $input array into an array of $partitionCount sub arrays.
375		*
376		* This is a slight modification of the function suggested on
377		* http://php.net/manual/en/function.array-chunk.php#75022. This method does not pad with empty partitions and
378		* ensures positive partition count.
379		*
380		* @param array $input The array to partition.
381		* @param int $partitionCount The maximum number of partitions to create.
382		* @param bool $preserveKeys Flag to preserve numeric array indexes. Associative indexes are preserved by default.
383		*
384		* @return array A multi-dimensional array containing $partitionCount sub arrays.
385		*
386		* @throws \InvalidArgumentException Thrown if $partitionCount is not a positive integer.
387		* @throws \InvalidArgumentException Thrown if $preserveKeys is not a boolean value.
388		*/
389		public static function partition(array $input, $partitionCount, $preserveKeys = false)
390		{
391		if (!is_int($partitionCount) \|\| $partitionCount < 1) {
392		throw new \InvalidArgumentException('$partitionCount must be a positive integer');
393		}
394
395		if ($preserveKeys !== false && $preserveKeys !== true) {
396		throw new \InvalidArgumentException('$preserveKeys must be a boolean value');
397		}
398
399		$inputLength = count($input);
400		$partitionLength = floor($inputLength / $partitionCount);
401		$partitionRemainder = $inputLength % $partitionCount;
402		$partitions = [];
403		$sliceOffset = 0;
404		for ($partitionIndex = 0; $partitionIndex < $partitionCount && $sliceOffset < $inputLength; $partitionIndex++) {
405		$sliceLength = ($partitionIndex < $partitionRemainder) ? $partitionLength + 1 : $partitionLength;
406		$partitions[$partitionIndex] = array_slice($input, $sliceOffset, $sliceLength, $preserveKeys);
407		$sliceOffset += $sliceLength;
408		}
409
410		return $partitions;
411		}
412
413		/**
414		* Unsets all elements in the given $array specified by $keys
415		*
416		* @param array &$array The array containing the elements to unset.
417		* @param array $keys Array of keys to unset.
418		*
419		* @return void
420		*/
421		public static function unsetAll(array &$array, array $keys)
422		{
423		foreach ($keys as $key) {
424		unset($array[$key]);
425		}
426		}
427
428		/**
429		* Convert all empty strings or strings that contain only whitespace to null in the given array
430		*
431		* @param array &$array The array containing empty strings
432		*
433		* @return void
434		*/
435		public static function nullifyEmptyStrings(array &$array)
436		{
437		foreach ($array as &$value) {
438		if (is_string($value) && trim($value) === '') {
439		$value = null;
440		}
441		}
442		}
443
444		/**
445		* Traverses the given $array using the key path specified by $delimitedKey and returns the final value.
446		*
447		* Example:
448		* <br />
449		* <pre>
450		* use DominionEnterprises\Util\Arrays;
451		* $array = [
452		* 'db' => [
453		* 'host' => 'localhost',
454		* 'login' => [
455		* 'username' => 'scott',
456		* 'password' => 'tiger',
457		* ],
458		* ],
459		* ];
460		* echo Arrays::getNested($array, 'db.login.username');
461		* </pre>
462		* <br />
463		* Output:
464		* <pre>
465		* scott
466		* </pre>
467		*
468		* @param array $array The array to traverse.
469		* @param string $delimitedKey A string of keys to traverse into the array.
470		* @param string $delimiter A string specifiying how the keys are delimited. The default is '.'.
471		*
472		* @return mixed The value at the inner most key or null if a key does not exist.
473		*/
474		final public static function getNested(array $array, $delimitedKey, $delimiter = '.')
475		{
476		$pointer = $array;
477		foreach (explode($delimiter, $delimitedKey) as $key) {
478		if (is_array($pointer) && array_key_exists($key, $pointer)) {
479		$pointer = $pointer[$key];
480		continue;
481		}
482
483		return null;
484		}
485
486		return $pointer;
487		}
488
489		/**
490		* Changes the case of all keys in an array. Numbered indices are left as is.
491		*
492		* @param array $input The array to work on.
493		* @param integer $case The case to which the keys should be set.
494		*
495		* @return array Returns an array with its keys case changed.
496		*/
497		public static function changeKeyCase(array $input, $case = self::CASE_LOWER)
498		{
499		if ($case & self::CASE_UNDERSCORE) {
500		$copy = [];
501		foreach ($input as $key => $value) {
502		$copy[preg_replace("/([a-z])([A-Z0-9])/", '$1_$2', $key)] = $value;
503		}
504
505		$input = $copy;
506		}
507
508		if ($case & self::CASE_CAMEL_CAPS) {
509		$copy = [];
510		foreach ($input as $key => $value) {
511		$key = implode(' ', array_filter(preg_split('/[^a-z0-9]/i', $key)));
512		$key = lcfirst(str_replace(' ', '', ucwords(strtolower($key))));
513		$copy[$key] = $value;
514		}
515
516		$input = $copy;
517		}
518
519		unset($copy); //gc
520
521		if ($case & self::CASE_UPPER) {
522		$input = array_change_key_case($input, \CASE_UPPER);
523		}
524
525		if ($case & self::CASE_LOWER) {
526		$input = array_change_key_case($input, \CASE_LOWER);
527		}
528
529		return $input;
530		}
531
532		/**
533		* Converts a multi-dimensional array into a single associative array whose keys are the concatinated keys
534		*
535		* @param array $input The array to flatten
536		* @param string $delimiter The separator for the concatinated keys.
537		*
538		* @return array The flattened array
539		*/
540		final public static function flatten(array $input, $delimiter = '.')
541		{
542		$args = func_get_args();
543		$prefix = count($args) === 3 ? array_pop($args) : '';
544		$result = [];
545		foreach ($input as $key => $value) {
546		$newKey = $prefix . (empty($prefix) ? '' : $delimiter) . $key;
547		if (is_array($value)) {
548		$result = array_merge($result, self::flatten($value, $delimiter, $newKey));
549		continue;
550		}
551
552		$result[$newKey] = $value;
553		}
554
555		return $result;
556		}
557
558		/**
559		* Returns all elements in the given $input array which contain the specifed $targetKey index.
560		*
561		* @param array $input The multi-dimensional array to check.
562		* @param string\|integer $targetKey The key to search for.
563		*
564		* @return array All elements of $input which contained $targetKey element with original keys preserved.
565		*/
566		final public static function getAllWhereKeyExists(array $input, $targetKey)
567		{
568		$result = [];
569		foreach ($input as $key => $value) {
570		if (array_key_exists($targetKey, $value)) {
571		$result[$key] = $value;
572		}
573		}
574
575		return $result;
576		}
577		}
578

dominionenterprises / util-arrays-php

Arrays::project() C last analyzed 2017-08-07 20:23 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Arrays::project() C
last analyzed 2017-08-07 20:23 UTC