htmlburger / wpemerge

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;
+	}
 }

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,9 +481,9 @@ 
             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 (! is_array($target)) {
+                if ( ! is_array($target)) {
                     return $default;
                 }
                 $result = static::pluck($target, $key);

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_callable( $this->handler ) ) {
-			return call_user_func_array( $this->handler, $arguments );
+		if (is_callable($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);
 	}
 }