htmlburger / wpemerge

src/Request.php

Spacing +17 added lines, -17 removed lines

@@ -56,7 +56,7 @@ 
 	 * @return Request
 	 */
 	public static function fromGlobals() {
-		return new static( stripslashes_deep( $_GET ), stripslashes_deep( $_POST ), $_COOKIE, $_FILES, $_SERVER, getallheaders() );
+		return new static(stripslashes_deep($_GET), stripslashes_deep($_POST), $_COOKIE, $_FILES, $_SERVER, getallheaders());
 	}
 
 	/**
@@ -69,7 +69,7 @@ 
 	 * @param array $server
 	 * @param array $headers
 	 */
-	public function __construct( $get, $post, $cookie, $files, $server, $headers ) {
+	public function __construct($get, $post, $cookie, $files, $server, $headers) {
 		$this->get = $get;
 		$this->post = $post;
 		$this->cookie = $cookie;
@@ -84,14 +84,14 @@ 
 	 * @return string
 	 */
 	public function getMethod() {
-		$method = (string) Arr::get( $this->server, 'REQUEST_METHOD', 'GET' );
+		$method = (string) Arr::get($this->server, 'REQUEST_METHOD', 'GET');
 		
-		$override = (string) Arr::get( $this->headers, 'X-HTTP-METHOD-OVERRIDE' );
-		if ( $method === 'POST' && $override ) {
+		$override = (string) Arr::get($this->headers, 'X-HTTP-METHOD-OVERRIDE');
+		if ($method === 'POST' && $override) {
 			$method = $override;
 		}
 
-		return strtoupper( $method );
+		return strtoupper($method);
 	}
 
 	/**
@@ -100,11 +100,11 @@ 
 	 * @return string
 	 */
 	public function getUrl() {
-		$https = Arr::get( $this->server, 'HTTPS' );
+		$https = Arr::get($this->server, 'HTTPS');
 
 		$protocol = $https ? 'https' : 'http';
-		$host = (string) Arr::get( $this->server, 'HTTP_HOST', '' );
-		$uri = (string) Arr::get( $this->server, 'REQUEST_URI', '' );
+		$host = (string) Arr::get($this->server, 'HTTP_HOST', '');
+		$uri = (string) Arr::get($this->server, 'REQUEST_URI', '');
 
 		return $protocol . '://' . $host . $uri;
 	}
@@ -118,12 +118,12 @@ 
 		$args = func_get_args();
 		$source = $this->{$args[0]};
 
-		if ( count( $args ) === 1 ) {
+		if (count($args) === 1) {
 			return $source;
 		}
 
 		$args[0] = $source;
-		return call_user_func_array( [Arr::class, 'get'], $args );
+		return call_user_func_array([Arr::class, 'get'], $args);
 	}
 
 	/**
@@ -132,7 +132,7 @@ 
 	 * @return mixed
 	 */
 	public function get() {
-		return call_user_func_array( [$this, 'input'], array_merge( ['get'], func_get_args() ) );
+		return call_user_func_array([$this, 'input'], array_merge(['get'], func_get_args()));
 	}
 
 	/**
@@ -141,7 +141,7 @@ 
 	 * @return mixed
 	 */
 	public function post() {
-		return call_user_func_array( [$this, 'input'], array_merge( ['post'], func_get_args() ) );
+		return call_user_func_array([$this, 'input'], array_merge(['post'], func_get_args()));
 	}
 
 	/**
@@ -150,7 +150,7 @@ 
 	 * @return mixed
 	 */
 	public function cookie() {
-		return call_user_func_array( [$this, 'input'], array_merge( ['cookie'], func_get_args() ) );
+		return call_user_func_array([$this, 'input'], array_merge(['cookie'], func_get_args()));
 	}
 
 	/**
@@ -159,7 +159,7 @@ 
 	 * @return mixed
 	 */
 	public function files() {
-		return call_user_func_array( [$this, 'input'], array_merge( ['files'], func_get_args() ) );
+		return call_user_func_array([$this, 'input'], array_merge(['files'], func_get_args()));
 	}
 
 	/**
@@ -168,7 +168,7 @@ 
 	 * @return mixed
 	 */
 	public function server() {
-		return call_user_func_array( [$this, 'input'], array_merge( ['server'], func_get_args() ) );
+		return call_user_func_array([$this, 'input'], array_merge(['server'], func_get_args()));
 	}
 
 	/**
@@ -177,6 +177,6 @@ 
 	 * @return mixed
 	 */
 	public function headers() {
-		return call_user_func_array( [$this, 'input'], array_merge( ['headers'], func_get_args() ) );
+		return call_user_func_array([$this, 'input'], array_merge(['headers'], func_get_args()));
 	}
 }

src/Framework.php

Spacing +42 added lines, -42 removed lines

@@ -38,7 +38,7 @@ 
 	 * @return boolean
 	 */
 	public static function debugging() {
-		return ( defined( 'WP_DEBUG' ) && WP_DEBUG );
+		return (defined('WP_DEBUG') && WP_DEBUG);
 	}
 
 	/**
@@ -57,8 +57,8 @@ 
 	 * @return null
 	 */
 	public static function verifyBoot() {
-		if ( ! static::isBooted() ) {
-			throw new Exception( get_called_class() . ' must be booted first.' );
+		if ( ! static::isBooted()) {
+			throw new Exception(get_called_class() . ' must be booted first.');
 		}
 	}
 
@@ -68,7 +68,7 @@ 
 	 * @return Container
 	 */
 	public static function getContainer() {
-		if ( static::$container === null ) {
+		if (static::$container === null) {
 			static::$container = new Container();
 		}
 		return static::$container;
@@ -82,29 +82,29 @@ 
 	 * @throws Exception
 	 * @return null
 	 */
-	public static function boot( $config ) {
-		if ( static::isBooted() ) {
-			throw new Exception( get_called_class() . ' already booted.' );
+	public static function boot($config) {
+		if (static::isBooted()) {
+			throw new Exception(get_called_class() . ' already booted.');
 		}
 		static::$booted = true;
 
 		$container = static::getContainer();
 
-		$container['framework.config'] = array_merge( [
+		$container['framework.config'] = array_merge([
 			'providers' => [],
-		], $config );
+		], $config);
 
-		$container['framework.service_providers'] = array_merge( [
+		$container['framework.service_providers'] = array_merge([
 			RoutingServiceProvider::class,
 			FlashServiceProvider::class,
 			OldInputServiceProvider::class,
 			TemplatingServiceProvider::class,
-		], $container['framework.config']['providers'] );
+		], $container['framework.config']['providers']);
 
-		Facade::setFacadeApplication( $container );
+		Facade::setFacadeApplication($container);
 		AliasLoader::getInstance()->register();
 
-		static::loadServiceProviders( $container );
+		static::loadServiceProviders($container);
 	}
 
 	/**
@@ -113,15 +113,15 @@ 
 	 * @param  Container $container
 	 * @return null
 	 */
-	protected static function loadServiceProviders( $container ) {
-		$container['framework.service_providers'] = apply_filters( 'carbon_framework_service_providers', $container['framework.service_providers'] );
+	protected static function loadServiceProviders($container) {
+		$container['framework.service_providers'] = apply_filters('carbon_framework_service_providers', $container['framework.service_providers']);
 
-		$service_providers = array_map( function( $service_provider ) {
+		$service_providers = array_map(function($service_provider) {
 			return new $service_provider();
-		}, $container['framework.service_providers'] );
+		}, $container['framework.service_providers']);
 
-		static::registerServiceProviders( $service_providers, $container );
-		static::bootServiceProviders( $service_providers, $container );
+		static::registerServiceProviders($service_providers, $container);
+		static::bootServiceProviders($service_providers, $container);
 	}
 
 	/**
@@ -130,9 +130,9 @@ 
 	 * @param  Container $container
 	 * @return null
 	 */
-	protected static function registerServiceProviders( $service_providers, $container ) {
-		foreach ( $service_providers as $provider ) {
-			$provider->register( $container );
+	protected static function registerServiceProviders($service_providers, $container) {
+		foreach ($service_providers as $provider) {
+			$provider->register($container);
 		}
 	}
 
@@ -142,9 +142,9 @@ 
 	 * @param  Container $container
 	 * @return null
 	 */
-	protected static function bootServiceProviders( $service_providers, $container ) {
-		foreach ( $service_providers as $provider ) {
-			$provider->boot( $container );
+	protected static function bootServiceProviders($service_providers, $container) {
+		foreach ($service_providers as $provider) {
+			$provider->boot($container);
 		}
 	}
 
@@ -155,8 +155,8 @@ 
 	 * @param  string $facade_class
 	 * @return null
 	 */
-	public static function facade( $alias, $facade_class ) {
-		AliasLoader::getInstance()->alias( $alias, $facade_class );
+	public static function facade($alias, $facade_class) {
+		AliasLoader::getInstance()->alias($alias, $facade_class);
 	}
 
 	/**
@@ -165,14 +165,14 @@ 
 	 * @param  string   $key
 	 * @return mixed|null
 	 */
-	public static function resolve( $key ) {
+	public static function resolve($key) {
 		static::verifyBoot();
 
-		if ( ! isset( static::getContainer()[ $key ] ) ) {
+		if ( ! isset(static::getContainer()[$key])) {
 			return null;
 		}
 
-		return static::getContainer()[ $key ];
+		return static::getContainer()[$key];
 	}
 
 	/**
@@ -181,28 +181,28 @@ 
 	 * @param  string $class
 	 * @return object
 	 */
-	public static function instantiate( $class ) {
+	public static function instantiate($class) {
 		static::verifyBoot();
 
-		$instance = static::resolve( $class );
-		if ( $instance === null ) {
+		$instance = static::resolve($class);
+		if ($instance === null) {
 			try {
-				$reflection = new ReflectionMethod( $class, '__construct' );
+				$reflection = new ReflectionMethod($class, '__construct');
 
-				if ( ! $reflection->isPublic() ) {
-					throw new Exception( $class . '::__construct() is not public.' );
+				if ( ! $reflection->isPublic()) {
+					throw new Exception($class . '::__construct() is not public.');
 				}
 
 				$parameters = $reflection->getParameters();
 
-				$required_parameters = array_filter( $parameters, function( $parameter ) {
+				$required_parameters = array_filter($parameters, function($parameter) {
 					return ! $parameter->isOptional();
 				} );
 
-				if ( ! empty( $required_parameters ) ) {
-					throw new Exception( $class . '::__construct() has requird parameters but could not be resolved from container. Did you miss to define it into the container?' );
+				if ( ! empty($required_parameters)) {
+					throw new Exception($class . '::__construct() has requird parameters but could not be resolved from container. Did you miss to define it into the container?');
 				}
-			} catch ( ReflectionException $e ) {
+			} catch (ReflectionException $e) {
 				// __constructor is not defined so we are free to create a new instance
 			}
 
@@ -218,7 +218,7 @@ 
 	 * @param  ResponseInterface $response
 	 * @return null
 	 */
-	public static function respond( ResponseInterface $response ) {
-		Response::respond( $response );
+	public static function respond(ResponseInterface $response) {
+		Response::respond($response);
 	}
 }

src/Controllers/Controller.php

Spacing +10 added lines, -10 removed lines

@@ -19,35 +19,35 @@
 	/**
 	 * @see Response::output()
 	 */
-	protected function output( $output ) {
-		return Response::output( $this->response(), $output );
+	protected function output($output) {
+		return Response::output($this->response(), $output);
 	}
 
 	/**
 	 * @see Response::template()
 	 */
-	protected function template( $templates, $context = array() ) {
-		return Response::template( $this->response(), $templates, $context );
+	protected function template($templates, $context = array()) {
+		return Response::template($this->response(), $templates, $context);
 	}
 
 	/**
 	 * @see Response::json()
 	 */
-	protected function json( $data ) {
-		return Response::json( $this->response(), $data );
+	protected function json($data) {
+		return Response::json($this->response(), $data);
 	}
 
 	/**
 	 * @see Response::redirect()
 	 */
-	protected function redirect( $url, $status = 302 ) {
-		return Response::redirect( $this->response(), $url, $status );
+	protected function redirect($url, $status = 302) {
+		return Response::redirect($this->response(), $url, $status);
 	}
 
 	/**
 	 * @see Response::error()
 	 */
-	protected function error( $code ) {
-		return Response::error( $this->response(), $code );
+	protected function error($code) {
+		return Response::error($this->response(), $code);
 	}
 }

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 +491 added lines, -491 removed lines

@@ -10,495 +10,495 @@
  */
 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 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 ($target instanceof Collection) {
-                    $target = $target->all();
-                } elseif (! 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 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 ($target instanceof Collection) {
+					$target = $target->all();
+				} elseif (! 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;
+	}
 }

Spacing +8 added lines, -8 removed lines

@@ -48,7 +48,7 @@ 
     {
         $results = [];
         foreach ($array as $values) {
-            if (! is_array($values)) {
+            if ( ! is_array($values)) {
                 continue;
             }
             $results = array_merge($results, $values);
@@ -80,9 +80,9 @@ 
 
         foreach ($array as $key => $value) {
             if (is_array($value) && ! empty($value)) {
-                $results = array_merge($results, static::dot($value, $prepend.$key.'.'));
+                $results = array_merge($results, static::dot($value, $prepend . $key . '.'));
             } else {
-                $results[$prepend.$key] = $value;
+                $results[$prepend . $key] = $value;
             }
         }
 
@@ -219,7 +219,7 @@ 
      */
     public static function get($array, $key, $default = null)
     {
-        if (! static::accessible($array)) {
+        if ( ! static::accessible($array)) {
             return $default;
         }
 
@@ -257,7 +257,7 @@ 
 
         $keys = (array) $keys;
 
-        if (! $array) {
+        if ( ! $array) {
             return false;
         }
 
@@ -419,7 +419,7 @@ 
             // 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])) {
+            if ( ! isset($array[$key]) || ! is_array($array[$key])) {
                 $array[$key] = [];
             }
 
@@ -481,11 +481,11 @@ 
             return $target;
         }
         $key = is_array($key) ? $key : explode('.', $key);
-        while (! is_null($segment = array_shift($key))) {
+        while ( ! is_null($segment = array_shift($key))) {
             if ($segment === '*') {
                 if ($target instanceof Collection) {
                     $target = $target->all();
-                } elseif (! is_array($target)) {
+                } elseif ( ! is_array($target)) {
                     return $default;
                 }
                 $result = static::pluck($target, $key);

src/Routing/Route.php

Spacing +22 added lines, -22 removed lines

@@ -44,29 +44,29 @@ 
 	 * @param mixed           $target
 	 * @param string|\Closure $handler
 	 */
-	public function __construct( $methods, $target, $handler ) {
-		if ( is_string( $target ) ) {
-			$target = new UrlCondition( $target );
+	public function __construct($methods, $target, $handler) {
+		if (is_string($target)) {
+			$target = new UrlCondition($target);
 		}
 
-		if ( is_array( $target ) ) {
-			$target = $this->condition( $target );
+		if (is_array($target)) {
+			$target = $this->condition($target);
 		}
 
-		if ( ! is_a( $target, ConditionInterface::class ) ) {
-			throw new Exception( 'Route target is not a valid route string or condition.' );
+		if ( ! is_a($target, ConditionInterface::class)) {
+			throw new Exception('Route target is not a valid route string or condition.');
 		}
 
 		$this->methods = $methods;
 		$this->target = $target;
-		$this->handler = new Handler( $handler );
+		$this->handler = new Handler($handler);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	public function satisfied() {
-		if ( ! in_array( $_SERVER['REQUEST_METHOD'], $this->methods) ) {
+		if ( ! in_array($_SERVER['REQUEST_METHOD'], $this->methods)) {
 			return false;
 		}
 		return $this->target->satisfied();
@@ -75,10 +75,10 @@ 
 	/**
 	 * {@inheritDoc}
 	 */
-	public function handle( $request ) {
-		$arguments = array_merge( [$request], $this->target->getArguments() );
-		return $this->executeMiddleware( $this->getMiddleware(), $request, function() use ( $arguments ) {
-			return call_user_func_array( [$this->handler, 'execute'], $arguments );
+	public function handle($request) {
+		$arguments = array_merge([$request], $this->target->getArguments());
+		return $this->executeMiddleware($this->getMiddleware(), $request, function() use ($arguments) {
+			return call_user_func_array([$this->handler, 'execute'], $arguments);
 		} );
 	}
 
@@ -88,21 +88,21 @@ 
 	 * @param  array $options
 	 * @return ConditionInterface
 	 */
-	public function condition( $options ) {
-		if ( count( $options ) === 0 ) {
-			throw new Exception( 'No condition type specified.' );
+	public function condition($options) {
+		if (count($options) === 0) {
+			throw new Exception('No condition type specified.');
 		}
 
 		$condition_type = $options[0];
-		$arguments = array_slice( $options, 1 );
+		$arguments = array_slice($options, 1);
 
-		$condition_class = Framework::resolve( 'framework.routing.conditions.' . $condition_type );
-		if ( $condition_class === null ) {
-			throw new Exception( 'Unknown condition type specified: ' . $condition_type );
+		$condition_class = Framework::resolve('framework.routing.conditions.' . $condition_type);
+		if ($condition_class === null) {
+			throw new Exception('Unknown condition type specified: ' . $condition_type);
 		}
 
-		$reflection = new ReflectionClass( $condition_class );
-		$condition = $reflection->newInstanceArgs( $arguments );
+		$reflection = new ReflectionClass($condition_class);
+		$condition = $reflection->newInstanceArgs($arguments);
 		return $condition;
 	}
 }

src/Routing/Conditions/Custom.php

Spacing +3 added lines, -3 removed lines

@@ -26,16 +26,16 @@
 	 * @param callable $callable
 	 * @param mixed    ...$arguments
 	 */
-	public function __construct( $callable ) {
+	public function __construct($callable) {
 		$this->callable = $callable;
-		$this->arguments = array_slice( func_get_args(), 1 );
+		$this->arguments = array_slice(func_get_args(), 1);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	public function satisfied() {
-		return call_user_func_array( $this->callable, $this->arguments );
+		return call_user_func_array($this->callable, $this->arguments);
 	}
 
 	/**

src/Routing/Middleware/HasMiddlewareTrait.php

Spacing +20 added lines, -20 removed lines

@@ -23,12 +23,12 @@ 
 	 * @param  mixed   $middleware
 	 * @return boolean
 	 */
-	protected function isMiddleware( $middleware ) {
-		if ( is_callable( $middleware ) ) {
+	protected function isMiddleware($middleware) {
+		if (is_callable($middleware)) {
 			return true;
 		}
 		
-		if ( is_a( $middleware, MiddlewareInterface::class, true ) ) {
+		if (is_a($middleware, MiddlewareInterface::class, true)) {
 			return true;
 		}
 
@@ -50,16 +50,16 @@ 
 	 * @param  string|callable|\CarbonFramework\Routing\Middleware\MiddlewareInterface|array $middleware
 	 * @return object
 	 */
-	public function addMiddleware( $middleware ) {
-		$middleware = is_array( $middleware ) ? $middleware : [$middleware];
+	public function addMiddleware($middleware) {
+		$middleware = is_array($middleware) ? $middleware : [$middleware];
 
-		foreach ( $middleware as $item ) {
-			if ( ! $this->isMiddleware( $item ) ) {
-				throw new Exception( 'Passed middleware must be a callable or the name of a class which implements the ' . MiddlewareInterface::class . ' interface.' );
+		foreach ($middleware as $item) {
+			if ( ! $this->isMiddleware($item)) {
+				throw new Exception('Passed middleware must be a callable or the name of a class which implements the ' . MiddlewareInterface::class . ' interface.');
 			}
 		}
 
-		$this->middleware = array_merge( $this->getMiddleware(), $middleware );
+		$this->middleware = array_merge($this->getMiddleware(), $middleware);
 		return $this;
 	}
 
@@ -69,8 +69,8 @@ 
 	 * @param  string|callable|\CarbonFramework\Routing\Middleware\MiddlewareInterface|array $middleware
 	 * @return object
 	 */
-	public function add( $middleware ) {
-		return $this->addMiddleware( $middleware );
+	public function add($middleware) {
+		return $this->addMiddleware($middleware);
 	}
 
 	/**
@@ -81,22 +81,22 @@ 
 	 * @param  Closure                                                   $next
 	 * @return ResponseInterface
 	 */
-	public function executeMiddleware( $middleware, $request, Closure $next ) {
-		$top_middleware = array_pop( $middleware );
+	public function executeMiddleware($middleware, $request, Closure $next) {
+		$top_middleware = array_pop($middleware);
 
-		if ( $top_middleware === null ) {
-			return $next( $request );
+		if ($top_middleware === null) {
+			return $next($request);
 		}
 
-		$top_middleware_next = function( $request ) use ( $middleware, $next ) {
-			return $this->executeMiddleware( $middleware, $request, $next );
+		$top_middleware_next = function($request) use ($middleware, $next) {
+			return $this->executeMiddleware($middleware, $request, $next);
 		};
 
-		if ( is_callable( $top_middleware ) ) {
-			return call_user_func( $top_middleware, $request, $top_middleware_next );
+		if (is_callable($top_middleware)) {
+			return call_user_func($top_middleware, $request, $top_middleware_next);
 		}
 
 		$instance = new $top_middleware();
-		return $instance->handle( $request, $top_middleware_next );
+		return $instance->handle($request, $top_middleware_next);
 	}
 }

src/Routing/Handler.php

Spacing +16 added lines, -16 removed lines

@@ -22,8 +22,8 @@ 
 	 * 
 	 * @param string|Closure $handler
 	 */
-	public function __construct( $handler ) {
-		$this->set( $handler );
+	public function __construct($handler) {
+		$this->set($handler);
 	}
 
 	/**
@@ -32,15 +32,15 @@ 
 	 * @param  string|Closure $handler
 	 * @return callable|array|null
 	 */
-	protected function parse( $handler ) {
-		if ( $handler instanceof Closure ) {
+	protected function parse($handler) {
+		if ($handler instanceof Closure) {
 			return $handler;
 		}
 
-		if ( is_string( $handler ) )  {
-			$handlerPieces = preg_split( '/@|::/', $handler, 2 );
-			if ( count( $handlerPieces ) === 1 ) {
-				if ( is_callable( $handlerPieces[0] ) ) {
+		if (is_string($handler)) {
+			$handlerPieces = preg_split('/@|::/', $handler, 2);
+			if (count($handlerPieces) === 1) {
+				if (is_callable($handlerPieces[0])) {
 					return $handlerPieces[0];
 				} else {
 					return null;
@@ -62,11 +62,11 @@ 
 	 * @param string|Closure $new_handler
 	 * @return null
 	 */
-	public function set( $new_handler ) {
-		$handler = $this->parse( $new_handler );
+	public function set($new_handler) {
+		$handler = $this->parse($new_handler);
 
-		if ( $handler === null ) {
-			throw new Exception( 'No or invalid handler provided.' );
+		if ($handler === null) {
+			throw new Exception('No or invalid handler provided.');
 		}
 
 		$this->handler = $handler;
@@ -79,14 +79,14 @@ 
 	 */
 	public function execute() {
 		$arguments = func_get_args();
-		if ( ! is_array( $this->handler ) ) {
-			return call_user_func_array( $this->handler, $arguments );
+		if ( ! is_array($this->handler)) {
+			return call_user_func_array($this->handler, $arguments);
 		}
 
 		$class = $this->handler['class'];
 		$method = $this->handler['method'];
 
-		$controller = Framework::instantiate( $class );
-		return call_user_func_array( [$controller, $method], $arguments );
+		$controller = Framework::instantiate($class);
+		return call_user_func_array([$controller, $method], $arguments);
 	}
 }