htmlburger / wpemerge

src/Facades/OldInput.php

Indentation +4 added lines, -4 removed lines

@@ -7,8 +7,8 @@
  */
 class OldInput extends Facade
 {
-    protected static function getFacadeAccessor()
-    {
-        return 'framework.old_input.old_input';
-    }
+	protected static function getFacadeAccessor()
+	{
+		return 'framework.old_input.old_input';
+	}
 }

src/Facades/Router.php

Indentation +4 added lines, -4 removed lines

@@ -7,8 +7,8 @@
  */
 class Router extends Facade
 {
-    protected static function getFacadeAccessor()
-    {
-        return 'framework.routing.router';
-    }
+	protected static function getFacadeAccessor()
+	{
+		return 'framework.routing.router';
+	}
 }

src/Facades/Flash.php

Indentation +4 added lines, -4 removed lines

@@ -7,8 +7,8 @@
  */
 class Flash extends Facade
 {
-    protected static function getFacadeAccessor()
-    {
-        return 'framework.flash.flash';
-    }
+	protected static function getFacadeAccessor()
+	{
+		return 'framework.flash.flash';
+	}
 }

src/Facades/Facade.php

Indentation +212 added lines, -212 removed lines

@@ -12,216 +12,216 @@
  */
 abstract class Facade
 {
-    /**
-     * The application instance being facaded.
-     *
-     * @var object
-     */
-    protected static $app;
-
-    /**
-     * The resolved object instances.
-     *
-     * @var array
-     */
-    protected static $resolvedInstance;
-
-    /**
-     * Convert the facade into a Mockery spy.
-     *
-     * @return void
-     */
-    public static function spy()
-    {
-        if (! static::isMock()) {
-            $class = static::getMockableClass();
-
-            static::swap($class ? Mockery::spy($class) : Mockery::spy());
-        }
-    }
-
-    /**
-     * Initiate a mock expectation on the facade.
-     *
-     * @return \Mockery\Expectation
-     */
-    public static function shouldReceive()
-    {
-        $name = static::getFacadeAccessor();
-
-        $mock = static::isMock()
-                    ? static::$resolvedInstance[$name]
-                    : static::createFreshMockInstance();
-
-        return $mock->shouldReceive(...func_get_args());
-    }
-
-    /**
-     * Create a fresh mock instance for the given class.
-     *
-     * @return \Mockery\Expectation
-     */
-    protected static function createFreshMockInstance()
-    {
-        return tap(static::createMock(), function ($mock) {
-            static::swap($mock);
-
-            $mock->shouldAllowMockingProtectedMethods();
-        });
-    }
-
-    /**
-     * Create a fresh mock instance for the given class.
-     *
-     * @return \Mockery\MockInterface
-     */
-    protected static function createMock()
-    {
-        $class = static::getMockableClass();
-
-        return $class ? Mockery::mock($class) : Mockery::mock();
-    }
-
-    /**
-     * Determines whether a mock is set as the instance of the facade.
-     *
-     * @return bool
-     */
-    protected static function isMock()
-    {
-        $name = static::getFacadeAccessor();
-
-        return isset(static::$resolvedInstance[$name]) &&
-               static::$resolvedInstance[$name] instanceof MockInterface;
-    }
-
-    /**
-     * Get the mockable class for the bound instance.
-     *
-     * @return string|null
-     */
-    protected static function getMockableClass()
-    {
-        if ($root = static::getFacadeRoot()) {
-            return get_class($root);
-        }
-    }
-
-    /**
-     * Hotswap the underlying instance behind the facade.
-     *
-     * @param  mixed  $instance
-     * @return void
-     */
-    public static function swap($instance)
-    {
-        static::$resolvedInstance[static::getFacadeAccessor()] = $instance;
-
-        if (isset(static::$app)) {
-            static::$app->instance(static::getFacadeAccessor(), $instance);
-        }
-    }
-
-    /**
-     * Get the root object behind the facade.
-     *
-     * @return mixed
-     */
-    public static function getFacadeRoot()
-    {
-        return static::resolveFacadeInstance(static::getFacadeAccessor());
-    }
-
-    /**
-     * Get the registered name of the component.
-     *
-     * @return string
-     *
-     * @throws \RuntimeException
-     */
-    protected static function getFacadeAccessor()
-    {
-        throw new RuntimeException('Facade does not implement getFacadeAccessor method.');
-    }
-
-    /**
-     * Resolve the facade root instance from the container.
-     *
-     * @param  string|object  $name
-     * @return mixed
-     */
-    protected static function resolveFacadeInstance($name)
-    {
-        if (is_object($name)) {
-            return $name;
-        }
-
-        if (isset(static::$resolvedInstance[$name])) {
-            return static::$resolvedInstance[$name];
-        }
-
-        return static::$resolvedInstance[$name] = static::$app[$name];
-    }
-
-    /**
-     * Clear a resolved facade instance.
-     *
-     * @param  string  $name
-     * @return void
-     */
-    public static function clearResolvedInstance($name)
-    {
-        unset(static::$resolvedInstance[$name]);
-    }
-
-    /**
-     * Clear all of the resolved instances.
-     *
-     * @return void
-     */
-    public static function clearResolvedInstances()
-    {
-        static::$resolvedInstance = [];
-    }
-
-    /**
-     * Get the application instance behind the facade.
-     *
-     * @return object
-     */
-    public static function getFacadeApplication()
-    {
-        return static::$app;
-    }
-
-    /**
-     * Set the application instance.
-     *
-     * @param  object $app
-     * @return void
-     */
-    public static function setFacadeApplication($app)
-    {
-        static::$app = $app;
-    }
-
-    /**
-     * Handle dynamic, static calls to the object.
-     *
-     * @param  string  $method
-     * @param  array   $args
-     * @return mixed
-     *
-     * @throws \RuntimeException
-     */
-    public static function __callStatic($method, $args)
-    {
-        $instance = static::getFacadeRoot();
-
-        if (! $instance) {
-            throw new RuntimeException('A facade root has not been set.');
-        }
-
-        return $instance->$method(...$args);
-    }
+	/**
+	 * The application instance being facaded.
+	 *
+	 * @var object
+	 */
+	protected static $app;
+
+	/**
+	 * The resolved object instances.
+	 *
+	 * @var array
+	 */
+	protected static $resolvedInstance;
+
+	/**
+	 * Convert the facade into a Mockery spy.
+	 *
+	 * @return void
+	 */
+	public static function spy()
+	{
+		if (! static::isMock()) {
+			$class = static::getMockableClass();
+
+			static::swap($class ? Mockery::spy($class) : Mockery::spy());
+		}
+	}
+
+	/**
+	 * Initiate a mock expectation on the facade.
+	 *
+	 * @return \Mockery\Expectation
+	 */
+	public static function shouldReceive()
+	{
+		$name = static::getFacadeAccessor();
+
+		$mock = static::isMock()
+					? static::$resolvedInstance[$name]
+					: static::createFreshMockInstance();
+
+		return $mock->shouldReceive(...func_get_args());
+	}
+
+	/**
+	 * Create a fresh mock instance for the given class.
+	 *
+	 * @return \Mockery\Expectation
+	 */
+	protected static function createFreshMockInstance()
+	{
+		return tap(static::createMock(), function ($mock) {
+			static::swap($mock);
+
+			$mock->shouldAllowMockingProtectedMethods();
+		});
+	}
+
+	/**
+	 * Create a fresh mock instance for the given class.
+	 *
+	 * @return \Mockery\MockInterface
+	 */
+	protected static function createMock()
+	{
+		$class = static::getMockableClass();
+
+		return $class ? Mockery::mock($class) : Mockery::mock();
+	}
+
+	/**
+	 * Determines whether a mock is set as the instance of the facade.
+	 *
+	 * @return bool
+	 */
+	protected static function isMock()
+	{
+		$name = static::getFacadeAccessor();
+
+		return isset(static::$resolvedInstance[$name]) &&
+			   static::$resolvedInstance[$name] instanceof MockInterface;
+	}
+
+	/**
+	 * Get the mockable class for the bound instance.
+	 *
+	 * @return string|null
+	 */
+	protected static function getMockableClass()
+	{
+		if ($root = static::getFacadeRoot()) {
+			return get_class($root);
+		}
+	}
+
+	/**
+	 * Hotswap the underlying instance behind the facade.
+	 *
+	 * @param  mixed  $instance
+	 * @return void
+	 */
+	public static function swap($instance)
+	{
+		static::$resolvedInstance[static::getFacadeAccessor()] = $instance;
+
+		if (isset(static::$app)) {
+			static::$app->instance(static::getFacadeAccessor(), $instance);
+		}
+	}
+
+	/**
+	 * Get the root object behind the facade.
+	 *
+	 * @return mixed
+	 */
+	public static function getFacadeRoot()
+	{
+		return static::resolveFacadeInstance(static::getFacadeAccessor());
+	}
+
+	/**
+	 * Get the registered name of the component.
+	 *
+	 * @return string
+	 *
+	 * @throws \RuntimeException
+	 */
+	protected static function getFacadeAccessor()
+	{
+		throw new RuntimeException('Facade does not implement getFacadeAccessor method.');
+	}
+
+	/**
+	 * Resolve the facade root instance from the container.
+	 *
+	 * @param  string|object  $name
+	 * @return mixed
+	 */
+	protected static function resolveFacadeInstance($name)
+	{
+		if (is_object($name)) {
+			return $name;
+		}
+
+		if (isset(static::$resolvedInstance[$name])) {
+			return static::$resolvedInstance[$name];
+		}
+
+		return static::$resolvedInstance[$name] = static::$app[$name];
+	}
+
+	/**
+	 * Clear a resolved facade instance.
+	 *
+	 * @param  string  $name
+	 * @return void
+	 */
+	public static function clearResolvedInstance($name)
+	{
+		unset(static::$resolvedInstance[$name]);
+	}
+
+	/**
+	 * Clear all of the resolved instances.
+	 *
+	 * @return void
+	 */
+	public static function clearResolvedInstances()
+	{
+		static::$resolvedInstance = [];
+	}
+
+	/**
+	 * Get the application instance behind the facade.
+	 *
+	 * @return object
+	 */
+	public static function getFacadeApplication()
+	{
+		return static::$app;
+	}
+
+	/**
+	 * Set the application instance.
+	 *
+	 * @param  object $app
+	 * @return void
+	 */
+	public static function setFacadeApplication($app)
+	{
+		static::$app = $app;
+	}
+
+	/**
+	 * Handle dynamic, static calls to the object.
+	 *
+	 * @param  string  $method
+	 * @param  array   $args
+	 * @return mixed
+	 *
+	 * @throws \RuntimeException
+	 */
+	public static function __callStatic($method, $args)
+	{
+		$instance = static::getFacadeRoot();
+
+		if (! $instance) {
+			throw new RuntimeException('A facade root has not been set.');
+		}
+
+		return $instance->$method(...$args);
+	}
 }

src/Support/AliasLoader.php

Indentation +161 added lines, -161 removed lines

@@ -9,165 +9,165 @@
  */
 class AliasLoader
 {
-    /**
-     * The array of class aliases.
-     *
-     * @var array
-     */
-    protected $aliases;
-
-    /**
-     * Indicates if a loader has been registered.
-     *
-     * @var bool
-     */
-    protected $registered = false;
-
-    /**
-     * The singleton instance of the loader.
-     *
-     * @var \CarbonFramework\Support\AliasLoader
-     */
-    protected static $instance;
-
-    /**
-     * Create a new AliasLoader instance.
-     *
-     * @param  array  $aliases
-     */
-    private function __construct($aliases)
-    {
-        $this->aliases = $aliases;
-    }
-
-    /**
-     * Get or create the singleton alias loader instance.
-     *
-     * @param  array  $aliases
-     * @return \CarbonFramework\Support\AliasLoader
-     */
-    public static function getInstance(array $aliases = [])
-    {
-        if (is_null(static::$instance)) {
-            return static::$instance = new static($aliases);
-        }
-
-        $aliases = array_merge(static::$instance->getAliases(), $aliases);
-
-        static::$instance->setAliases($aliases);
-
-        return static::$instance;
-    }
-
-    /**
-     * Load a class alias if it is registered.
-     *
-     * @param  string  $alias
-     * @return bool|null
-     */
-    public function load($alias)
-    {
-        if (isset($this->aliases[$alias])) {
-            return class_alias($this->aliases[$alias], $alias);
-        }
-    }
-
-    /**
-     * Add an alias to the loader.
-     *
-     * @param  string  $class
-     * @param  string  $alias
-     * @return void
-     */
-    public function alias($class, $alias)
-    {
-        $this->aliases[$class] = $alias;
-    }
-
-    /**
-     * Register the loader on the auto-loader stack.
-     *
-     * @return void
-     */
-    public function register()
-    {
-        if (! $this->registered) {
-            $this->prependToLoaderStack();
-
-            $this->registered = true;
-        }
-    }
-
-    /**
-     * Prepend the load method to the auto-loader stack.
-     *
-     * @return void
-     */
-    protected function prependToLoaderStack()
-    {
-        spl_autoload_register([$this, 'load'], true, true);
-    }
-
-    /**
-     * Get the registered aliases.
-     *
-     * @return array
-     */
-    public function getAliases()
-    {
-        return $this->aliases;
-    }
-
-    /**
-     * Set the registered aliases.
-     *
-     * @param  array  $aliases
-     * @return void
-     */
-    public function setAliases(array $aliases)
-    {
-        $this->aliases = $aliases;
-    }
-
-    /**
-     * Indicates if the loader has been registered.
-     *
-     * @return bool
-     */
-    public function isRegistered()
-    {
-        return $this->registered;
-    }
-
-    /**
-     * Set the "registered" state of the loader.
-     *
-     * @param  bool  $value
-     * @return void
-     */
-    public function setRegistered($value)
-    {
-        $this->registered = $value;
-    }
-
-    /**
-     * Set the value of the singleton alias loader.
-     *
-     * @param  \CarbonFramework\Support\AliasLoader $loader
-     * @return void
-     */
-    public static function setInstance($loader)
-    {
-        static::$instance = $loader;
-    }
-
-    /**
-     * Clone method.
-     *
-     * @return void
-     */
-    private function __clone()
-    {
-        //
-    }
+	/**
+	 * The array of class aliases.
+	 *
+	 * @var array
+	 */
+	protected $aliases;
+
+	/**
+	 * Indicates if a loader has been registered.
+	 *
+	 * @var bool
+	 */
+	protected $registered = false;
+
+	/**
+	 * The singleton instance of the loader.
+	 *
+	 * @var \CarbonFramework\Support\AliasLoader
+	 */
+	protected static $instance;
+
+	/**
+	 * Create a new AliasLoader instance.
+	 *
+	 * @param  array  $aliases
+	 */
+	private function __construct($aliases)
+	{
+		$this->aliases = $aliases;
+	}
+
+	/**
+	 * Get or create the singleton alias loader instance.
+	 *
+	 * @param  array  $aliases
+	 * @return \CarbonFramework\Support\AliasLoader
+	 */
+	public static function getInstance(array $aliases = [])
+	{
+		if (is_null(static::$instance)) {
+			return static::$instance = new static($aliases);
+		}
+
+		$aliases = array_merge(static::$instance->getAliases(), $aliases);
+
+		static::$instance->setAliases($aliases);
+
+		return static::$instance;
+	}
+
+	/**
+	 * Load a class alias if it is registered.
+	 *
+	 * @param  string  $alias
+	 * @return bool|null
+	 */
+	public function load($alias)
+	{
+		if (isset($this->aliases[$alias])) {
+			return class_alias($this->aliases[$alias], $alias);
+		}
+	}
+
+	/**
+	 * Add an alias to the loader.
+	 *
+	 * @param  string  $class
+	 * @param  string  $alias
+	 * @return void
+	 */
+	public function alias($class, $alias)
+	{
+		$this->aliases[$class] = $alias;
+	}
+
+	/**
+	 * Register the loader on the auto-loader stack.
+	 *
+	 * @return void
+	 */
+	public function register()
+	{
+		if (! $this->registered) {
+			$this->prependToLoaderStack();
+
+			$this->registered = true;
+		}
+	}
+
+	/**
+	 * Prepend the load method to the auto-loader stack.
+	 *
+	 * @return void
+	 */
+	protected function prependToLoaderStack()
+	{
+		spl_autoload_register([$this, 'load'], true, true);
+	}
+
+	/**
+	 * Get the registered aliases.
+	 *
+	 * @return array
+	 */
+	public function getAliases()
+	{
+		return $this->aliases;
+	}
+
+	/**
+	 * Set the registered aliases.
+	 *
+	 * @param  array  $aliases
+	 * @return void
+	 */
+	public function setAliases(array $aliases)
+	{
+		$this->aliases = $aliases;
+	}
+
+	/**
+	 * Indicates if the loader has been registered.
+	 *
+	 * @return bool
+	 */
+	public function isRegistered()
+	{
+		return $this->registered;
+	}
+
+	/**
+	 * Set the "registered" state of the loader.
+	 *
+	 * @param  bool  $value
+	 * @return void
+	 */
+	public function setRegistered($value)
+	{
+		$this->registered = $value;
+	}
+
+	/**
+	 * Set the value of the singleton alias loader.
+	 *
+	 * @param  \CarbonFramework\Support\AliasLoader $loader
+	 * @return void
+	 */
+	public static function setInstance($loader)
+	{
+		static::$instance = $loader;
+	}
+
+	/**
+	 * Clone method.
+	 *
+	 * @return void
+	 */
+	private function __clone()
+	{
+		//
+	}
 }

src/Support/Arr.php

Indentation +489 added lines, -489 removed lines

@@ -10,493 +10,493 @@
  */
 class Arr
 {
-    /**
-     * Determine whether the given value is array accessible.
-     *
-     * @param  mixed  $value
-     * @return bool
-     */
-    public static function accessible($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
-     * @param  string  $key
-     * @param  mixed   $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 an array of arrays into a single array.
-     *
-     * @param  array  $array
-     * @return array
-     */
-    public static function collapse($array)
-    {
-        $results = [];
-        foreach ($array as $values) {
-            if (! is_array($values)) {
-                continue;
-            }
-            $results = array_merge($results, $values);
-        }
-        return $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)];
-    }
-
-    /**
-     * Flatten a multi-dimensional associative array with dots.
-     *
-     * @param  array   $array
-     * @param  string  $prepend
-     * @return array
-     */
-    public static function dot($array, $prepend = '')
-    {
-        $results = [];
-
-        foreach ($array as $key => $value) {
-            if (is_array($value) && ! empty($value)) {
-                $results = array_merge($results, static::dot($value, $prepend.$key.'.'));
-            } else {
-                $results[$prepend.$key] = $value;
-            }
-        }
-
-        return $results;
-    }
-
-    /**
-     * Get all of the given array except for a specified array of items.
-     *
-     * @param  array  $array
-     * @param  array|string  $keys
-     * @return array
-     */
-    public static function except($array, $keys)
-    {
-        static::forget($array, $keys);
-
-        return $array;
-    }
-
-    /**
-     * Determine if the given key exists in the provided array.
-     *
-     * @param  \ArrayAccess|array  $array
-     * @param  string|int  $key
-     * @return bool
-     */
-    public static function exists($array, $key)
-    {
-        if ($array instanceof ArrayAccess) {
-            return $array->offsetExists($key);
-        }
-
-        return array_key_exists($key, $array);
-    }
-
-    /**
-     * Return the first element in an array passing a given truth test.
-     *
-     * @param  array  $array
-     * @param  callable|null  $callback
-     * @param  mixed  $default
-     * @return mixed
-     */
-    public static function first($array, callable $callback = null, $default = null)
-    {
-        if (is_null($callback)) {
-            if (empty($array)) {
-                return $default;
-            }
-
-            foreach ($array as $item) {
-                return $item;
-            }
-        }
-
-        foreach ($array as $key => $value) {
-            if (call_user_func($callback, $value, $key)) {
-                return $value;
-            }
-        }
-
-        return $default;
-    }
-
-    /**
-     * Return the last element in an array passing a given truth test.
-     *
-     * @param  array  $array
-     * @param  callable|null  $callback
-     * @param  mixed  $default
-     * @return mixed
-     */
-    public static function last($array, callable $callback = null, $default = null)
-    {
-        if (is_null($callback)) {
-            return empty($array) ? $default : end($array);
-        }
-
-        return static::first(array_reverse($array, true), $callback, $default);
-    }
-
-    /**
-     * Remove one or many array items from a given array using "dot" notation.
-     *
-     * @param  array  $array
-     * @param  array|string  $keys
-     * @return void
-     */
-    public static function forget(&$array, $keys)
-    {
-        $original = &$array;
-
-        $keys = (array) $keys;
-
-        if (count($keys) === 0) {
-            return;
-        }
-
-        foreach ($keys as $key) {
-            // if the exact key exists in the top-level, remove it
-            if (static::exists($array, $key)) {
-                unset($array[$key]);
-
-                continue;
-            }
-
-            $parts = explode('.', $key);
-
-            // clean up before each pass
-            $array = &$original;
-
-            while (count($parts) > 1) {
-                $part = array_shift($parts);
-
-                if (isset($array[$part]) && is_array($array[$part])) {
-                    $array = &$array[$part];
-                } else {
-                    continue 2;
-                }
-            }
-
-            unset($array[array_shift($parts)]);
-        }
-    }
-
-    /**
-     * Get an item from an array using "dot" notation.
-     *
-     * @param  \ArrayAccess|array  $array
-     * @param  string  $key
-     * @param  mixed   $default
-     * @return mixed
-     */
-    public static function get($array, $key, $default = null)
-    {
-        if (! static::accessible($array)) {
-            return $default;
-        }
-
-        if (is_null($key)) {
-            return $array;
-        }
-
-        if (static::exists($array, $key)) {
-            return $array[$key];
-        }
-
-        foreach (explode('.', $key) as $segment) {
-            if (static::accessible($array) && static::exists($array, $segment)) {
-                $array = $array[$segment];
-            } else {
-                return $default;
-            }
-        }
-
-        return $array;
-    }
-
-    /**
-     * Check if an item or items exist in an array using "dot" notation.
-     *
-     * @param  \ArrayAccess|array  $array
-     * @param  string|array  $keys
-     * @return bool
-     */
-    public static function has($array, $keys)
-    {
-        if (is_null($keys)) {
-            return false;
-        }
-
-        $keys = (array) $keys;
-
-        if (! $array) {
-            return false;
-        }
-
-        if ($keys === []) {
-            return false;
-        }
-
-        foreach ($keys as $key) {
-            $subKeyArray = $array;
-
-            if (static::exists($array, $key)) {
-                continue;
-            }
-
-            foreach (explode('.', $key) as $segment) {
-                if (static::accessible($subKeyArray) && static::exists($subKeyArray, $segment)) {
-                    $subKeyArray = $subKeyArray[$segment];
-                } else {
-                    return false;
-                }
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * Determines if an array is associative.
-     *
-     * An array is "associative" if it doesn't have sequential numerical keys beginning with zero.
-     *
-     * @param  array  $array
-     * @return bool
-     */
-    public static function isAssoc(array $array)
-    {
-        $keys = array_keys($array);
-
-        return array_keys($keys) !== $keys;
-    }
-
-    /**
-     * 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));
-    }
-
-    /**
-     * Pluck an array of values from an array.
-     *
-     * @param  array  $array
-     * @param  string|array  $value
-     * @param  string|array|null  $key
-     * @return array
-     */
-    public static function pluck($array, $value, $key = null)
-    {
-        $results = [];
-
-        list($value, $key) = static::explodePluckParameters($value, $key);
-
-        foreach ($array as $item) {
-            $itemValue = static::data_get($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 = static::data_get($item, $key);
-
-                $results[$itemKey] = $itemValue;
-            }
-        }
-
-        return $results;
-    }
-
-    /**
-     * Explode the "value" and "key" arguments passed to "pluck".
-     *
-     * @param  string|array  $value
-     * @param  string|array|null  $key
-     * @return array
-     */
-    protected static function explodePluckParameters($value, $key)
-    {
-        $value = is_string($value) ? explode('.', $value) : $value;
-
-        $key = is_null($key) || is_array($key) ? $key : explode('.', $key);
-
-        return [$value, $key];
-    }
-
-    /**
-     * Push an item onto the beginning of an array.
-     *
-     * @param  array  $array
-     * @param  mixed  $value
-     * @param  mixed  $key
-     * @return array
-     */
-    public static function prepend($array, $value, $key = null)
-    {
-        if (is_null($key)) {
-            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::forget($array, $key);
-
-        return $value;
-    }
-
-    /**
-     * Set an array item to a given value using "dot" notation.
-     *
-     * If no key is given to the method, the entire array will be replaced.
-     *
-     * @param  array   $array
-     * @param  string  $key
-     * @param  mixed   $value
-     * @return array
-     */
-    public static function set(&$array, $key, $value)
-    {
-        if (is_null($key)) {
-            return $array = $value;
-        }
-
-        $keys = explode('.', $key);
-
-        while (count($keys) > 1) {
-            $key = array_shift($keys);
-
-            // If the key doesn't exist at this depth, we will just create an empty array
-            // to hold the next value, allowing us to create the arrays to hold final
-            // values at the correct depth. Then we'll keep digging into the array.
-            if (! isset($array[$key]) || ! is_array($array[$key])) {
-                $array[$key] = [];
-            }
-
-            $array = &$array[$key];
-        }
-
-        $array[array_shift($keys)] = $value;
-
-        return $array;
-    }
-
-    /**
-     * Shuffle the given array and return the result.
-     *
-     * @param  array  $array
-     * @return array
-     */
-    public static function shuffle($array)
-    {
-        shuffle($array);
-
-        return $array;
-    }
-
-    /**
-     * Recursively sort an array by keys and values.
-     *
-     * @param  array  $array
-     * @return array
-     */
-    public static function sortRecursive($array)
-    {
-        foreach ($array as &$value) {
-            if (is_array($value)) {
-                $value = static::sortRecursive($value);
-            }
-        }
-
-        if (static::isAssoc($array)) {
-            ksort($array);
-        } else {
-            sort($array);
-        }
-
-        return $array;
-    }
-
-    /**
-     * Get an item from an array or object using "dot" notation.
-     *
-     * @param  mixed         $target
-     * @param  string|array  $key
-     * @param  mixed         $default
-     * @return mixed
-     */
-    public static function data_get($target, $key, $default = null)
-    {
-        if (is_null($key)) {
-            return $target;
-        }
-        $key = is_array($key) ? $key : explode('.', $key);
-        while (! is_null($segment = array_shift($key))) {
-            if ($segment === '*') {
-                if (! is_array($target)) {
-                    return $default;
-                }
-                $result = static::pluck($target, $key);
-                return in_array('*', $key) ? static::collapse($result) : $result;
-            }
-            if (static::accessible($target) && static::exists($target, $segment)) {
-                $target = $target[$segment];
-            } elseif (is_object($target) && isset($target->{$segment})) {
-                $target = $target->{$segment};
-            } else {
-                return $default;
-            }
-        }
-        return $target;
-    }
+	/**
+	 * Determine whether the given value is array accessible.
+	 *
+	 * @param  mixed  $value
+	 * @return bool
+	 */
+	public static function accessible($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
+	 * @param  string  $key
+	 * @param  mixed   $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 an array of arrays into a single array.
+	 *
+	 * @param  array  $array
+	 * @return array
+	 */
+	public static function collapse($array)
+	{
+		$results = [];
+		foreach ($array as $values) {
+			if (! is_array($values)) {
+				continue;
+			}
+			$results = array_merge($results, $values);
+		}
+		return $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)];
+	}
+
+	/**
+	 * Flatten a multi-dimensional associative array with dots.
+	 *
+	 * @param  array   $array
+	 * @param  string  $prepend
+	 * @return array
+	 */
+	public static function dot($array, $prepend = '')
+	{
+		$results = [];
+
+		foreach ($array as $key => $value) {
+			if (is_array($value) && ! empty($value)) {
+				$results = array_merge($results, static::dot($value, $prepend.$key.'.'));
+			} else {
+				$results[$prepend.$key] = $value;
+			}
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Get all of the given array except for a specified array of items.
+	 *
+	 * @param  array  $array
+	 * @param  array|string  $keys
+	 * @return array
+	 */
+	public static function except($array, $keys)
+	{
+		static::forget($array, $keys);
+
+		return $array;
+	}
+
+	/**
+	 * Determine if the given key exists in the provided array.
+	 *
+	 * @param  \ArrayAccess|array  $array
+	 * @param  string|int  $key
+	 * @return bool
+	 */
+	public static function exists($array, $key)
+	{
+		if ($array instanceof ArrayAccess) {
+			return $array->offsetExists($key);
+		}
+
+		return array_key_exists($key, $array);
+	}
+
+	/**
+	 * Return the first element in an array passing a given truth test.
+	 *
+	 * @param  array  $array
+	 * @param  callable|null  $callback
+	 * @param  mixed  $default
+	 * @return mixed
+	 */
+	public static function first($array, callable $callback = null, $default = null)
+	{
+		if (is_null($callback)) {
+			if (empty($array)) {
+				return $default;
+			}
+
+			foreach ($array as $item) {
+				return $item;
+			}
+		}
+
+		foreach ($array as $key => $value) {
+			if (call_user_func($callback, $value, $key)) {
+				return $value;
+			}
+		}
+
+		return $default;
+	}
+
+	/**
+	 * Return the last element in an array passing a given truth test.
+	 *
+	 * @param  array  $array
+	 * @param  callable|null  $callback
+	 * @param  mixed  $default
+	 * @return mixed
+	 */
+	public static function last($array, callable $callback = null, $default = null)
+	{
+		if (is_null($callback)) {
+			return empty($array) ? $default : end($array);
+		}
+
+		return static::first(array_reverse($array, true), $callback, $default);
+	}
+
+	/**
+	 * Remove one or many array items from a given array using "dot" notation.
+	 *
+	 * @param  array  $array
+	 * @param  array|string  $keys
+	 * @return void
+	 */
+	public static function forget(&$array, $keys)
+	{
+		$original = &$array;
+
+		$keys = (array) $keys;
+
+		if (count($keys) === 0) {
+			return;
+		}
+
+		foreach ($keys as $key) {
+			// if the exact key exists in the top-level, remove it
+			if (static::exists($array, $key)) {
+				unset($array[$key]);
+
+				continue;
+			}
+
+			$parts = explode('.', $key);
+
+			// clean up before each pass
+			$array = &$original;
+
+			while (count($parts) > 1) {
+				$part = array_shift($parts);
+
+				if (isset($array[$part]) && is_array($array[$part])) {
+					$array = &$array[$part];
+				} else {
+					continue 2;
+				}
+			}
+
+			unset($array[array_shift($parts)]);
+		}
+	}
+
+	/**
+	 * Get an item from an array using "dot" notation.
+	 *
+	 * @param  \ArrayAccess|array  $array
+	 * @param  string  $key
+	 * @param  mixed   $default
+	 * @return mixed
+	 */
+	public static function get($array, $key, $default = null)
+	{
+		if (! static::accessible($array)) {
+			return $default;
+		}
+
+		if (is_null($key)) {
+			return $array;
+		}
+
+		if (static::exists($array, $key)) {
+			return $array[$key];
+		}
+
+		foreach (explode('.', $key) as $segment) {
+			if (static::accessible($array) && static::exists($array, $segment)) {
+				$array = $array[$segment];
+			} else {
+				return $default;
+			}
+		}
+
+		return $array;
+	}
+
+	/**
+	 * Check if an item or items exist in an array using "dot" notation.
+	 *
+	 * @param  \ArrayAccess|array  $array
+	 * @param  string|array  $keys
+	 * @return bool
+	 */
+	public static function has($array, $keys)
+	{
+		if (is_null($keys)) {
+			return false;
+		}
+
+		$keys = (array) $keys;
+
+		if (! $array) {
+			return false;
+		}
+
+		if ($keys === []) {
+			return false;
+		}
+
+		foreach ($keys as $key) {
+			$subKeyArray = $array;
+
+			if (static::exists($array, $key)) {
+				continue;
+			}
+
+			foreach (explode('.', $key) as $segment) {
+				if (static::accessible($subKeyArray) && static::exists($subKeyArray, $segment)) {
+					$subKeyArray = $subKeyArray[$segment];
+				} else {
+					return false;
+				}
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * Determines if an array is associative.
+	 *
+	 * An array is "associative" if it doesn't have sequential numerical keys beginning with zero.
+	 *
+	 * @param  array  $array
+	 * @return bool
+	 */
+	public static function isAssoc(array $array)
+	{
+		$keys = array_keys($array);
+
+		return array_keys($keys) !== $keys;
+	}
+
+	/**
+	 * 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));
+	}
+
+	/**
+	 * Pluck an array of values from an array.
+	 *
+	 * @param  array  $array
+	 * @param  string|array  $value
+	 * @param  string|array|null  $key
+	 * @return array
+	 */
+	public static function pluck($array, $value, $key = null)
+	{
+		$results = [];
+
+		list($value, $key) = static::explodePluckParameters($value, $key);
+
+		foreach ($array as $item) {
+			$itemValue = static::data_get($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 = static::data_get($item, $key);
+
+				$results[$itemKey] = $itemValue;
+			}
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Explode the "value" and "key" arguments passed to "pluck".
+	 *
+	 * @param  string|array  $value
+	 * @param  string|array|null  $key
+	 * @return array
+	 */
+	protected static function explodePluckParameters($value, $key)
+	{
+		$value = is_string($value) ? explode('.', $value) : $value;
+
+		$key = is_null($key) || is_array($key) ? $key : explode('.', $key);
+
+		return [$value, $key];
+	}
+
+	/**
+	 * Push an item onto the beginning of an array.
+	 *
+	 * @param  array  $array
+	 * @param  mixed  $value
+	 * @param  mixed  $key
+	 * @return array
+	 */
+	public static function prepend($array, $value, $key = null)
+	{
+		if (is_null($key)) {
+			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::forget($array, $key);
+
+		return $value;
+	}
+
+	/**
+	 * Set an array item to a given value using "dot" notation.
+	 *
+	 * If no key is given to the method, the entire array will be replaced.
+	 *
+	 * @param  array   $array
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return array
+	 */
+	public static function set(&$array, $key, $value)
+	{
+		if (is_null($key)) {
+			return $array = $value;
+		}
+
+		$keys = explode('.', $key);
+
+		while (count($keys) > 1) {
+			$key = array_shift($keys);
+
+			// If the key doesn't exist at this depth, we will just create an empty array
+			// to hold the next value, allowing us to create the arrays to hold final
+			// values at the correct depth. Then we'll keep digging into the array.
+			if (! isset($array[$key]) || ! is_array($array[$key])) {
+				$array[$key] = [];
+			}
+
+			$array = &$array[$key];
+		}
+
+		$array[array_shift($keys)] = $value;
+
+		return $array;
+	}
+
+	/**
+	 * Shuffle the given array and return the result.
+	 *
+	 * @param  array  $array
+	 * @return array
+	 */
+	public static function shuffle($array)
+	{
+		shuffle($array);
+
+		return $array;
+	}
+
+	/**
+	 * Recursively sort an array by keys and values.
+	 *
+	 * @param  array  $array
+	 * @return array
+	 */
+	public static function sortRecursive($array)
+	{
+		foreach ($array as &$value) {
+			if (is_array($value)) {
+				$value = static::sortRecursive($value);
+			}
+		}
+
+		if (static::isAssoc($array)) {
+			ksort($array);
+		} else {
+			sort($array);
+		}
+
+		return $array;
+	}
+
+	/**
+	 * Get an item from an array or object using "dot" notation.
+	 *
+	 * @param  mixed         $target
+	 * @param  string|array  $key
+	 * @param  mixed         $default
+	 * @return mixed
+	 */
+	public static function data_get($target, $key, $default = null)
+	{
+		if (is_null($key)) {
+			return $target;
+		}
+		$key = is_array($key) ? $key : explode('.', $key);
+		while (! is_null($segment = array_shift($key))) {
+			if ($segment === '*') {
+				if (! is_array($target)) {
+					return $default;
+				}
+				$result = static::pluck($target, $key);
+				return in_array('*', $key) ? static::collapse($result) : $result;
+			}
+			if (static::accessible($target) && static::exists($target, $segment)) {
+				$target = $target[$segment];
+			} elseif (is_object($target) && isset($target->{$segment})) {
+				$target = $target->{$segment};
+			} else {
+				return $default;
+			}
+		}
+		return $target;
+	}
 }