lenevor / syscodes

src/components/Collections/Arr.php

Indentation +367 added lines, -367 removed lines

@@ -32,39 +32,39 @@ 
  */
 class Arr
 {
-	/**
-	 * Determine whether the value is accessible in a array.
-	 *
-	 * @param  mixed  $value The default value
-	 *
-	 * @return bool
-	 *
-	 * @uses   instanceof ArrayAccess
-	 */
-	public static function access($value) 
-	{
-		return is_array($value) || $value instanceof ArrayAccess;
-	}
-
-	/**
-	 * Add an element to an array using "dot" notation if it doesn't exist.
-	 *
-	 * @param  array  $array  The search array 
-	 * @param  string  $key  The key exist
-	 * @param  mixed  $value  The default value
-	 *
-	 * @return array 
-	 */
-	public static function add($array, $key, $value)
-	{
-		if (is_null(static::get($array, $key))) {
-			static::set($array, $key, $value);
-		}
-
-		return $array;
-	}
-
-	/**
+    /**
+     * Determine whether the value is accessible in a array.
+     *
+     * @param  mixed  $value The default value
+     *
+     * @return bool
+     *
+     * @uses   instanceof ArrayAccess
+     */
+    public static function access($value) 
+    {
+        return is_array($value) || $value instanceof ArrayAccess;
+    }
+
+    /**
+     * Add an element to an array using "dot" notation if it doesn't exist.
+     *
+     * @param  array  $array  The search array 
+     * @param  string  $key  The key exist
+     * @param  mixed  $value  The default value
+     *
+     * @return array 
+     */
+    public static function add($array, $key, $value)
+    {
+        if (is_null(static::get($array, $key))) {
+            static::set($array, $key, $value);
+        }
+
+        return $array;
+    }
+
+    /**
      * Collapse the collection items into a single array.
      * 
      * @return static
@@ -74,358 +74,358 @@ 
         $results = [];
 
         foreach ($array as $values) {
-			if ($values instanceof Collection) {
-				$values = $values->all();
-			} elseif ( ! is_array($values)) {
-				continue;
-			}
+            if ($values instanceof Collection) {
+                $values = $values->all();
+            } elseif ( ! is_array($values)) {
+                continue;
+            }
 
-			$results[] = $values;
+            $results[] = $values;
         }
 
         return array_merge([], ...$results);
     }
 
-	/**
-	 * Divide an array into two arrays. One with keys and the other with values.
-	 *
-	 * @param  array  $array
-	 *
-	 * @return array
-	 */
-	public static function divide($array)
-	{
-		return [array_keys($array), array_values($array)];
-	}
-
-	/**
-	 * Get all of the given array except for a specified array of items.
-	 *
-	 * @param  array  $array
-	 * @param  string|array  $keys
-	 *
-	 * @return array
-	 */
-	public static function except($array, $keys)
-	{
-		static::erase($array, $keys);
-
-		return $array;
-	}
+    /**
+     * Divide an array into two arrays. One with keys and the other with values.
+     *
+     * @param  array  $array
+     *
+     * @return array
+     */
+    public static function divide($array)
+    {
+        return [array_keys($array), array_values($array)];
+    }
+
+    /**
+     * Get all of the given array except for a specified array of items.
+     *
+     * @param  array  $array
+     * @param  string|array  $keys
+     *
+     * @return array
+     */
+    public static function except($array, $keys)
+    {
+        static::erase($array, $keys);
+
+        return $array;
+    }
 	
-	/**
-	 * Determine if the given key exists in the provided array.
-	 *
-	 * @param  ArrayAccess|array  $array  The search array
-	 * @param  string|int  $key  The key exist
-	 *
-	 * @return bool
-	 *
-	 * @uses   instaceof ArrayAccess
-	 */
-	public static function exists($array, $key) 
-	{
-		if ($array instanceof ArrayAccess) {
-			return $array->offsetExists($key);
-		}
+    /**
+     * Determine if the given key exists in the provided array.
+     *
+     * @param  ArrayAccess|array  $array  The search array
+     * @param  string|int  $key  The key exist
+     *
+     * @return bool
+     *
+     * @uses   instaceof ArrayAccess
+     */
+    public static function exists($array, $key) 
+    {
+        if ($array instanceof ArrayAccess) {
+            return $array->offsetExists($key);
+        }
 		
-		return array_key_exists($key, $array);
-	}
-
-	/**
-	 * Unsets dot-notated key from an array.
-	 *
-	 * @param  array  $array  The search array
-	 * @param  mixed  $keys  The dot-notated key or array of keys
-	 *
-	 * @return mixed
-	 */
-	public static function erase(&$array, $keys)
-	{
-		$original = &$array;
-
-		$keys = (array) $keys;
-
-		if (count($keys) === 0) {
-			return;
-		}
-
-		foreach ($keys as $key) {
-			if (static::exists($array, $key)) {
-				unset($array[$key]);
-
-				continue;
-			}
+        return array_key_exists($key, $array);
+    }
+
+    /**
+     * Unsets dot-notated key from an array.
+     *
+     * @param  array  $array  The search array
+     * @param  mixed  $keys  The dot-notated key or array of keys
+     *
+     * @return mixed
+     */
+    public static function erase(&$array, $keys)
+    {
+        $original = &$array;
+
+        $keys = (array) $keys;
+
+        if (count($keys) === 0) {
+            return;
+        }
+
+        foreach ($keys as $key) {
+            if (static::exists($array, $key)) {
+                unset($array[$key]);
+
+                continue;
+            }
 			
-			$parts = explode('.', $key);
+            $parts = explode('.', $key);
 
-			// Clean up after each pass
-			$array = &$original;
+            // Clean up after each pass
+            $array = &$original;
 	
-			// traverse the array into the second last key
-			while (count($parts) > 1) {
-				$part = array_shift($parts);
+            // traverse the array into the second last key
+            while (count($parts) > 1) {
+                $part = array_shift($parts);
 	
-				if (isset($array[$part]) && is_array($array[$part])) {
-					$array = &$array[$key];
-				} else {
-					continue 2;
-				}
-			}
-
-			unset($array[array_shift($parts)]);
-		}
-	}
-
-	/**
-	 * Flatten a multi-dimensional array into a single level.
-	 * 
-	 * @param  array  $array
-	 * 
-	 * @return array
-	 */
-	public static function flatten($array)
-	{
-		$result = [];
-
-		array_walk_recursive($array, function ($value) use (&$result) {
-			$result[] = $value;
-		});
-
-		return $result;
-	}
+                if (isset($array[$part]) && is_array($array[$part])) {
+                    $array = &$array[$key];
+                } else {
+                    continue 2;
+                }
+            }
+
+            unset($array[array_shift($parts)]);
+        }
+    }
+
+    /**
+     * Flatten a multi-dimensional array into a single level.
+     * 
+     * @param  array  $array
+     * 
+     * @return array
+     */
+    public static function flatten($array)
+    {
+        $result = [];
+
+        array_walk_recursive($array, function ($value) use (&$result) {
+            $result[] = $value;
+        });
+
+        return $result;
+    }
 	
-	/**
-	 * Fetch a flattened array of a nested array element.
-	 * 
-	 * @param  array  $array
-	 * @param  string  $key
-	 * 
-	 * @return array
-	 */
-	public static function fetch($array, $key)
-	{
-		foreach (explode('.', $key) as $segment) {
-			$results = array();
+    /**
+     * Fetch a flattened array of a nested array element.
+     * 
+     * @param  array  $array
+     * @param  string  $key
+     * 
+     * @return array
+     */
+    public static function fetch($array, $key)
+    {
+        foreach (explode('.', $key) as $segment) {
+            $results = array();
 			
-			foreach ($array as $value) {
-				if (array_key_exists($segment, $value = (array) $value)) {
-					$results[] = $value[$segment];
-				}
-			}
+            foreach ($array as $value) {
+                if (array_key_exists($segment, $value = (array) $value)) {
+                    $results[] = $value[$segment];
+                }
+            }
 			
-			$array = array_values($results);
-		}
+            $array = array_values($results);
+        }
 		
-		return array_values($results);
-	}
-
-	/**
-	 * Return the first element in an array passing a given truth test.
-	 *
-	 * @param  array  $array 
-	 * @param  \Closure  $callback
-	 * @param  mixed  $default
-	 *
-	 * @return mixed
-	 */
-	public static function first($array, callable $callback, $default = null)
-	{
-		foreach ($array as $key => $value) { 
-			if (call_user_func($callback, $key, $value)) return $value;
-		}
-
-		return value($default);
-	}	
-
-	/**
-	 * Get an item from an array using "dot" notation.
-	 *
-	 * @param  \ArrayAccess|array  $array  The search array
-	 * @param  string  $key  The dot-notated key or array of keys
-	 * @param  mixed  $default  The default value
-	 *
-	 * @return mixed
-	 */
-	public static function get($array, $key, $default = null)
-	{
-		if ( ! static::access($array)) {
-			return value($default);
-		}
-
-		if (static::exists($array, $key)) {
-			return $array[$key];
-		}
-
-		foreach (explode('.', $key) as $segm) {
-			if (static::access($array) && static::exists($array, $segm)) {
-				$array = $array[$segm];
-			} else {
-				return value($default);
-			}
-		}
-
-		return $array;		
-	}
-
-	/**
-	 * Return the last element in an array passing a given truth test.
-	 *
-	 * @param  array  $array 
-	 * @param  \Closure  $callback
-	 * @param  mixed  $default 
-	 *
-	 * @return mixed
-	 *
-	 * @uses   \Syscodes\Support\Arr::first
-	 */
-	public static function last($array, $callback, $default = null)
-	{
-		return static::first(array_reverse($array), $callback, $default);
-	}
-
-	/**
-	 * Check if an item exists in an array using "dot" notation.
-	 * 
-	 * @param  array  $array
-	 * @param  string  $key
-	 * 
-	 * @return bool
-	 */
-	public static function has($array, $key)
-	{
-		if (empty($array) || is_null($key)) return false;
+        return array_values($results);
+    }
+
+    /**
+     * Return the first element in an array passing a given truth test.
+     *
+     * @param  array  $array 
+     * @param  \Closure  $callback
+     * @param  mixed  $default
+     *
+     * @return mixed
+     */
+    public static function first($array, callable $callback, $default = null)
+    {
+        foreach ($array as $key => $value) { 
+            if (call_user_func($callback, $key, $value)) return $value;
+        }
+
+        return value($default);
+    }	
+
+    /**
+     * Get an item from an array using "dot" notation.
+     *
+     * @param  \ArrayAccess|array  $array  The search array
+     * @param  string  $key  The dot-notated key or array of keys
+     * @param  mixed  $default  The default value
+     *
+     * @return mixed
+     */
+    public static function get($array, $key, $default = null)
+    {
+        if ( ! static::access($array)) {
+            return value($default);
+        }
+
+        if (static::exists($array, $key)) {
+            return $array[$key];
+        }
+
+        foreach (explode('.', $key) as $segm) {
+            if (static::access($array) && static::exists($array, $segm)) {
+                $array = $array[$segm];
+            } else {
+                return value($default);
+            }
+        }
+
+        return $array;		
+    }
+
+    /**
+     * Return the last element in an array passing a given truth test.
+     *
+     * @param  array  $array 
+     * @param  \Closure  $callback
+     * @param  mixed  $default 
+     *
+     * @return mixed
+     *
+     * @uses   \Syscodes\Support\Arr::first
+     */
+    public static function last($array, $callback, $default = null)
+    {
+        return static::first(array_reverse($array), $callback, $default);
+    }
+
+    /**
+     * Check if an item exists in an array using "dot" notation.
+     * 
+     * @param  array  $array
+     * @param  string  $key
+     * 
+     * @return bool
+     */
+    public static function has($array, $key)
+    {
+        if (empty($array) || is_null($key)) return false;
 		
-		if (array_key_exists($key, $array)) return true;
+        if (array_key_exists($key, $array)) return true;
 		
-		foreach (explode('.', $key) as $segment) {
-			if ( ! is_array($array) || ! static::exists($array, $segment)) {
-				return false;
-			}
+        foreach (explode('.', $key) as $segment) {
+            if ( ! is_array($array) || ! static::exists($array, $segment)) {
+                return false;
+            }
 			
-			$array = $array[$segment];
-		}
+            $array = $array[$segment];
+        }
 		
-		return true;
-	}
-
-	/**
-	 * Get a subset of the items from the given array.
-	 * 
-	 * @param  array  $array
-	 * @param  array|string  $keys
-	 * 
-	 * @return array
-	 */
-	public static function only($array, $keys)
-	{
-		return array_intersect_key($array, array_flip($array), $keys);
-	}
-
-	/**
-	 * Sets a value in an array using "dot" notation.
-	 *
-	 * @param  array  $array  The search array
-	 * @param  string  $key  The dot-notated key or array of keys
-	 * @param  mixed  $value  The default value
-	 *
-	 * @return mixed
-	 */
-	public static function set(& $array, $key, $value = null)
-	{
-		$keys = explode('.', $key);
-
-		while (count($keys) > 1) {
-			$key = array_shift($keys);
-
-			if ( ! static::exists($array, $key)) {
-				$array[$key] = [];
-			}
-
-			$array =& $array[$key];
-		}
-
-		$array[array_shift($keys)] = $value;
-
-		return $array;
-	}
-
-	/**
-	 * Push an item onto the beginning of an array.
-	 * 
-	 * @param  mixed  $array
-	 * @param  mixed  $value
-	 * @param  mixed  key
-	 * 
-	 * @return array
-	 */
-	public static function prepend($array, $value, $key = null)
-	{
-		if (func_num_args() == 2) {
-			array_unshift($array, $value);
-		} else {
-			$array = [$key => $value] + $array;
-		}
-
-		return $array;
-	}
-
-	/**
-	 * Get a value from the array, and remove it.
-	 * 
-	 * @param  array  $array
-	 * @param  string  $key
-	 * @param  mixed  $default
-	 * 
-	 * @return mixed
-	 */
-	public static function pull(&$array, $key, $default = null)
-	{
-		$value = static::get($array, $key, $default);
-
-		static::erase($array, $key);
-
-		return $value;
-	}
-
-	/**
-	 * Convert the array into a query string.
-	 * 
-	 * @param  array  $array
-	 * 
-	 * @return array
-	 */
-	public static function query($array)
-	{
-		return http_build_query($array, null, '&', PHP_QUERY_RFC3986);
-	}
-
-	/**
-	 * Filter the array using the given callback.
-	 * 
-	 * @param  array  $array
-	 * @param  \Callable  $callback
-	 * 
-	 * @return array
-	 */
-	public static function where($array, Callable $callback)
-	{
-		return array_filter($array, $callback, ARRAY_FILTER_USE_BOTH);
-	}
-
-	/**
-	 * If the given value is not an array and not null, wrap it in one.
-	 * 
-	 * @param  mixed  $value
-	 * 
-	 * @return array
-	 */
-	public static function wrap($value)
-	{
-		if (is_null($value)) {
-			return [];
-		}
-
-		return is_array($value) ? $value : [$value];
-	}
+        return true;
+    }
+
+    /**
+     * Get a subset of the items from the given array.
+     * 
+     * @param  array  $array
+     * @param  array|string  $keys
+     * 
+     * @return array
+     */
+    public static function only($array, $keys)
+    {
+        return array_intersect_key($array, array_flip($array), $keys);
+    }
+
+    /**
+     * Sets a value in an array using "dot" notation.
+     *
+     * @param  array  $array  The search array
+     * @param  string  $key  The dot-notated key or array of keys
+     * @param  mixed  $value  The default value
+     *
+     * @return mixed
+     */
+    public static function set(& $array, $key, $value = null)
+    {
+        $keys = explode('.', $key);
+
+        while (count($keys) > 1) {
+            $key = array_shift($keys);
+
+            if ( ! static::exists($array, $key)) {
+                $array[$key] = [];
+            }
+
+            $array =& $array[$key];
+        }
+
+        $array[array_shift($keys)] = $value;
+
+        return $array;
+    }
+
+    /**
+     * Push an item onto the beginning of an array.
+     * 
+     * @param  mixed  $array
+     * @param  mixed  $value
+     * @param  mixed  key
+     * 
+     * @return array
+     */
+    public static function prepend($array, $value, $key = null)
+    {
+        if (func_num_args() == 2) {
+            array_unshift($array, $value);
+        } else {
+            $array = [$key => $value] + $array;
+        }
+
+        return $array;
+    }
+
+    /**
+     * Get a value from the array, and remove it.
+     * 
+     * @param  array  $array
+     * @param  string  $key
+     * @param  mixed  $default
+     * 
+     * @return mixed
+     */
+    public static function pull(&$array, $key, $default = null)
+    {
+        $value = static::get($array, $key, $default);
+
+        static::erase($array, $key);
+
+        return $value;
+    }
+
+    /**
+     * Convert the array into a query string.
+     * 
+     * @param  array  $array
+     * 
+     * @return array
+     */
+    public static function query($array)
+    {
+        return http_build_query($array, null, '&', PHP_QUERY_RFC3986);
+    }
+
+    /**
+     * Filter the array using the given callback.
+     * 
+     * @param  array  $array
+     * @param  \Callable  $callback
+     * 
+     * @return array
+     */
+    public static function where($array, Callable $callback)
+    {
+        return array_filter($array, $callback, ARRAY_FILTER_USE_BOTH);
+    }
+
+    /**
+     * If the given value is not an array and not null, wrap it in one.
+     * 
+     * @param  mixed  $value
+     * 
+     * @return array
+     */
+    public static function wrap($value)
+    {
+        if (is_null($value)) {
+            return [];
+        }
+
+        return is_array($value) ? $value : [$value];
+    }
 }
\ No newline at end of file

src/components/Console/Cli.php

Indentation +693 added lines, -693 removed lines

@@ -34,708 +34,708 @@
  */
 class Cli
 {
-	/**
- 	 * Background color identifier.
- 	 *
- 	 * @var array $backgroundColors
- 	 */
- 	protected static $backgroundColors = [
- 		'black'      => '40',
- 		'red'        => '41',
- 		'green'      => '42',
- 		'yellow'     => '43',
- 		'blue'       => '44',
- 		'magenta'    => '45',
- 		'cyan'       => '46',
- 		'light_gray' => '47'
- 	];
-
-	/**
-	 * Foreground color identifier.
- 	 *
- 	 * @var array $foregroundColors
-	 */
-	protected static $foregroundColors = [
-		'black'         => '0;30',
-		'dark_gray'     => '1;30',
-		'blue'          => '0;34',
-		'dark_blue'     => '1;34',
-		'light_blue'    => '1;34',
-		'green'         => '0;32',
-		'light_green'   => '1;32',
-		'cyan'          => '0;36', 
-		'light_cyan'    => '1;36',
-		'red'           => '0;31',
-		'light_red'     => '1;31',
-		'purple'        => '0;35',
-		'light_purple'  => '1;35',
-		'light_yellow'  => '0;33',
-		'yellow'        => '1;33',
-		'light_gray'    => '0;37',
-		'white'         => '1;37'
- 	];
-
-	/**
-	 * Indicates that you do not use any color for foreground or background.
-	 *
-	 * @var bool $noColor
-	 */
-	public static $noColor = false;
-
-	/**
-	 * String of arguments to be used in console.
-	 *
-	 * @var array $options
-	 */
-	protected static $options = [];
-
-	/**
-	 * Readline Support for command line.
-	 *
-	 * @var bool $readlineSupport
-	 */
-	public static $readlineSupport = false;
-
-	/**
-	 * List of array segments.
-	 *
-	 * @var array $segments
-	 */
-	protected static $segments = [];
-
- 	/**
- 	 * The standar STDERR is where the application writes its error messages.
- 	 *
- 	 * @var string $stderr 
- 	 */
- 	protected static $stderr;
-
- 	/**
- 	 * The estandar STDOUT is where the application records its output messages.
- 	 *
- 	 * @var string $stdout
- 	 */
- 	protected static $stdout;
-
- 	/**
-	 * Message that tells the user that he is waiting to receive an order.
-	 *
-	 * @var string $waitMsg
-	 */
-	public static $waitMsg = 'Press any key to continue...';
-
-	/**
-	 * Static constructor. Parses all the CLI params.
-	 * 
-	 * @return \Syscodes\Contracts\Core\Lenevor  $core
-	 * 
-	 * @throws \Exception
-	 */
- 	public static function initialize(Lenevor $core)
- 	{
- 		if ( ! $core->initCli()) {
-			throw new Exception('Cli class cannot be used outside of the command line');
- 		}
-
- 		// Readline is an extension for PHP that makes interactive the command console
- 		static::$readlineSupport = extension_loaded('readline');
-
- 		// clear segments & options to keep testing clean
- 		static::$options  = [];
- 		static::$segments = [];
-
- 		static::parseCommandLine();
-
- 		// Writes its error messages
- 		static::$stderr = STDERR;
-
- 		// Records its output messages
- 		static::$stdout = STDOUT;
- 	}
-
- 	/**
- 	 * Beeps a certain number of times.
-	 *
-	 * @param  int  $num  The number of times to beep
-	 *
- 	 * @return int
- 	 */
- 	public static function bell(int $num = 1)
- 	{
- 		echo str_repeat("\x07", $num);
- 	}
-
- 	/**
- 	 * Clears the screen of output.
- 	 *
- 	 * @return void
- 	 */
- 	public static function clearScreen()
- 	{
- 		static::isWindows() 
-
- 			// Windows doesn't work for this, but their terminal is tiny so shove this in
- 			? static::newLine(40)
-
- 			// Anything with a flair of Unix will handle these magic characters
- 			: fwrite(static::$stdout, chr(27)."[H".chr(27)."[2J");
- 	}
-
- 	/**
- 	 * Returns the given text with the correct color codes for a foreground and
-	 * optionally a background color.
- 	 *
- 	 * @param  string  $text  The text to color
- 	 * @param  string  $foreground  The foreground color
- 	 * @param  string  $background  The background color
- 	 * @param  string  $format  Other formatting to apply. Currently only 'underline' is understood
- 	 *
- 	 * @return string  The color coded string
- 	 *
- 	 * @throws \Syscodes\Core\Exceptions\LenevorException
- 	 */
- 	public static function color(string $text, string $foreground, string $background = null, string $format = null)
- 	{
- 		if (static::$noColor)
- 		{
- 			return $text;
- 		}
-
- 		if ( ! Arr::exists(static::$foregroundColors, $foreground)) {
- 			throw new LenevorException(static::error("Invalid CLI foreground color: {$foreground}."));
- 		}
-
- 		if ( $background !== null && ! Arr::exists(static::$backgroundColors, $background)) {
- 			throw new LenevorException(static::error("Invalid CLI background color: {$background}."));
- 		}
-
- 		$string = "\033[".static::$foregroundColors[$foreground]."m";
-
- 		if ($background !== null) {
- 			$string .= "\033[".static::$backgroundColors[$background]."m";
- 		}
-
- 		if ($format === 'underline') {
- 			$string .= "\033[4m";
- 		}
-
- 		$string .= $text."\033[0m";
-
- 		return $string;
- 	}
-
- 	/**
- 	 * Get the number of characters in a string.
- 	 *
- 	 * @param  string  $string
- 	 *
- 	 * @return int
- 	 */
- 	public static function strlen(?string $string)
- 	{
- 		if (is_null($string)) {
- 			return 0;
- 		}
-
- 		foreach (static::$foregroundColors as $color) {
- 			$string = strtr($string, ["\033[".$color.'m' => '']);
- 		}
-
- 		foreach (static::$backgroundColors as $color) {
- 			$string = strtr($string, ["\033[".$color.'m' => '']);
- 		}
-
- 		$string = strtr($string, ["\033[4m" => '', "\033[0m" => '']);
-
- 		return mb_strlen($string);
- 	}
-
- 	/**
- 	 * Outputs an error to the CLI using STDERR instead of STDOUT.
- 	 *
- 	 * @param  string|array  $text  The text to output, or array of errors
- 	 * @param  string  $foreground  The foreground color
- 	 * @param  string|null  $background  the background color
- 	 *
- 	 * @return string
- 	 */
- 	public static function error(string $text = '', string $foreground = 'light_red', string $background = null)
- 	{
-		if (is_array($text)) {
-			$text = implode(PHP_EOL, $text);
-		}
+    /**
+     * Background color identifier.
+     *
+     * @var array $backgroundColors
+     */
+        protected static $backgroundColors = [
+            'black'      => '40',
+            'red'        => '41',
+            'green'      => '42',
+            'yellow'     => '43',
+            'blue'       => '44',
+            'magenta'    => '45',
+            'cyan'       => '46',
+            'light_gray' => '47'
+        ];
+
+    /**
+     * Foreground color identifier.
+     *
+     * @var array $foregroundColors
+     */
+    protected static $foregroundColors = [
+        'black'         => '0;30',
+        'dark_gray'     => '1;30',
+        'blue'          => '0;34',
+        'dark_blue'     => '1;34',
+        'light_blue'    => '1;34',
+        'green'         => '0;32',
+        'light_green'   => '1;32',
+        'cyan'          => '0;36', 
+        'light_cyan'    => '1;36',
+        'red'           => '0;31',
+        'light_red'     => '1;31',
+        'purple'        => '0;35',
+        'light_purple'  => '1;35',
+        'light_yellow'  => '0;33',
+        'yellow'        => '1;33',
+        'light_gray'    => '0;37',
+        'white'         => '1;37'
+        ];
+
+    /**
+     * Indicates that you do not use any color for foreground or background.
+     *
+     * @var bool $noColor
+     */
+    public static $noColor = false;
+
+    /**
+     * String of arguments to be used in console.
+     *
+     * @var array $options
+     */
+    protected static $options = [];
+
+    /**
+     * Readline Support for command line.
+     *
+     * @var bool $readlineSupport
+     */
+    public static $readlineSupport = false;
+
+    /**
+     * List of array segments.
+     *
+     * @var array $segments
+     */
+    protected static $segments = [];
+
+        /**
+         * The standar STDERR is where the application writes its error messages.
+         *
+         * @var string $stderr 
+         */
+        protected static $stderr;
+
+        /**
+         * The estandar STDOUT is where the application records its output messages.
+         *
+         * @var string $stdout
+         */
+        protected static $stdout;
+
+        /**
+         * Message that tells the user that he is waiting to receive an order.
+         *
+         * @var string $waitMsg
+         */
+    public static $waitMsg = 'Press any key to continue...';
+
+    /**
+     * Static constructor. Parses all the CLI params.
+     * 
+     * @return \Syscodes\Contracts\Core\Lenevor  $core
+     * 
+     * @throws \Exception
+     */
+        public static function initialize(Lenevor $core)
+        {
+            if ( ! $core->initCli()) {
+            throw new Exception('Cli class cannot be used outside of the command line');
+            }
+
+            // Readline is an extension for PHP that makes interactive the command console
+            static::$readlineSupport = extension_loaded('readline');
+
+            // clear segments & options to keep testing clean
+            static::$options  = [];
+            static::$segments = [];
+
+            static::parseCommandLine();
+
+            // Writes its error messages
+            static::$stderr = STDERR;
+
+            // Records its output messages
+            static::$stdout = STDOUT;
+        }
+
+        /**
+         * Beeps a certain number of times.
+         *
+         * @param  int  $num  The number of times to beep
+         *
+         * @return int
+         */
+        public static function bell(int $num = 1)
+        {
+            echo str_repeat("\x07", $num);
+        }
+
+        /**
+         * Clears the screen of output.
+         *
+         * @return void
+         */
+        public static function clearScreen()
+        {
+            static::isWindows() 
+
+                // Windows doesn't work for this, but their terminal is tiny so shove this in
+             ? static::newLine(40)
+
+                // Anything with a flair of Unix will handle these magic characters
+             : fwrite(static::$stdout, chr(27)."[H".chr(27)."[2J");
+        }
+
+        /**
+         * Returns the given text with the correct color codes for a foreground and
+         * optionally a background color.
+         *
+         * @param  string  $text  The text to color
+         * @param  string  $foreground  The foreground color
+         * @param  string  $background  The background color
+         * @param  string  $format  Other formatting to apply. Currently only 'underline' is understood
+         *
+         * @return string  The color coded string
+         *
+         * @throws \Syscodes\Core\Exceptions\LenevorException
+         */
+        public static function color(string $text, string $foreground, string $background = null, string $format = null)
+        {
+            if (static::$noColor)
+            {
+                return $text;
+            }
+
+            if ( ! Arr::exists(static::$foregroundColors, $foreground)) {
+                throw new LenevorException(static::error("Invalid CLI foreground color: {$foreground}."));
+            }
+
+            if ( $background !== null && ! Arr::exists(static::$backgroundColors, $background)) {
+                throw new LenevorException(static::error("Invalid CLI background color: {$background}."));
+            }
+
+            $string = "\033[".static::$foregroundColors[$foreground]."m";
+
+            if ($background !== null) {
+                $string .= "\033[".static::$backgroundColors[$background]."m";
+            }
+
+            if ($format === 'underline') {
+                $string .= "\033[4m";
+            }
+
+            $string .= $text."\033[0m";
+
+            return $string;
+        }
+
+        /**
+         * Get the number of characters in a string.
+         *
+         * @param  string  $string
+         *
+         * @return int
+         */
+        public static function strlen(?string $string)
+        {
+            if (is_null($string)) {
+                return 0;
+            }
+
+            foreach (static::$foregroundColors as $color) {
+                $string = strtr($string, ["\033[".$color.'m' => '']);
+            }
+
+            foreach (static::$backgroundColors as $color) {
+                $string = strtr($string, ["\033[".$color.'m' => '']);
+            }
+
+            $string = strtr($string, ["\033[4m" => '', "\033[0m" => '']);
+
+            return mb_strlen($string);
+        }
+
+        /**
+         * Outputs an error to the CLI using STDERR instead of STDOUT.
+         *
+         * @param  string|array  $text  The text to output, or array of errors
+         * @param  string  $foreground  The foreground color
+         * @param  string|null  $background  the background color
+         *
+         * @return string
+         */
+        public static function error(string $text = '', string $foreground = 'light_red', string $background = null)
+        {
+        if (is_array($text)) {
+            $text = implode(PHP_EOL, $text);
+        }
 		
-		if ($foreground || $background) {
-			$text = static::color($text, $foreground, $background);
-		}
+        if ($foreground || $background) {
+            $text = static::color($text, $foreground, $background);
+        }
 		
-		fwrite(static::$stderr, $text.PHP_EOL);
-	}
-
-	/**
-	 * Attempts to determine the width of the viewable CLI window.
-	 *
-	 * @param  int  $default
-	 *
-	 * @return int
-	 */
-	public static function getWidth(int $default = 80)
-	{
-		if (static::isWindows() || (int) shell_exec('tput cols') === 0) {
-			return $default;
-		}
-
-		return (int) shell_exec('tput cols');
-	}
-
-	/**
-	 * Attempts to determine the height of the viewable CLI window.
-	 *
-	 * @param  int  $default
-	 *
-	 * @return int
-	 */
-	public static function getHeight(int $default = 32)
-	{
-		if (static::isWindows()) {
-			return $default;
-		}
-
-		return (int) shell_exec('tput lines');
-	}
-
-	/**
-	 * Takes a string and writes it to the command line, wrapping to a maximum width. 
-	 * If no maximum width is specified, will wrap to the window's max.
-	 *
-	 * @param  string  $string
-	 * @param  int  $max
-	 * @param  int $padLeft
-	 *
-	 * @return string
-	 */
-	public static function wrap(string $string = null, int $max = 0, int $padLeft = 0)
-	{
-		if (empty($string)) {
-			return '';
-		}
-
-		if ($max === 0) {
-			$max = static::getWidth();
-		}
-
-		if (static::getWidth() < $max) {
-			$max = static::getWidth();
-		}
-
-		$max = $max - $padLeft;
-
-		$lines = wordwrap($string, $max);
-
-		if ($pad_left > 0) {
-			$lines = explode(PHP_EOL, $lines);
-
-			$first = true;
-
-			array_walk ($lines, function (&$line, $index) use ($pad_left, &$first) {
-
-				if ( ! $first) {
-					$line = str_repeat(' ', $pad_left) . $line;
-				} else {
-					$first = false;
-				}
-
-			});
-
-			$lines = implode(PHP_EOL, $lines);
-		}
-
-		return $lines;
-	}
-
- 	/**
- 	 * Get input from the shell, using readline or the standard STDIN.
- 	 *
- 	 * @param  string|int  $prefix  The name of the option (int if unnamed)
- 	 *
- 	 * @return string
- 	 */
- 	public static function input($prefix = '')
- 	{
- 		if (static::$readlineSupport) {
- 			return readline($prefix);
- 		}
-
- 		echo $prefix;
-
- 		return fgets(STDIN);
- 	}
-
- 	/**
- 	 * If operating system === windows.
- 	 * 
- 	 * @return string
- 	 */
- 	public static function isWindows()
- 	{
- 		return 'win' === strtolower(substr(php_uname("s"), 0, 3));
- 	}
-
- 	/**
- 	 * Enter a number of empty lines.
- 	 * 
- 	 * @param  int  $num  Number of lines to output
- 	 *
- 	 * @return void
- 	 */
- 	public static function newLine(int $num = 1)
- 	{
- 		for ($i = 0; $i < $num; $i++) {			
- 			static::write();
- 		}
- 	}
-
- 	/**
-	 * Returns the option with the given name. You can also give the option number.
-	 *
-	 * @param  string|int  $name  The name of the option (int if unnamed)
-	 * @param  mixed  $default  The value to return if the option is not defined
-	 *
-	 * @return mixed
-	 * 
-	 * @uses   \Syscodes\Contract\Core\Lenevor
-	 */
- 	public static function option($name, $default = null)
- 	{
- 		if ( ! isset(static::$options[$name])) {
- 			return Lenevor::value($default);
- 		}
-
- 		return static::$options[$name];
-	}
-
-	/**
-	 * Parses the command line it was called from and collects all
-	 * options and valid segments.
-	 * 
-	 * @return bool
-	 */
-	protected static function parseCommandLine()
-	{
-		$options = false;
-
-		for ($i = 1; $i < $_SERVER['argc']; $i++) {
-			if ( ! $options && mb_strpos($_SERVER['argv'][$i], '-') === false) {
-				static::$segments[] = $_SERVER['argv'][$i];
-
-				continue;
-			}
-
-			$options = true;
-
-			$args  = str_replace('-', '', $_SERVER['argv'][$i]);
-			$value = null;
-
-			if (isset($_SERVER['argv'][$i + 1]) && mb_strpos($_SERVER['argv'][$i + 1], '-') !== 0) {
-				$value = $_SERVER['argv'][$i + 1];
-				$i++;
-			}
-
-			static::$options[$args] = $value;
-
-			$options = false;
-		}
-	}
-
-	/**
-	 * Returns the command line string portions of the arguments, minus
-	 * any options, as a string.
-	 *
-	 * @return string
-	 */
-	public static function getURI()
-	{
-		return implode('/', static::$segments);
-	}
-
-	/**
-	 * Returns an individual segment.
-	 *
-	 * @param  int  $index
-	 * 
-	 * @return mixed|null
-	 */
-	public static function getSegment(int $index)
-	{
-		if ( ! isset(static::$segments[$index - 1])) {
-			return null;
-		}
-
-		return static::$segments[$index - 1];
-	}
-
-	/**
-	 * Returns the raw array of segments found.
-	 *
-	 * @return array
-	 */
-	public static function getSegments()
-	{
-		return static::$segments;
-	}
-
- 	/**
- 	 * Asks the user for input.  This can have either 1 or 2 arguments.
-	 *
-	 * Usage:
-	 *
-	 * // Waits for any key press
-	 * Cli::prompt();
-	 *
-	 * // Takes any input
-	 * $color = Cli::prompt('What is your favorite color?');
-	 *
-	 * // Takes any input, but offers default
-	 * $color = Cli::prompt('What is your favourite color?', 'white');
-	 *
-	 * // Will only accept the options in the array
-	 * $ready = Cli::prompt('Are you ready?', array('y','n'));
-	 *
-	 * @return string The user input
-	 */
- 	public static function prompt()
- 	{
- 		$args = func_get_args();
-
-		$options = [];
-		$output  = '';
-		$default = null;
-
-		// How many we got
-		$arg_count = count($args);
-
-		// Is the last argument a boolean? True means required
-		$required = end($args) === true;
-
-		// Reduce the argument count if required was passed, we don't care about that anymore
-		$required === true and --$arg_count;
-
-		// This method can take a few crazy combinations of arguments, so lets work it out
-		switch ($arg_count) {
-			case 2:
-
-				// E.g: $ready = Cli::prompt('Are you ready?', ['y','n']);
-				if (is_array($args[1])) {
-					list($output, $options) = $args;
-				}
-				// E.g: $color = Cli::prompt('What is your favourite color?', 'white');
-				elseif (is_string($args[1])) {
-					list($output, $default) = $args;
-				}
-
-			break;
-
-			case 1:
-
-				// No question (probably been asked already) so just show options
-				// E.g: $ready = Cli::prompt(array('y','n'));
-				if (is_array($args[0])) {
-					$options = $args[0];
-				}
-				// Question without options
-				// E.g: $ready = Cli::prompt('What did you do today?');
-				elseif (is_string($args[0])) {
-					$output = $args[0];
-				}
-
-			break;
-		}
-
-		// If a question has been asked with the read
-		if ($output !== '') {
-			$extra_output = '';
-
-			if ($default !== null) {
-				$extra_output = ' [ Default: "'.$default.'" ]';
-			} elseif ($options !== []) {
-				$extra_output = ' [ '.implode(' | ', $options).' ]';
-			}
-
-			fwrite(static::$stdout, $output.$extra_output.': ');
-		}
-
-		// Read the input from keyboard.
-		$input = trim(static::input()) ?: $default;
-
-		// No input provided and we require one (default will stop this being called)
-		if (empty($input) and $required === true) {
-			static::write('This is required.');
-			static::newLine();
-
-			$input = forward_static_call_array([__CLASS__, 'prompt'], $args);
-		}
-
-		// If options are provided and the choice is not in the array, tell them to try again
-		if ( ! empty($options) and ! in_array($input, $options)) {
-			static::write('This is not a valid option. Please try again.');
-			static::newLine();
-
-			$input = forward_static_call_array([__CLASS__, 'prompt'], $args);
-		}
-
-		return $input;
- 	}
-
- 	/**
- 	 * Allows you to set a commandline option from code.
- 	 *
- 	 * @param  string|int  $name  The name of the option (int if unnamed)
-	 * @param  mixed|null  $value  The value to set, or null to delete the option
-	 *
-	 * @return mixed
-	 */
- 	public static function setOption($name, $value = null)
- 	{
- 		if ($value == null) {
- 			if (isset(static::$options[$name])) {
- 				unset(static::$options[$name]);
- 			}
- 		} else {
- 			static::$options[$name] = $value;
- 		}
- 	}
-
- 	/**
- 	 * Waits a certain number of seconds, optionally showing a wait message and
-	 * waiting for a key press.
- 	 *
- 	 * @param  int  $seconds  Number of seconds
- 	 * @param  bool  $countdown  Show a countdown or not
- 	 *
- 	 * @return string
- 	 */
- 	public static function wait(int $seconds = 0, bool $countdown = false)
- 	{
- 		if ($countdown === true) {
-			$time = $seconds;
-
- 			while ($time > 0) {
- 				fwrite(static::$stdout, $time.'... ');
- 				sleep(1);
- 				$time--;
- 			}
-
- 			static::write();
- 		} else {
- 			if ($seconds = 0) {
- 				sleep($seconds);
- 			} else {
- 				static::write(static::$waitMsg);
- 				static::input();
- 			}
- 		}
- 	}
-
- 	/**
- 	 * Outputs a string to the cli.	If you send an array it will implode them 
- 	 * with a line break.
- 	 * 
- 	 * @param  string|array  $text  The text to output, or array of lines
- 	 * @param  string|null  $foreground  The foreground color
- 	 * @param  string|null  $background  The background color
- 	 *
- 	 * @return string
- 	 */
- 	public static function write(string $text = '', string $foreground = null, string $background = null)
- 	{
- 		if (is_array($text)) {
- 			$text = implode(PHP_EOL, $text);
- 		}
-
- 		if ($foreground OR $background) {
- 			$text = static::color($text, $foreground, $background);
- 		}
-
- 		fwrite(static::$stdout, $text.PHP_EOL);
- 	}
-
- 	/**
- 	 * Returns a well formatted table.
- 	 *
- 	 * @param  array  $tbody  List of rows
- 	 * @param  array  $thead  List of columns
- 	 *
- 	 * @return void
- 	 */
- 	public static function table(array $tbody, array $thead = [])
- 	{
- 		$rows = [];
-
- 		if ( ! empty($thead)) {
- 			$rows[] = array_values($thead);
- 		}
-
- 		foreach ($tbody as $tr) {
- 			$rows[] = count($rows);
- 		}
-
- 		$totalRows = count($rows);
-
- 		// Store all columns lengths
- 		$allColsLengths = [];
-
- 		// Store maximum lengths by column
- 		$maxColsLengths = [];
-
- 		for ($row = 0; $row < $totalRows; $row++) {
- 			$column = 0;
-
- 			foreach ($rows[$row] as $col) {
- 				$allColsLengths[$row][$column] = static::strlen($col);
-
- 				if ( ! isset($maxColsLengths[$column]) || $allColsLengths[$row][$column] > $maxColsLengths[$column]) {
- 					$maxColsLengths[$column] = $allColsLengths[$row][$column];
- 				}
-
- 				$column++;
- 			}
- 		}
-
- 		for ($row = 0; $row < $totalRows; $row++) {
- 			$column = 0;
-
- 			foreach ($rows[$row] as $col)
- 			{
- 				$diverse = $maxColsLengths[$column] - static::strlen($col);
+        fwrite(static::$stderr, $text.PHP_EOL);
+    }
+
+    /**
+     * Attempts to determine the width of the viewable CLI window.
+     *
+     * @param  int  $default
+     *
+     * @return int
+     */
+    public static function getWidth(int $default = 80)
+    {
+        if (static::isWindows() || (int) shell_exec('tput cols') === 0) {
+            return $default;
+        }
+
+        return (int) shell_exec('tput cols');
+    }
+
+    /**
+     * Attempts to determine the height of the viewable CLI window.
+     *
+     * @param  int  $default
+     *
+     * @return int
+     */
+    public static function getHeight(int $default = 32)
+    {
+        if (static::isWindows()) {
+            return $default;
+        }
+
+        return (int) shell_exec('tput lines');
+    }
+
+    /**
+     * Takes a string and writes it to the command line, wrapping to a maximum width. 
+     * If no maximum width is specified, will wrap to the window's max.
+     *
+     * @param  string  $string
+     * @param  int  $max
+     * @param  int $padLeft
+     *
+     * @return string
+     */
+    public static function wrap(string $string = null, int $max = 0, int $padLeft = 0)
+    {
+        if (empty($string)) {
+            return '';
+        }
+
+        if ($max === 0) {
+            $max = static::getWidth();
+        }
+
+        if (static::getWidth() < $max) {
+            $max = static::getWidth();
+        }
+
+        $max = $max - $padLeft;
+
+        $lines = wordwrap($string, $max);
+
+        if ($pad_left > 0) {
+            $lines = explode(PHP_EOL, $lines);
+
+            $first = true;
+
+            array_walk ($lines, function (&$line, $index) use ($pad_left, &$first) {
+
+                if ( ! $first) {
+                    $line = str_repeat(' ', $pad_left) . $line;
+                } else {
+                    $first = false;
+                }
+
+            });
+
+            $lines = implode(PHP_EOL, $lines);
+        }
+
+        return $lines;
+    }
+
+        /**
+         * Get input from the shell, using readline or the standard STDIN.
+         *
+         * @param  string|int  $prefix  The name of the option (int if unnamed)
+         *
+         * @return string
+         */
+        public static function input($prefix = '')
+        {
+            if (static::$readlineSupport) {
+                return readline($prefix);
+            }
+
+            echo $prefix;
+
+            return fgets(STDIN);
+        }
+
+        /**
+         * If operating system === windows.
+         * 
+         * @return string
+         */
+        public static function isWindows()
+        {
+            return 'win' === strtolower(substr(php_uname("s"), 0, 3));
+        }
+
+        /**
+         * Enter a number of empty lines.
+         * 
+         * @param  int  $num  Number of lines to output
+         *
+         * @return void
+         */
+        public static function newLine(int $num = 1)
+        {
+            for ($i = 0; $i < $num; $i++) {			
+                static::write();
+            }
+        }
+
+        /**
+         * Returns the option with the given name. You can also give the option number.
+         *
+         * @param  string|int  $name  The name of the option (int if unnamed)
+         * @param  mixed  $default  The value to return if the option is not defined
+         *
+         * @return mixed
+         * 
+         * @uses   \Syscodes\Contract\Core\Lenevor
+         */
+        public static function option($name, $default = null)
+        {
+            if ( ! isset(static::$options[$name])) {
+                return Lenevor::value($default);
+            }
+
+            return static::$options[$name];
+    }
+
+    /**
+     * Parses the command line it was called from and collects all
+     * options and valid segments.
+     * 
+     * @return bool
+     */
+    protected static function parseCommandLine()
+    {
+        $options = false;
+
+        for ($i = 1; $i < $_SERVER['argc']; $i++) {
+            if ( ! $options && mb_strpos($_SERVER['argv'][$i], '-') === false) {
+                static::$segments[] = $_SERVER['argv'][$i];
+
+                continue;
+            }
+
+            $options = true;
+
+            $args  = str_replace('-', '', $_SERVER['argv'][$i]);
+            $value = null;
+
+            if (isset($_SERVER['argv'][$i + 1]) && mb_strpos($_SERVER['argv'][$i + 1], '-') !== 0) {
+                $value = $_SERVER['argv'][$i + 1];
+                $i++;
+            }
+
+            static::$options[$args] = $value;
+
+            $options = false;
+        }
+    }
+
+    /**
+     * Returns the command line string portions of the arguments, minus
+     * any options, as a string.
+     *
+     * @return string
+     */
+    public static function getURI()
+    {
+        return implode('/', static::$segments);
+    }
+
+    /**
+     * Returns an individual segment.
+     *
+     * @param  int  $index
+     * 
+     * @return mixed|null
+     */
+    public static function getSegment(int $index)
+    {
+        if ( ! isset(static::$segments[$index - 1])) {
+            return null;
+        }
+
+        return static::$segments[$index - 1];
+    }
+
+    /**
+     * Returns the raw array of segments found.
+     *
+     * @return array
+     */
+    public static function getSegments()
+    {
+        return static::$segments;
+    }
+
+        /**
+         * Asks the user for input.  This can have either 1 or 2 arguments.
+         *
+         * Usage:
+         *
+         * // Waits for any key press
+         * Cli::prompt();
+         *
+         * // Takes any input
+         * $color = Cli::prompt('What is your favorite color?');
+         *
+         * // Takes any input, but offers default
+         * $color = Cli::prompt('What is your favourite color?', 'white');
+         *
+         * // Will only accept the options in the array
+         * $ready = Cli::prompt('Are you ready?', array('y','n'));
+         *
+         * @return string The user input
+         */
+        public static function prompt()
+        {
+            $args = func_get_args();
+
+        $options = [];
+        $output  = '';
+        $default = null;
+
+        // How many we got
+        $arg_count = count($args);
+
+        // Is the last argument a boolean? True means required
+        $required = end($args) === true;
+
+        // Reduce the argument count if required was passed, we don't care about that anymore
+        $required === true and --$arg_count;
+
+        // This method can take a few crazy combinations of arguments, so lets work it out
+        switch ($arg_count) {
+            case 2:
+
+                // E.g: $ready = Cli::prompt('Are you ready?', ['y','n']);
+                if (is_array($args[1])) {
+                    list($output, $options) = $args;
+                }
+                // E.g: $color = Cli::prompt('What is your favourite color?', 'white');
+                elseif (is_string($args[1])) {
+                    list($output, $default) = $args;
+                }
+
+            break;
+
+            case 1:
+
+                // No question (probably been asked already) so just show options
+                // E.g: $ready = Cli::prompt(array('y','n'));
+                if (is_array($args[0])) {
+                    $options = $args[0];
+                }
+                // Question without options
+                // E.g: $ready = Cli::prompt('What did you do today?');
+                elseif (is_string($args[0])) {
+                    $output = $args[0];
+                }
+
+            break;
+        }
+
+        // If a question has been asked with the read
+        if ($output !== '') {
+            $extra_output = '';
+
+            if ($default !== null) {
+                $extra_output = ' [ Default: "'.$default.'" ]';
+            } elseif ($options !== []) {
+                $extra_output = ' [ '.implode(' | ', $options).' ]';
+            }
+
+            fwrite(static::$stdout, $output.$extra_output.': ');
+        }
+
+        // Read the input from keyboard.
+        $input = trim(static::input()) ?: $default;
+
+        // No input provided and we require one (default will stop this being called)
+        if (empty($input) and $required === true) {
+            static::write('This is required.');
+            static::newLine();
+
+            $input = forward_static_call_array([__CLASS__, 'prompt'], $args);
+        }
+
+        // If options are provided and the choice is not in the array, tell them to try again
+        if ( ! empty($options) and ! in_array($input, $options)) {
+            static::write('This is not a valid option. Please try again.');
+            static::newLine();
+
+            $input = forward_static_call_array([__CLASS__, 'prompt'], $args);
+        }
+
+        return $input;
+        }
+
+        /**
+         * Allows you to set a commandline option from code.
+         *
+         * @param  string|int  $name  The name of the option (int if unnamed)
+         * @param  mixed|null  $value  The value to set, or null to delete the option
+         *
+         * @return mixed
+         */
+        public static function setOption($name, $value = null)
+        {
+            if ($value == null) {
+                if (isset(static::$options[$name])) {
+                    unset(static::$options[$name]);
+                }
+            } else {
+                static::$options[$name] = $value;
+            }
+        }
+
+        /**
+         * Waits a certain number of seconds, optionally showing a wait message and
+         * waiting for a key press.
+         *
+         * @param  int  $seconds  Number of seconds
+         * @param  bool  $countdown  Show a countdown or not
+         *
+         * @return string
+         */
+        public static function wait(int $seconds = 0, bool $countdown = false)
+        {
+            if ($countdown === true) {
+            $time = $seconds;
+
+                while ($time > 0) {
+                    fwrite(static::$stdout, $time.'... ');
+                    sleep(1);
+                    $time--;
+                }
+
+                static::write();
+            } else {
+                if ($seconds = 0) {
+                    sleep($seconds);
+                } else {
+                    static::write(static::$waitMsg);
+                    static::input();
+                }
+            }
+        }
+
+        /**
+         * Outputs a string to the cli.	If you send an array it will implode them 
+         * with a line break.
+         * 
+         * @param  string|array  $text  The text to output, or array of lines
+         * @param  string|null  $foreground  The foreground color
+         * @param  string|null  $background  The background color
+         *
+         * @return string
+         */
+        public static function write(string $text = '', string $foreground = null, string $background = null)
+        {
+            if (is_array($text)) {
+                $text = implode(PHP_EOL, $text);
+            }
+
+            if ($foreground OR $background) {
+                $text = static::color($text, $foreground, $background);
+            }
+
+            fwrite(static::$stdout, $text.PHP_EOL);
+        }
+
+        /**
+         * Returns a well formatted table.
+         *
+         * @param  array  $tbody  List of rows
+         * @param  array  $thead  List of columns
+         *
+         * @return void
+         */
+        public static function table(array $tbody, array $thead = [])
+        {
+            $rows = [];
+
+            if ( ! empty($thead)) {
+                $rows[] = array_values($thead);
+            }
+
+            foreach ($tbody as $tr) {
+                $rows[] = count($rows);
+            }
+
+            $totalRows = count($rows);
+
+            // Store all columns lengths
+            $allColsLengths = [];
+
+            // Store maximum lengths by column
+            $maxColsLengths = [];
+
+            for ($row = 0; $row < $totalRows; $row++) {
+                $column = 0;
+
+                foreach ($rows[$row] as $col) {
+                    $allColsLengths[$row][$column] = static::strlen($col);
+
+                    if ( ! isset($maxColsLengths[$column]) || $allColsLengths[$row][$column] > $maxColsLengths[$column]) {
+                        $maxColsLengths[$column] = $allColsLengths[$row][$column];
+                    }
+
+                    $column++;
+                }
+            }
+
+            for ($row = 0; $row < $totalRows; $row++) {
+                $column = 0;
+
+                foreach ($rows[$row] as $col)
+                {
+                    $diverse = $maxColsLengths[$column] - static::strlen($col);
  				
- 				if ($diverse) {
- 					$rows[$row][$column] = $rows[$row][$column].str_repeat(' ', $diverse);
- 				}
+                    if ($diverse) {
+                        $rows[$row][$column] = $rows[$row][$column].str_repeat(' ', $diverse);
+                    }
 
- 				$column++;
- 			} 			
- 		}
+                    $column++;
+                } 			
+            }
 
- 		$table = '';
+            $table = '';
 
- 		for ($row = 0; $row < $rows; $row++) {
- 			if (0 === $row) {
- 				$cols = '+';
+            for ($row = 0; $row < $rows; $row++) {
+                if (0 === $row) {
+                    $cols = '+';
 
- 				foreach ($rows[$row] as $col) {
- 					$cols .= str_repeat('-', static::strlen($col) + 2).'+';
- 				}
+                    foreach ($rows[$row] as $col) {
+                        $cols .= str_repeat('-', static::strlen($col) + 2).'+';
+                    }
 
- 				$table .= $cols.PHP_EOL;
- 			}
+                    $table .= $cols.PHP_EOL;
+                }
 
- 			$table .= '| '.implode('-', $rows[$row]).' |'.PHP_EOL;
+                $table .= '| '.implode('-', $rows[$row]).' |'.PHP_EOL;
 
- 			if (0 === $row && ! empty($thead) || $row + 1 === $rows) {
- 				$table .= $cols.PHP_EOL;
- 			}
- 		}
+                if (0 === $row && ! empty($thead) || $row + 1 === $rows) {
+                    $table .= $cols.PHP_EOL;
+                }
+            }
 
- 		fwrite(static::$stdout, $table);
- 	}
+            fwrite(static::$stdout, $table);
+        }
 }
\ No newline at end of file