Arr::access() - Code Metrics - lenevor/syscodes - Measure and Improve Code Quality continuously with Scrutinizer

Arr::access() A
last analyzed 2021-03-26 23:28 UTC

↳ Parent: Arr
Complexity

Conditions	2
Paths	2
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

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

/**
 * Lenevor Framework
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file license.md.
 * It is also available through the world-wide-web at this URL:
 * https://lenevor.com/license
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to [email protected] so we can send you a copy immediately.
 *
 * @package     Lenevor
 * @subpackage  Base
 * @link        https://lenevor.com
 * @copyright   Copyright (c) 2019 - 2021 Alexander Campo <[email protected]>
 * @license     https://opensource.org/licenses/BSD-3-Clause New BSD license or see https://lenevor.com/license or see /license.md
 */

namespace Syscodes\Collections;

use ArrayAccess;
use InvalidArgumentException;

/**
 * Gets all a given array for return dot-notated key from an array.
 * 
 * @author Alexander Campo <[email protected]>
 */
class Arr
{
	/**
	 * Determine whether the value is accessible in a array.
	 *
	 * @param  mixed  $value The default value
	 *
	 * @return bool
	 *
	 * @uses   instanceof ArrayAccess
	 */
	public static function access($value) 
	{
		return is_array($value) || $value instanceof ArrayAccess;
	}

	/**
	 * Add an element to an array using "dot" notation if it doesn't exist.
	 *
	 * @param  array  $array  The search array 
	 * @param  string  $key  The key exist
	 * @param  mixed  $value  The default value
	 *
	 * @return array 
	 */
	public static function add($array, $key, $value)
	{
		if (is_null(static::get($array, $key))) {
			static::set($array, $key, $value);
		}

		return $array;
	}

	/**
     * Collapse the collection items into a single array.
     * 
     * @return static
     */
    public static function collapse($array)
    {
        $results = [];

        foreach ($array as $values) {
			if ($values instanceof Collection) {
				$values = $values->all();
			} elseif ( ! is_array($values)) {
				continue;
			}

			$results[] = $values;
        }

        return array_merge([], ...$results);

    }

	/**
	 * Divide an array into two arrays. One with keys and the other with values.
	 *
	 * @param  array  $array
	 *
	 * @return array
	 */
	public static function divide($array)
	{
		return [array_keys($array), array_values($array)];
	}

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

		return $array;
	}
	
	/**
	 * Determine if the given key exists in the provided array.
	 *
	 * @param  ArrayAccess|array  $array  The search array
	 * @param  string|int  $key  The key exist
	 *
	 * @return bool
	 *
	 * @uses   instaceof ArrayAccess
	 */
	public static function exists($array, $key) 
	{
		if ($array instanceof ArrayAccess) {
			return $array->offsetExists($key);
		}
		
		return array_key_exists($key, $array);
	}

	/**
	 * Unsets dot-notated key from an array.
	 *
	 * @param  array  $array  The search array
	 * @param  mixed  $keys  The dot-notated key or array of keys
	 *
	 * @return mixed
	 */
	public static function erase(&$array, $keys)
	{
		$original = &$array;

		$keys = (array) $keys;

		if (count($keys) === 0) {
			return;
		}

		foreach ($keys as $key) {
			if (static::exists($array, $key)) {
				unset($array[$key]);

				continue;
			}
			
			$parts = explode('.', $key);

			// Clean up after each pass
			$array = &$original;
	
			// traverse the array into the second last key
			while (count($parts) > 1) {
				$part = array_shift($parts);
	
				if (isset($array[$part]) && is_array($array[$part])) {
					$array = &$array[$key];
				} else {
					continue 2;
				}
			}

			unset($array[array_shift($parts)]);
		}
	}

	/**
	 * Flatten a multi-dimensional array into a single level.
	 * 
	 * @param  array  $array
	 * 
	 * @return array
	 */
	public static function flatten($array)
	{
		$result = [];

		array_walk_recursive($array, function ($value) use (&$result) {
			$result[] = $value;
		});

		return $result;
	}
	
	/**
	 * Fetch a flattened array of a nested array element.
	 * 
	 * @param  array  $array
	 * @param  string  $key
	 * 
	 * @return array
	 */
	public static function fetch($array, $key)
	{
		foreach (explode('.', $key) as $segment) {
			$results = array();
			
			foreach ($array as $value) {
				if (array_key_exists($segment, $value = (array) $value)) {
					$results[] = $value[$segment];
				}
			}
			
			$array = array_values($results);
		}
		
		return array_values($results);

	}

	/**
	 * Return the first element in an array passing a given truth test.
	 *
	 * @param  array  $array 
	 * @param  \Closure  $callback
	 * @param  mixed  $default
	 *
	 * @return mixed
	 */
	public static function first($array, callable $callback, $default = null)
	{
		foreach ($array as $key => $value) { 
			if (call_user_func($callback, $key, $value)) return $value;
		}

		return value($default);
	}	

	/**
	 * Get an item from an array using "dot" notation.
	 *
	 * @param  \ArrayAccess|array  $array  The search array
	 * @param  string  $key  The dot-notated key or array of keys
	 * @param  mixed  $default  The default value
	 *
	 * @return mixed
	 */
	public static function get($array, $key, $default = null)
	{
		if ( ! static::access($array)) {
			return value($default);
		}

		if (static::exists($array, $key)) {
			return $array[$key];
		}

		foreach (explode('.', $key) as $segm) {
			if (static::access($array) && static::exists($array, $segm)) {
				$array = $array[$segm];
			} else {
				return value($default);
			}
		}

		return $array;		
	}

	/**
	 * Return the last element in an array passing a given truth test.
	 *
	 * @param  array  $array 
	 * @param  \Closure  $callback
	 * @param  mixed  $default 
	 *
	 * @return mixed
	 *
	 * @uses   \Syscodes\Support\Arr::first
	 */
	public static function last($array, $callback, $default = null)
	{
		return static::first(array_reverse($array), $callback, $default);
	}

	/**
	 * Check if an item exists in an array using "dot" notation.
	 * 
	 * @param  array  $array
	 * @param  string  $key
	 * 
	 * @return bool
	 */
	public static function has($array, $key)
	{
		if (empty($array) || is_null($key)) return false;
		
		if (array_key_exists($key, $array)) return true;
		
		foreach (explode('.', $key) as $segment) {
			if ( ! is_array($array) || ! static::exists($array, $segment)) {
				return false;
			}
			
			$array = $array[$segment];
		}
		
		return true;
	}

	/**
	 * Get a subset of the items from the given array.
	 * 
	 * @param  array  $array
	 * @param  array|string  $keys
	 * 
	 * @return array
	 */
	public static function only($array, $keys)
	{
		return array_intersect_key($array, array_flip($array), $keys);
		return array_intersect_key($array, array_flip($array), /** @scrutinizer ignore-type */ $keys);
	}

	/**
	 * Sets a value in an array using "dot" notation.
	 *
	 * @param  array  $array  The search array
	 * @param  string  $key  The dot-notated key or array of keys
	 * @param  mixed  $value  The default value
	 *
	 * @return mixed
	 */
	public static function set(& $array, $key, $value = null)
	{
		$keys = explode('.', $key);

		while (count($keys) > 1) {
			$key = array_shift($keys);

			if ( ! static::exists($array, $key)) {
				$array[$key] = [];
			}

			$array =& $array[$key];
		}

		$array[array_shift($keys)] = $value;

		return $array;
	}

	/**
	 * Push an item onto the beginning of an array.
	 * 
	 * @param  mixed  $array
	 * @param  mixed  $value
	 * @param  mixed  key
filter:
    dependency_paths: ["lib/*"]
	 * 
	 * @return array
	 */
	public static function prepend($array, $value, $key = null)
	{
		if (func_num_args() == 2) {
			array_unshift($array, $value);
		} else {
			$array = [$key => $value] + $array;
		}

		return $array;
	}

	/**
	 * Get a value from the array, and remove it.
	 * 
	 * @param  array  $array
	 * @param  string  $key
	 * @param  mixed  $default
	 * 
	 * @return mixed
	 */
	public static function pull(&$array, $key, $default = null)
	{
		$value = static::get($array, $key, $default);

		static::erase($array, $key);

		return $value;
	}
	
	/**
	 * Pluck an array of values from an array.
	 * 
	 * @param  iterable  $array
	 * @param  string|array|int|null  $value
	 * @param  string|array|null  $key
	 * 
	 * @return array
	 */
	public static function pluck($array, $value, $key = null)
	{
		$results = [];

		foreach ($array as $item) {
			$itemValue = is_object($item) ? $item->{$value} : $item[$value];
			
			// If the key is "null", we will just append the value to the array and keep
			// looping. Otherwise we will key the array using the value of the key we
			// received from the developer. Then we'll return the final array form.
			if (is_null($key)) {
				$results[] = $itemValue;
			} else {
				$itemKey = is_object($item) ? $item->{$key} : $item[$key];
				
				$results[$itemKey] = $itemValue;
			}
		}
		
		return $results;
	}

	/**
	 * Convert the array into a query string.
	 * 
	 * @param  array  $array
	 * 
	 * @return array
	 */
	public static function query($array)
	{
		return http_build_query($array, null, '&', PHP_QUERY_RFC3986);
		return http_build_query($array, /** @scrutinizer ignore-type */ null, '&', PHP_QUERY_RFC3986);
	}

	/**
	 * Filter the array using the given callback.
	 * 
	 * @param  array  $array
	 * @param  \Callable  $callback
filter:
    dependency_paths: ["lib/*"]
	 * 
	 * @return array
	 */
	public static function where($array, Callable $callback)
	{
		return array_filter($array, $callback, ARRAY_FILTER_USE_BOTH);
	}

	/**
	 * If the given value is not an array and not null, wrap it in one.
	 * 
	 * @param  mixed  $value
	 * 
	 * @return array
	 */
	public static function wrap($value)
	{
		if (is_null($value)) {
			return [];
		}

		return is_array($value) ? $value : [$value];
	}
}
lenevor / syscodes

Arr::access() A last analyzed 2021-03-26 23:28 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Arr::access() A
last analyzed 2021-03-26 23:28 UTC
