diff --git a/.gitignore b/.gitignore
index 5826402..02ceb5d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,4 @@
 composer.phar
 composer.lock
 .DS_Store
+notes
diff --git a/.travis.yml b/.travis.yml
index b1eb5d4..c08b8d6 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,8 +1,9 @@
 language: php
 
 php:
-  - 5.3
   - 5.4
+  - 5.5
+  - 5.6
 
 before_script:
   - curl -s http://getcomposer.org/installer | php
diff --git a/composer.json b/composer.json
index a554ad8..36d7598 100644
--- a/composer.json
+++ b/composer.json
@@ -1,34 +1,31 @@
 {
 	"name": "soapbox/laravel-formatter",
 	"type": "library",
-	"description": "A Laravel 4 formatting library that converts data output between XML, CSV, JSON, TXT, YAML and a few others. ",
-	"keywords": ["laravel", "formatter", "data","convert","csv", "xml", "yaml"],
+	"description": "A formatting library that converts data output between XML, CSV, JSON, TXT, YAML and a few others.",
+	"keywords": ["laravel", "formatter", "data", "convert", "csv", "xml", "yaml"],
     "homepage": "http://github.com/SoapBox/laravel-formatter",
     "license": "MIT",
-	"version": "1.4",
+	"version": "2.0",
 	"authors": [
 		{
 			"name": "Graham McCarthy",
 			"email": "graham@soapboxhq.com",
 			"homepage": "http://grahammccarthy.com"
+		},
+		{
+			"name": "Jaspaul Bola",
+			"email": "jaspaul.b@gamil.com",
+			"homepage": "http://jaspaulbola.com"
 		}
 	],
 	"require": {
-		"php": ">=5.3.0",
-		"illuminate/support": ">=4.0",
-		"illuminate/foundation": ">=4.0",
-		"illuminate/config": ">=4.0",
-		"illuminate/session": ">=4.0",
-		"illuminate/filesystem": ">=4.0",
-		"illuminate/view": ">=4.0"
-	},
-	"require-dev": {
-		"orchestra/testbench": "2.1.*",
-		"mockery/mockery": "dev-master"
+		"php": ">=5.4.0",
+		"league/csv": "~6.0",
+		"mustangostang/spyc": "0.5.*@dev",
+		"illuminate/support": ">=4.0"
 	},
 	"autoload": {
 		"psr-0": {
-			"Spyc": "src/spyc/",
 			"SoapBox\\Formatter": "src/"
 		}
 	},
diff --git a/readme.md b/readme.md
index e020937..a1dfc9f 100644
--- a/readme.md
+++ b/readme.md
@@ -3,69 +3,96 @@ Formatter Bundle
 
 [![Build Status](https://travis-ci.org/SoapBox/laravel-formatter.svg?branch=master)](https://travis-ci.org/SoapBox/laravel-formatter)
 
-A Laravel 4 Formatter Package based on the work done by @dberry37388 with FuelPHP's Formatter class.
+A formatter package that will help you to easily convert between various formats such as XML, JSON, CSV, etc...
 
-This package will help you to easily convert between various formats such as XML, JSON, CSV, etc...
+# Goals
+The goals of this library are to allow the transfomation of data formats from one type to another.
+See Parsers and Formats to see supported input / output formats.
 
+# Installation
 
-Installation
-------------
+Through command line:
 
-Begin by installing this package through Composer. Edit your project's `composer.json` file to require `SoapBox/laravel-formatter`.
+```bash
+composer require soapbox/laravel-formatter
+```
+
+Through composer.json:
 
-	"require": {
-		"soapbox/laravel-formatter": "dev-master"
-	}
+```json
+{
+  "require": {
+    "soapbox/laravel-formatter": "2.x"
+  }
+}
 
-Next, update Composer from the Terminal:
+```
 
-    composer update
+## Parsers
+All of the following are supported formats that the formatter can read from.
+* Array
+* CSV
+* JSON
+* XML
+* YAML
 
-Once this operation completes, the final step is to add the service provider. Open `app/config/app.php`, and add a new item to the providers array.
+## Formats
+All of the following are formats that are supported for output.
+* Array
+* CSV
+* JSON
+* XML
+* YAML
 
-    'SoapBox\Formatter\FormatterServiceProvider'
+## General Usage
 
+__Including The Formatter__
 
-Usage
------
-The best way to learn how to use Formatter is to look through the code, where you can familiarize yourself with all of the available methods.
+```php
+use SoapBox\Formatter\Formatter;
+```
 
-###Calling Formatter
-Formatter::make($data_to_convert, 'type of data')->to_the_format_you_want();
+__Supported Types__
 
-### Available Formats to Convert From
-- Json
-- Serialized Array
-- XML
-- CSV
+```php
+Formatter::JSON; //json
+Formatter::CSV;  //csv
+Formatter::XML;  //xml
+Formatter::ARR;  //array
+Formatter::YAML; //yaml
+```
 
-### Available Formats to Convert To
-- Json
-- Serializaed Array
-- XML
-- CSV
-- PHP Array
-- PHP Export
-- YAML
+__Making Your First Formatter(s)__
 
+```php
+$formatter = Formatter::make($jsonString, Formatter::JSON);
+$formatter = Formatter::make($yamlString, Formatter::YAML);
+$formatter = Formatter::make($array, Formatter::ARR);
+...
 ```
-$json_string = '{"foo":"bar","baz":"qux"}';
-$result = Formatter::make($json_string, 'json')->to_array();
-
-if ( empty(Formatter::$errors) ) {
-	//show the results
-	print_r($result);
-} else {
-	// Show the errors
-	print_r(Formatter::$errors);
-	return;
-}
 
-// Returns
-Array
-(
-    [foo] => bar
-    [baz] => qux
-)
+__Outputting From Your Formatter__
+
+```php
+$csv   = $formatter->toCsv();
+$json  = $formatter->toJson();
+$xml   = $formatter->toXml();
+$array = $formatter->toArray();
+$yaml  = $formatter->toYaml();
+```
+
+## Deprecated Functionality
+The following have been deprecated from the library, however you can easily continue using them in your application
+
+__Serialized Array__
+
+```php
+$serialized = serialize($formatter->toArray());
+```
+
+__PHP Export__
+
+```php
+$export = var_export($formatter->toArray());
 ```
 
diff --git a/src/SoapBox/Formatter/ArrayHelpers.php b/src/SoapBox/Formatter/ArrayHelpers.php
new file mode 100644
index 0000000..42ec4e3
--- /dev/null
+++ b/src/SoapBox/Formatter/ArrayHelpers.php
@@ -0,0 +1,23 @@
+<?php namespace SoapBox\Formatter;
+
+use Illuminate\Support\Arr;
+
+class ArrayHelpers {
+
+	public static function isAssociative($array) {
+	    return array_keys($array) !== range(0, count($array) - 1);
+	}
+
+	public static function dotKeys(array $data) {
+		return array_keys(Arr::dot($data));
+	}
+
+	public static function dot(array $data) {
+		return Arr::dot($data);
+	}
+
+	public static function set(array &$data, $key, $value) {
+		Arr::set($data, $key, $value);
+	}
+
+}
diff --git a/src/SoapBox/Formatter/Facades/Formatter.php b/src/SoapBox/Formatter/Facades/Formatter.php
deleted file mode 100644
index 76fd8e0..0000000
--- a/src/SoapBox/Formatter/Facades/Formatter.php
+++ /dev/null
@@ -1,14 +0,0 @@
-<?php namespace SoapBox\Formatter\Facades;
-
-use Illuminate\Support\Facades\Facade;
-
-class Formatter extends Facade {
-
-	/**
-	* Get the registered name of the component.
-	*
-	* @return string
-	*/
-	protected static function getFacadeAccessor() { return 'formatter'; }
-
-}
\ No newline at end of file
diff --git a/src/SoapBox/Formatter/Formatter.php b/src/SoapBox/Formatter/Formatter.php
index 576cc81..9029d13 100644
--- a/src/SoapBox/Formatter/Formatter.php
+++ b/src/SoapBox/Formatter/Formatter.php
@@ -1,432 +1,81 @@
-<?php
+<?php namespace SoapBox\Formatter;
 
-/**
- * Formatter Bundle
- *
- * Port of the FuelPHP Formatter Bundle
- * http://fuelphp.com/
- *
- * @package Formatter
- * @version 1.0
- * @author  Daniel Berry <daniel@danielberry.me>
- * @license MIT License (see LICENSE.readme included in the bundle)
- *
- */
+use InvalidArgumentException;
+use SoapBox\Formatter\Parsers\ArrayParser;
+use SoapBox\Formatter\Parsers\CsvParser;
+use SoapBox\Formatter\Parsers\JsonParser;
+use SoapBox\Formatter\Parsers\XmlParser;
+use SoapBox\Formatter\Parsers\YamlParser;
 
-/**
- * Setup the Formatter namespace
- */
-//namespace Formatter;
-namespace SoapBox\Formatter;
-
-//use Config, Lang;
-use Illuminate\Support\Facades\Config;
-use Illuminate\Support\Facades\Lang;
-
-/**
- * The Formatter Class
- *
- * Makes it quick and easy to convert data between several different formats.
- *
- * @package  Formatter
- * @author   Daniel Berry <danielberrytn@gmail.com>
- *
- */
 class Formatter {
-
-	/**
-	 * Holds the data that we are converting
-	 * @var array
-	 */
-	protected $_data = array();
-
-	/**
-	 * Holds the errors. For now only works with from_csv
-	 * @var array
-	 */
-	public static $errors = array();
-
-	/**
-	 * Returns an instance of the Formatter Bundle
-	 * @param  mixex  $data      the data we are converting
-	 * @param  [type] $from_type what we want to convert to
-	 * @return Formatter
-	 */
-	public static function make($data = null, $from_type = null, $attributes = array())
-	{
-		return new self($data, $from_type, $attributes);
-	}
-
-	/**
-	 * Should not be called directly. You should be using Formatter::make()
-	 *
-	 * Constructs our class and sets up some vars we will be using throughout
-	 * the conversion process.
-	 *
-	 * @param mixed  $data        data we will be converting
-	 * @param string $from_type  what we are converting form
-	 */
-	public function __construct($data = null, $from_type = null, $attributes = array())
-	{
-		// make sure we have data to convert to
-		if (!is_array($data) && empty($data)) {
-			array_push(self::$errors, Lang::get('formatter::formatter.no_data', array('from_type' => $from_type)));
-		}
-
-		// make sure our from type has been specified.
-		if ($from_type !== null) {
-			// check to make sure the method exists
-			if (method_exists($this, "_from_{$from_type}")) {
-				$data = call_user_func(array($this, '_from_' . $from_type), $data, $attributes);
-			} else {
-				array_push(self::$errors, Lang::get('formatter::formatter.from_type_not_supported', array('from_type' => $from_type)));
-			}
-		}
-
-		// set up our data.
-		$this->_data = $data;
-	}
-
-	/**
-	 * To array conversion
-	 *
-	 * Goes through the input and makes sure everything is either a scalar value or array
-	 *
-	 * @param   mixed  $data
-	 * @return  array
-	 */
-	public function to_array($data = null)
-	{
-		if ($data === null) {
-			$data = $this->_data;
-		}
-
-		$array = array();
-
-		if (is_object($data) and ! $data instanceof \Iterator) {
-			$data = get_object_vars($data);
-		}
-
-		if (empty($data)) {
-			return array();
-		}
-
-		foreach ($data as $key => $value) {
-			if (is_object($value) or is_array($value)) {
-				$array[$key] = $this->to_array($value);
-			} else {
-				$array[$key] = $value;
-			}
-		}
-
-		return $array;
-	}
-
-	/**
-	 * To CSV conversion
-	 *
-	 * @param   mixed   $data
-	 * @param   mixed   $delimiter
-	 * @return  string
-	 */
-	public function to_csv($data = null, $attributes = null) {
-
-		// let's get the config file
-		$config = Config::get('formatter::formatter.csv');
-
-		// csv format settings
-		$newline = array_get($attributes, 'newline', array_get($config, 'newline', "\n"));
-		$delimiter = array_get($attributes, 'delimiter', array_get($config, 'delimiter', ","));
-		$enclosure = array_get($attributes, 'enclosure', array_get($config, 'enclosure', "\""));
-		$escape = array_get($attributes, 'escape', array_get($config, 'escape', '\\'));
-
-		// escape function
-		$escaper = function($items) use($enclosure, $escape) {
-			return array_map(function($item) use($enclosure, $escape) {
-				return str_replace($enclosure, $escape.$enclosure, $item);
-			}, $items);
-		};
-
-		if ($data === null) {
-			$data = $this->_data;
-		}
-
-		if (is_object($data) and ! $data instanceof \Iterator) {
-			$data = $this->to_array($data);
-		}
-
-		// Multi-dimensional array
-		if (is_array($data) and self::is_multi($data)) {
-			$data = array_values($data);
-
-			if (self::is_assoc($data[0])) {
-				$headings = array_keys($data[0]);
-			} else {
-				$headings = array_shift($data);
-			}
-
-		}
-		// Single array
-		else {
-			$headings = array_keys((array) $data);
-			$data = array($data);
-		}
-
-		$output = $enclosure.implode($enclosure.$delimiter.$enclosure, $escaper($headings)).$enclosure.$newline;
-
-		foreach ($data as $row) {
-			$output .= $enclosure.implode($enclosure.$delimiter.$enclosure, $escaper((array) $row)).$enclosure.$newline;
-		}
-
-		return rtrim($output, $newline);
-	}
-
-
-	/**
-	 * Serialize
-	 *
-	 * @param   mixed  $data
-	 * @return  string
-	 */
-	public function to_serialized($data = null) {
-		if ($data == null) {
-			$data = $this->_data;
-		}
-
-		return serialize($data);
-	}
-
-	/**
-	 * To JSON conversion
-	 *
-	 * @param   mixed  $data
-	 * @param   bool   wether to make the json pretty
-	 * @return  string
-	 */
-	public function to_json($data = null, $pretty = false) {
-		if ($data == null) {
-			$data = $this->_data;
-		}
-
-		// To allow exporting ArrayAccess objects like Orm\Model instances they need to be
-		// converted to an array first
-		$data = (is_array($data) or is_object($data)) ? $this->to_array($data) : $data;
-		return $pretty ? static::pretty_json($data) : json_encode($data);
-	}
-
 	/**
-	 * Return as a string representing the PHP structure
-	 *
-	 * @param   mixed  $data
-	 * @return  string
+	 * Add class constants that help define input format
 	 */
-	public function to_php($data = null) {
-		if ($data == null) {
-			$data = $this->_data;
-		}
+	const CSV  = 'csv';
+	const JSON = 'json';
+	const XML  = 'xml';
+	const ARR  = 'array';
+	const YAML = 'yaml';
 
-		return var_export($data, true);
-	}
+	private static $supportedTypes = [self::CSV, self::JSON, self::XML, self::ARR, self::YAML];
+	private $parser;
 
 	/**
-	 * Convert to YAML
+	 * Make: Returns an instance of formatter initialized with data and type
 	 *
-	 * @param   mixed   $data
-	 * @return  string
-	 */
-	public function to_yaml($data = null) {
-		if ($data == null) {
-			$data = $this->_data;
-		}
-
-		$data = (is_array($data) or is_object($data)) ? $this->to_array($data) : $data;
-
-		return \Spyc::YAMLDump($data);
-	}
-
-	/**
-	 * To XML conversion
+	 * @param mixed $data The data that formatter should parse
+	 * @param string $type The type of data formatter is expected to parse
 	 *
-	 * @param   mixed        $data
-	 * @param   null         $structure
-	 * @param   null|string  $basenode
-	 * @return  string
+	 * @return Formatter
 	 */
-	public function to_xml($data = null, $structure = null, $basenode = 'xml') {
-		if ($data == null) {
-			$data = $this->_data;
-		}
-
-		// turn off compatibility mode as simple xml throws a wobbly if you don't.
-		if (ini_get('zend.ze1_compatibility_mode') == 1) {
-			ini_set('zend.ze1_compatibility_mode', 0);
-		}
-
-		if ($structure == null) {
-			$structure = simplexml_load_string("<?xml version='1.0' encoding='utf-8'?><$basenode />");
-		}
-
-		// Force it to be something useful
-		if ( ! is_array($data) and ! is_object($data)) {
-			$data = (array) $data;
-		}
-
-		foreach ($data as $key => $value) {
-			// convert our booleans to 0/1 integer values so they are
-			// not converted to blanks.
-			if(is_bool($value)) {
-				$value = (int) $value;
-			}
-
-			// no numeric keys in our xml please!
-			if (is_numeric($key)) {
-				// make string key...
-				$key = (\Str::singular($basenode) != $basenode) ? \Str::singular($basenode) : 'item';
-			}
-
-			// replace anything not alpha numeric
-			$key = preg_replace('/[^a-z_\-0-9]/i', '', $key);
-
-			// if there is another array found recrusively call this function
-			if (is_array($value) or is_object($value)) {
-				$node = $structure->addChild($key);
-
-				// recursive call if value is not empty
-				if( ! empty($value)) {
-					$this->to_xml($value, $node, $key);
-				}
-			} else {
-				// add single node.
-				$value = htmlspecialchars(html_entity_decode($value, ENT_QUOTES, 'UTF-8'), ENT_QUOTES, "UTF-8");
-
-				$structure->addChild($key, $value);
+	public static function make($data, $type) {
+		if (in_array($type, self::$supportedTypes)) {
+			$parser = null;
+			switch ($type) {
+				case self::CSV:
+					$parser = new CsvParser($data);
+					break;
+				case self::JSON:
+					$parser = new JsonParser($data);
+					break;
+				case self::XML:
+					$parser = new XmlParser($data);
+					break;
+				case self::ARR:
+					$parser = new ArrayParser($data);
+					break;
+				case self::YAML:
+					$parser = new YamlParser($data);
+					break;
 			}
+			return new Formatter($parser, $type);
 		}
-
-		// pass back as string. or simple xml object if you want!
-		return $structure->asXML();
+		throw new InvalidArgumentException(
+			'make function only accepts [csv, json, xml, array] for $type but ' . $type . ' was provided.'
+		);
 	}
 
-	/**
-	 * Import JSON data
-	 *
-	 * @param   string  $string
-	 * @return  mixed
-	 */
-	private function _from_json($string) {
-		return json_decode(trim($string));
+	private function __construct($parser) {
+		$this->parser = $parser;
 	}
 
-	/**
-	 * Import Serialized data
-	 *
-	 * @param   string  $string
-	 * @return  mixed
-	 */
-	private function _from_serialize($string) {
-		return unserialize(trim($string));
-	}
-
-	/**
-	 * Import XML data
-	 *
-	 * @param   string  $string
-	 * @return  array
-	 */
-	protected function _from_xml($string) {
-		$_arr = is_string($string) ? simplexml_load_string($string, 'SimpleXMLElement', LIBXML_NOCDATA) : $string;
-		$arr = array();
-
-		// Convert all objects SimpleXMLElement to array recursively
-		foreach ((array)$_arr as $key => $val) {
-			$arr[$key] = (is_array($val) or is_object($val)) ? $this->_from_xml($val) : $val;
-		}
-
-		return $arr;
+	public function toJson() {
+		return $this->parser->toJson();
 	}
 
-	/**
-	 * Import CSV data
-	 *
-	 * @param   string  $string
-	 * @return  array
-	 */
-	protected function _from_csv($string, $attributes = array()) {
-		$data = array();
-
-		// let's get the config file
-		$config = Config::get('formatter::formatter.csv');
-
-		// csv format settings
-		$newline = array_get($attributes, 'newline', array_get($config, 'newline', "\n"));
-		$delimiter = array_get($attributes, 'delimiter', array_get($config, 'delimiter', ","));
-		$enclosure = array_get($attributes, 'enclosure', array_get($config, 'enclosure', "\""));
-		$escape = array_get($attributes, 'escape', array_get($config, 'escape', '\\'));
-		$regex_newline = array_get($attributes, 'regex_newline', array_get($config, 'regex_newline', '\n'));
-
-		$rows = preg_split('/(?<='.preg_quote($enclosure).')'.$regex_newline.'/', trim($string));
-
-		// Get the headings
-		$headings = str_replace($escape.$enclosure, $enclosure, str_getcsv(array_shift($rows), $delimiter, $enclosure, $escape));
-
-		foreach ($rows as $line_number => $row) {
-			$data_fields = str_replace($escape.$enclosure, $enclosure, str_getcsv($row, $delimiter, $enclosure, $escape));
-			if (count($data_fields) > count($headings)) {
-				array_push(self::$errors, Lang::get('formatter::formatter.more_data', array('line_number' => $line_number + 1) ));
-			} else if (count($data_fields) < count($headings)) {
-				array_push(self::$errors, Lang::get('formatter::formatter.less_data', array('line_number' => $line_number + 1) ));
-			} else {
-				$data[] = array_combine($headings, $data_fields);
-			}
-		}
-
-		if(empty($rows) && !empty($headings) && count($headings) > 0) {
-			$data = $headings;
-		}
-
-		return $data;
+	public function toArray() {
+		return $this->parser->toArray();
 	}
 
-
-	/**
-	 * Checks if the given array is a multidimensional array.
-	 *
-	 * @param   array  $arr       the array to check
-	 * @param   array  $all_keys  if true, check that all elements are arrays
-	 * @return  bool   true if its a multidimensional array, false if not
-	 */
-	protected static function is_multi($arr, $all_keys = false) {
-		$values = array_filter($arr, 'is_array');
-		return $all_keys ? count($arr) === count($values) : count($values) > 0;
+	public function toYaml() {
+		return $this->parser->toYaml();
 	}
 
-	/**
-	 * Checks if the given array is an assoc array.
-	 *
-	 * @param   array  $arr  the array to check
-	 * @return  bool   true if its an assoc array, false if not
-	 */
-	public static function is_assoc($arr) {
-		if ( ! is_array($arr)) {
-			array_push(self::$errors, Lang::get('formatter::formatter.must_be_array'));
-		}
-
-		$counter = 0;
-
-		foreach ($arr as $key => $unused) {
-			if ( ! is_int($key) or $key !== $counter++) {
-				return true;
-			}
-		}
-		return false;
+	public function toXml() {
+		return $this->parser->toXml();
 	}
 
-	/**
-	 * Returns with errors
-	 * @return array
-	 */
-	public function errors()
-	{
-		return self::$errors;
+	public function toCsv() {
+		return $this->parser->toCsv();
 	}
 }
diff --git a/src/SoapBox/Formatter/FormatterServiceProvider.php b/src/SoapBox/Formatter/FormatterServiceProvider.php
index 9a97fd7..903ee2e 100644
--- a/src/SoapBox/Formatter/FormatterServiceProvider.php
+++ b/src/SoapBox/Formatter/FormatterServiceProvider.php
@@ -1,48 +1,43 @@
-<?php namespace SoapBox\Formatter;
-
-use Illuminate\Support\ServiceProvider;
-
-class FormatterServiceProvider extends ServiceProvider {
-
-	/**
-	 * Indicates if loading of the provider is deferred.
-	 *
-	 * @var bool
-	 */
-	protected $defer = false;
-
-	/**
-	 * Bootstrap the application events.
-	 *
-	 * @return void
-	 */
-	public function boot() {
-		$this->package('SoapBox/formatter');
-	}
-
-	/**
-	 * Register the service provider.
-	 *
-	 * @return void
-	 */
-	public function register() {
-		$this->app['formatter'] = $this->app->share(function($app) {
-			return new Formatter;
-		});
-
-		$this->app->booting(function() {
-			$loader = \Illuminate\Foundation\AliasLoader::getInstance();
-			$loader->alias('Formatter', 'SoapBox\Formatter\Facades\Formatter');
-		});
-	}
-
-	/**
-	 * Get the services provided by the provider.
-	 *
-	 * @return array
-	 */
-	public function provides() {
-		return array('formatter');
-	}
-
-}
\ No newline at end of file
+<?php namespace SoapBox\Formatter;
+
+use Illuminate\Support\ServiceProvider;
+
+/**
+ * Used to register Authroize with service providers, mainly for Laravel.
+ */
+class FormatterServiceProvider extends ServiceProvider {
+
+	/**
+	 * Indicates if loading of the provider is deferred.
+	 *
+	 * @var bool
+	 */
+	protected $defer = false;
+
+	/**
+	 * Bootstrap the application events.
+	 *
+	 * @return void
+	 */
+	public function boot() {
+		$this->package('soapbox/laravel-formatter');
+	}
+
+	/**
+	 * Register the service provider.
+	 *
+	 * @return void
+	 */
+	public function register() {
+	}
+
+	/**
+	 * Get the services provided by the provider.
+	 *
+	 * @return array
+	 */
+	public function provides() {
+		return array();
+	}
+
+}
diff --git a/src/SoapBox/Formatter/Parsers/ArrayParser.php b/src/SoapBox/Formatter/Parsers/ArrayParser.php
new file mode 100644
index 0000000..aa569cb
--- /dev/null
+++ b/src/SoapBox/Formatter/Parsers/ArrayParser.php
@@ -0,0 +1,26 @@
+<?php namespace SoapBox\Formatter\Parsers;
+
+use InvalidArgumentException;
+
+class ArrayParser extends Parser {
+
+	private $array;
+
+	public function __construct($data) {
+		if (is_string($data)) {
+			$data = unserialize($data);
+		}
+
+		if (is_array($data) || is_object($data)) {
+			$this->array = (array) $data;
+		} else {
+			throw new InvalidArgumentException(
+				'ArrayParser only accepts (optionally serialized) [object, array] for $data.'
+			);
+		}
+	}
+
+	public function toArray() {
+		return $this->array;
+	}
+}
diff --git a/src/SoapBox/Formatter/Parsers/CsvParser.php b/src/SoapBox/Formatter/Parsers/CsvParser.php
new file mode 100644
index 0000000..5f57fb6
--- /dev/null
+++ b/src/SoapBox/Formatter/Parsers/CsvParser.php
@@ -0,0 +1,44 @@
+<?php namespace SoapBox\Formatter\Parsers;
+
+use InvalidArgumentException;
+use League\Csv\Reader;
+use SoapBox\Formatter\ArrayHelpers;
+
+class CsvParser extends Parser {
+
+	private $csv;
+
+	public function __construct($data) {
+		if (is_string($data)) {
+			$this->csv = Reader::createFromString($data);
+		} else {
+			throw new InvalidArgumentException(
+				'CsvParser only accepts (string) [csv] for $data.'
+			);
+		}
+	}
+
+	public function toArray() {
+		$temp = $this->csv->jsonSerialize();
+
+		$headings = $temp[0];
+		$result = $headings;
+
+		if (count($temp) > 1) {
+			$result = [];
+			for ($i = 1; $i < count($temp); ++$i) {
+				$row = [];
+				for ($j = 0; $j < count($headings); ++$j) {
+					$row[$headings[$j]] = $temp[$i][$j];
+				}
+				$expanded = [];
+				foreach ($row as $key => $value) {
+					ArrayHelpers::set($expanded, $key, $value);
+				}
+				$result[] = $expanded;
+			}
+		}
+
+		return $result;
+	}
+}
diff --git a/src/SoapBox/Formatter/Parsers/JsonParser.php b/src/SoapBox/Formatter/Parsers/JsonParser.php
new file mode 100644
index 0000000..372ec68
--- /dev/null
+++ b/src/SoapBox/Formatter/Parsers/JsonParser.php
@@ -0,0 +1,15 @@
+<?php namespace SoapBox\Formatter\Parsers;
+
+class JsonParser extends Parser {
+
+	private $json;
+
+	public function __construct($data) {
+		$this->json = json_decode(trim($data));
+	}
+
+	public function toArray() {
+		return (array) $this->json;
+	}
+
+}
diff --git a/src/SoapBox/Formatter/Parsers/Parser.php b/src/SoapBox/Formatter/Parsers/Parser.php
new file mode 100644
index 0000000..0d33f81
--- /dev/null
+++ b/src/SoapBox/Formatter/Parsers/Parser.php
@@ -0,0 +1,155 @@
+<?php namespace SoapBox\Formatter\Parsers;
+
+use Spyc;
+use Illuminate\Support\Str;
+use SoapBox\Formatter\ArrayHelpers;
+
+/**
+ * Parser Interface
+ *
+ * This interface describes the abilities of a parser which is able to transform
+ * inputs to the object type.
+ */
+abstract class Parser {
+
+	/**
+	 * Constructor is used to initialize the parser
+	 *
+	 * @param mixed $data The input sharing a type with the parser
+	 */
+	abstract public function __construct($data);
+
+	/**
+	 * Used to retrieve a (php) array representation of the data encapsulated within our Parser.
+	 *
+	 * @return array
+	 */
+	abstract public function toArray();
+
+	/**
+	 * Return a json representation of the data stored in the parser
+	 *
+	 * @return string A json string representing the encapsulated data
+	 */
+	public function toJson() {
+		return json_encode($this->toArray());
+	}
+
+	/**
+	 * Return a yaml representation of the data stored in the parser
+	 *
+	 * @return string A yaml string representing the encapsulated data
+	 */
+	public function toYaml() {
+		return Spyc::YAMLDump($this->toArray());
+	}
+
+	/**
+	 * To XML conversion
+	 *
+	 * @param   mixed        $data
+	 * @param   null         $structure
+	 * @param   null|string  $basenode
+	 * @return  string
+	 */
+	private function xmlify($data, $structure = null, $basenode = 'xml') {
+		// turn off compatibility mode as simple xml throws a wobbly if you don't.
+		if (ini_get('zend.ze1_compatibility_mode') == 1) {
+			ini_set('zend.ze1_compatibility_mode', 0);
+		}
+
+		if ($structure == null) {
+			$structure = simplexml_load_string("<?xml version='1.0' encoding='utf-8'?><$basenode />");
+		}
+
+		// Force it to be something useful
+		if (!is_array($data) && !is_object($data)) {
+			$data = (array) $data;
+		}
+
+		foreach ($data as $key => $value) {
+			// convert our booleans to 0/1 integer values so they are
+			// not converted to blanks.
+			if (is_bool($value)) {
+				$value = (int) $value;
+			}
+
+			// no numeric keys in our xml please!
+			if (is_numeric($key)) {
+				// make string key...
+				$key = (Str::singular($basenode) != $basenode) ? Str::singular($basenode) : 'item';
+			}
+
+			// replace anything not alpha numeric
+			$key = preg_replace('/[^a-z_\-0-9]/i', '', $key);
+
+			// if there is another array found recrusively call this function
+			if (is_array($value) or is_object($value)) {
+				$node = $structure->addChild($key);
+
+				// recursive call if value is not empty
+				if (!empty($value)) {
+					$this->xmlify($value, $node, $key);
+				}
+			} else {
+				// add single node.
+				$value = htmlspecialchars(html_entity_decode($value, ENT_QUOTES, 'UTF-8'), ENT_QUOTES, "UTF-8");
+
+				$structure->addChild($key, $value);
+			}
+		}
+
+		// pass back as string. or simple xml object if you want!
+		return $structure->asXML();
+	}
+
+	/**
+	 * Return an xml representation of the data stored in the parser
+	 *
+	 * @return string An xml string representing the encapsulated data
+	 */
+	public function toXml() {
+		return $this->xmlify($this->toArray());
+	}
+
+	private function csvify($data) {
+		$results = [];
+		foreach ($data as $row) {
+			$results[] = array_values(ArrayHelpers::dot($row));
+		}
+		return $results;
+	}
+
+	/**
+	 * Return a csv representation of the data stored in the parser
+	 *
+	 * @return string An csv string representing the encapsulated data
+	 */
+	public function toCsv() {
+		$data = $this->toArray();
+
+		if (ArrayHelpers::isAssociative($data) || !is_array($data[0])) {
+			$data = [$data];
+		}
+
+		$result = [];
+
+		$result[] = ArrayHelpers::dotKeys($data[0]);
+
+		foreach ($data as $row) {
+			$result[] = array_values(ArrayHelpers::dot($row));
+		}
+
+		$output = '';
+		$count = 0;
+		foreach ($result as $row) {
+			if ($count != 0) {
+				$output .=  "\r\n";
+			}
+			$count++;
+			$output .= implode(',', $row);
+		}
+
+		return $output;
+	}
+}
diff --git a/src/SoapBox/Formatter/Parsers/XmlParser.php b/src/SoapBox/Formatter/Parsers/XmlParser.php
new file mode 100644
index 0000000..100786d
--- /dev/null
+++ b/src/SoapBox/Formatter/Parsers/XmlParser.php
@@ -0,0 +1,36 @@
+<?php namespace SoapBox\Formatter\Parsers;
+
+class XmlParser extends Parser {
+
+	private $xml;
+
+	/**
+	 * Ported from laravel-formatter
+	 * https://github.com/SoapBox/laravel-formatter
+	 *
+	 * @author  Daniel Berry <daniel@danielberry.me>
+	 * @license MIT License (see LICENSE.readme included in the bundle)
+	 *
+	 */
+	private function objectify($value) {
+		$temp = is_string($value) ?
+			simplexml_load_string($value, 'SimpleXMLElement', LIBXML_NOCDATA) :
+			$value;
+
+		$result = [];
+
+		foreach ((array) $temp as $key => $value) {
+			$result[$key] = (is_array($value) or is_object($value)) ? $this->objectify($value) : $value;
+		}
+
+		return $result;
+	}
+
+	public function __construct($data) {
+		$this->xml = $this->objectify($data);
+	}
+
+	public function toArray() {
+		return (array) $this->xml;
+	}
+}
diff --git a/src/SoapBox/Formatter/Parsers/YamlParser.php b/src/SoapBox/Formatter/Parsers/YamlParser.php
new file mode 100644
index 0000000..ca1547d
--- /dev/null
+++ b/src/SoapBox/Formatter/Parsers/YamlParser.php
@@ -0,0 +1,24 @@
+<?php namespace SoapBox\Formatter\Parsers;
+
+use InvalidArgumentException;
+use Spyc;
+
+class YamlParser extends Parser {
+
+	private $array;
+
+	public function __construct($data) {
+		if (is_string($data)) {
+			$this->array = Spyc::YAMLLoadString($data);
+		} else {
+			throw new InvalidArgumentException(
+				'YamlParser only accepts (string) [yaml] for $data.'
+			);
+		}
+	}
+
+	public function toArray() {
+		return $this->array;
+	}
+
+}
diff --git a/src/config/.gitkeep b/src/config/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/src/config/formatter.php b/src/config/formatter.php
deleted file mode 100644
index 2716b5e..0000000
--- a/src/config/formatter.php
+++ /dev/null
@@ -1,13 +0,0 @@
-<?php
-return array(
-	'csv' => array(
-		'delimiter'     => ',',
-		'enclosure'     => '"',
-		'newline'       => "\n",
-		'regex_newline' => '\n',
-		'escape'        => '\\',
-	),
-	'xml' => array(
-		'basenode' => 'xml',
-	),
-);
diff --git a/src/lang/.gitkeep b/src/lang/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/src/lang/en/formatter.php b/src/lang/en/formatter.php
deleted file mode 100644
index 8749c10..0000000
--- a/src/lang/en/formatter.php
+++ /dev/null
@@ -1,21 +0,0 @@
-<?php
-
-/**
- * Formatter Bundle
- *
- * Port of the FuelPHP Formatter Bundle
- * http://fuelphp.com/
- *
- * @package Formatter
- * @version 1.0
- * @author  Daniel Berry <daniel@danielberry.me>
- * @license MIT License (see LICENSE.readme included in the bundle)
- *
- */
-
-return array(
-	'no_data' 				  => 'No data to convert',
-	'from_type_not_supported' => ':from_type is not a supported type to convert from.',
-	'more_data'				  => 'The line :line_number contains more data fields than the heading.',
-	'less_data'				  => 'The line :line_number contains less data fields than the heading.'
-);
\ No newline at end of file
diff --git a/src/spyc/COPYING b/src/spyc/COPYING
deleted file mode 100644
index 8e7ddbc..0000000
--- a/src/spyc/COPYING
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License
-
-Copyright (c) 2011 Vladimir Andersen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
\ No newline at end of file
diff --git a/src/spyc/README b/src/spyc/README
deleted file mode 100644
index 4d77166..0000000
--- a/src/spyc/README
+++ /dev/null
@@ -1,159 +0,0 @@
-#
-#    S P Y C
-#      a simple php yaml class
-#
-# Load this README!
-# >> $readme = Spyc::YAMLLoad('README');
-#
---- %YAML:1.1
-title: Spyc -- a Simple PHP YAML Class
-version: 0.5
-authors: [chris wanstrath (chris@ozmm.org), vlad andersen (vlad.andersen@gmail.com)]
-websites: [http://www.yaml.org, http://spyc.sourceforge.net]
-license: [MIT License, http://www.opensource.org/licenses/mit-license.php]
-copyright: "(c) 2005-2006 Chris Wanstrath, 2006-2011 Vlad Andersen"
-tested on: [php 5.2.x]
-
-installation: >
-  Copy spyc.php to a directory you can
-  access with your YAML-ready PHP script.
-
-  That's it!
-
-about: >
-  From www.yaml.org:
-
-  "YAML(tm) (rhymes with 'camel') is a human-friendly, cross language,
-  Unicode based data serialization language designed around the common
-  native data structures of agile programming languages. It is broadly
-  useful for programming needs ranging from configuration files to
-  Internet messaging to object persistence to data auditing. Together
-  with the Unicode standard for characters, the YAML specification provides
-  all the information necessary to understand YAML Version 1.1 and to
-  creating programs that process YAML information.
-
-  YAML(tm) is a balance of the following design goals:
-    - YAML documents are very readable by humans.
-    - YAML interacts well with scripting languages.
-    - YAML uses host languages' native data structures.
-    - YAML has a consistent information model.
-    - YAML enables stream-based processing.
-    - YAML is expressive and extensible.
-    - YAML is easy to implement."
-
-  YAML makes a lot of sense.  It's easy to use, easy to learn, and cool.
-  As the lucky stiff named why once said, "YAML is a beacon of light."
-
-  If you're new to YAML, may we suggest YAML In Five Minutes:
-    - http://yaml.kwiki.org/?YamlInFiveMinutes
-
-  If you don't have five minutes, realize that this README is a completely
-  valid YAML document.  Dig in, load this or any YAML file into an array
-  with Spyc and see how easy it is to translate friendly text into usable
-  data.
-
-  The purpose of Spyc is to provide a pure PHP alternative to Syck, a
-  simple API for loading and dumping YAML documents, a YAML loader which
-  understands a usable subset of the YAML spec, and to further spread
-  the glory of YAML to the PHP masses.
-
-  If you're at all hesitant ("usable subset of YAML?!"), navigate
-  http://yaml.org/start.html.  Spyc completely understands the YAML
-  document shown there, a document which has features way beyond the
-  scope of what normal config files might require.  Try it for yourself,
-  and then start enjoying the peace of mind YAML brings to your life.
-
-meat and a few potatoes:
-  - concept: Loading a YAML document into PHP
-    brief: >
-      $yaml will become an array of all the data in wicked.yaml
-    code: |
-
-      include('spyc.php');
-
-      $yaml = Spyc::YAMLLoad('wicked.yaml');
-
-  - concept: Loading a YAML string into PHP
-    brief: >
-      $array will look like this:
-        array('A YAML','document in a','string')
-    code: |
-
-      include('spyc.php');
-
-      $yaml  = '- A YAML\n- document in a\n- string.';
-      $array = Spyc::YAMLLoad($yaml);
-
-  - concept: Dumping a PHP array to YAML
-    brief: >
-      $yaml will become a string of a YAML document created from
-      $array.
-    code: |
-
-      include('spyc.php');
-
-      $array['name']  = 'chris';
-      $array['sport'] = 'curbing';
-
-      $yaml = Spyc::YAMLDump($array);
-
-prior art:
-  - who: [Brian Ingerson, Clark Evans, Oren Ben-Kiki]
-    why?: >
-      The YAML spec is really a piece of work, and these guys
-      did a great job on it.  A simple and elegant language like
-      YAML was a long time coming and it's refreshing to know
-      such able minded individuals took the task to heart and
-      executed it with cunning and strength.  In addition to
-      their various noteworthy contributions to YAML parsers
-      and related projects, YAML.pm's README is a treasure trove
-      of information for knowledge seekers.  Thanks, guys.
-
-  - who: why the lucky stiff
-    why?: >
-      As the author of Syck, the code used in Ruby for the language's
-      YAML class and methods, why is indirectly (directly?) responsible
-      for my first exposure to YAML (as a config file in a Ruby web-app)
-      and the countless hours I spent playing with this sheik new data
-      format afterwards.  Syck's README is a YAML file and thus the
-      inspiration for this file and, even, this very piece of software.
-
-  - who: Steve Howell
-    why?: >
-      Python's YAML implementation.  PyYAML's README file is also YAML,
-      so it too inspired the YAML format of this README file.
-
-  - who: [Rasmus Lerdorf, Zeev Suraski, Andi Gutmans, et al]
-    why?: >
-      PHP is great at what it does best.  It's also paid a lot of my bills.
-      Thanks.
-
-bugs:
-  report: >
-    Please see Spyc's Sourceforge project page for information on reporting bugs.
-  speed: >
-    This implementation was not designed for speed.  Rather, it
-    was designed for those who need a pure PHP implementation of
-    a YAML parser and who are not overly concerned with performance.
-    If you want speed, check out Syck.
-  depth: >
-    This parser is by no means a comprehensive YAML parser.  For supported
-    features and future plans, check the website.
-  unicode: >
-    YAML is supposed to be unicode, but for now we're just using ASCII.
-    PHP has crappy unicode support but who knows what the future holds.
-
-resources:
-  - http://www.yaml.org
-  - http://www.yaml.org/spec/
-  - http://yaml.kwiki.org/?YamlInFiveMinutes
-  - http://www.whytheluckystiff.net/syck/
-  - http://yaml4r.sourceforge.net/cookbook/
-
-thanks:
-  - Adam Wood
-  - Daniel Ferreira
-  - Aaron Jensen
-  - Mike Thornton
-  - Fabien Potencier
-  - Mustafa Kumas
\ No newline at end of file
diff --git a/src/spyc/examples/yaml-dump.php b/src/spyc/examples/yaml-dump.php
deleted file mode 100644
index 05a8a2f..0000000
--- a/src/spyc/examples/yaml-dump.php
+++ /dev/null
@@ -1,25 +0,0 @@
-<?php
-
-#
-#    S P Y C
-#      a simple php yaml class
-#
-# Feel free to dump an array to YAML, and then to load that YAML back into an
-# array.  This is a good way to test the limitations of the parser and maybe
-# learn some basic YAML.
-#
-
-include('../spyc.php');
-
-$array[] = 'Sequence item';
-$array['The Key'] = 'Mapped value';
-$array[] = array('A sequence','of a sequence');
-$array[] = array('first' => 'A sequence','second' => 'of mapped values');
-$array['Mapped'] = array('A sequence','which is mapped');
-$array['A Note'] = 'What if your text is too long?';
-$array['Another Note'] = 'If that is the case, the dumper will probably fold your text by using a block.  Kinda like this.';
-$array['The trick?'] = 'The trick is that we overrode the default indent, 2, to 4 and the default wordwrap, 40, to 60.';
-$array['Old Dog'] = "And if you want\n to preserve line breaks, \ngo ahead!";
-$array['key:withcolon'] = "Should support this to";
-
-$yaml = Spyc::YAMLDump($array,4,60);
\ No newline at end of file
diff --git a/src/spyc/examples/yaml-load.php b/src/spyc/examples/yaml-load.php
deleted file mode 100644
index fba9571..0000000
--- a/src/spyc/examples/yaml-load.php
+++ /dev/null
@@ -1,21 +0,0 @@
-<?php
-
-#
-#    S P Y C
-#      a simple php yaml class
-#
-# license: [MIT License, http://www.opensource.org/licenses/mit-license.php]
-#
-
-include('../spyc.php');
-
-$array = Spyc::YAMLLoad('../spyc.yaml');
-
-echo '<pre><a href="spyc.yaml">spyc.yaml</a> loaded into PHP:<br/>';
-print_r($array);
-echo '</pre>';
-
-
-echo '<pre>YAML Data dumped back:<br/>';
-echo Spyc::YAMLDump($array);
-echo '</pre>';
diff --git a/src/spyc/php4/5to4.php b/src/spyc/php4/5to4.php
deleted file mode 100644
index 5a48694..0000000
--- a/src/spyc/php4/5to4.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-php5to4 ("../spyc.php", 'spyc-latest.php4');
-
-function php5to4 ($src, $dest) {
-  $code = file_get_contents ($src);
-  $code = preg_replace ('#(public|private|protected)\s+\$#i', 'var \$', $code);
-  $code = preg_replace ('#(public|private|protected)\s+static\s+\$#i', 'var \$', $code);
-  $code = preg_replace ('#(public|private|protected)\s+function#i', 'function', $code);
-  $code = preg_replace ('#(public|private|protected)\s+static\s+function#i', 'function', $code);
-  $code = preg_replace ('#throw new Exception\\(([^)]*)\\)#i', 'trigger_error($1,E_USER_ERROR)', $code);
-  $code = str_replace ('self::', '$this->', $code);
-  $f = fopen ($dest, 'w');
-  fwrite($f, $code);
-  fclose ($f);
-  print "Written to $dest.\n";
-}
\ No newline at end of file
diff --git a/src/spyc/php4/spyc.php4 b/src/spyc/php4/spyc.php4
deleted file mode 100644
index 73f08cc..0000000
--- a/src/spyc/php4/spyc.php4
+++ /dev/null
@@ -1,1023 +0,0 @@
-<?php
-/**
-   * Spyc -- A Simple PHP YAML Class
-   * @version 0.4.5
-   * @author Vlad Andersen <vlad.andersen@gmail.com>
-   * @author Chris Wanstrath <chris@ozmm.org>
-   * @link http://code.google.com/p/spyc/
-   * @copyright Copyright 2005-2006 Chris Wanstrath, 2006-2009 Vlad Andersen
-   * @license http://www.opensource.org/licenses/mit-license.php MIT License
-   * @package Spyc
-   */
-
-if (!function_exists('spyc_load')) {
-  /**
-   * Parses YAML to array.
-   * @param string $string YAML string.
-   * @return array
-   */
-  function spyc_load ($string) {
-    return Spyc::YAMLLoadString($string);
-  }
-}
-
-if (!function_exists('spyc_load_file')) {
-  /**
-   * Parses YAML to array.
-   * @param string $file Path to YAML file.
-   * @return array
-   */
-  function spyc_load_file ($file) {
-    return Spyc::YAMLLoad($file);
-  }
-}
-
-/**
-   * The Simple PHP YAML Class.
-   *
-   * This class can be used to read a YAML file and convert its contents
-   * into a PHP array.  It currently supports a very limited subsection of
-   * the YAML spec.
-   *
-   * Usage:
-   * <code>
-   *   $Spyc  = new Spyc;
-   *   $array = $Spyc->load($file);
-   * </code>
-   * or:
-   * <code>
-   *   $array = Spyc::YAMLLoad($file);
-   * </code>
-   * or:
-   * <code>
-   *   $array = spyc_load_file($file);
-   * </code>
-   * @package Spyc
-   */
-class Spyc {
-
-  // SETTINGS
-
-  /**
-   * Setting this to true will force YAMLDump to enclose any string value in
-   * quotes.  False by default.
-   * 
-   * @var bool
-   */
-  var $setting_dump_force_quotes = false;
-
-  /**
-   * Setting this to true will forse YAMLLoad to use syck_load function when
-   * possible. False by default.
-   * @var bool
-   */
-  var $setting_use_syck_is_possible = false;
-
-
-
-  /**#@+
-  * @access private
-  * @var mixed
-  */
-  var $_dumpIndent;
-  var $_dumpWordWrap;
-  var $_containsGroupAnchor = false;
-  var $_containsGroupAlias = false;
-  var $path;
-  var $result;
-  var $LiteralPlaceHolder = '___YAML_Literal_Block___';
-  var $SavedGroups = array();
-  var $indent;
-  /**
-   * Path modifier that should be applied after adding current element.
-   * @var array
-   */
-  var $delayedPath = array();
-
-  /**#@+
-  * @access public
-  * @var mixed
-  */
-  var $_nodeId;
-
-/**
- * Load a valid YAML string to Spyc.
- * @param string $input
- * @return array
- */
-  function load ($input) {
-    return $this->__loadString($input);
-  }
-
- /**
- * Load a valid YAML file to Spyc.
- * @param string $file
- * @return array
- */
-  function loadFile ($file) {
-    return $this->__load($file);
-  }
-
-  /**
-     * Load YAML into a PHP array statically
-     *
-     * The load method, when supplied with a YAML stream (string or file),
-     * will do its best to convert YAML in a file into a PHP array.  Pretty
-     * simple.
-     *  Usage:
-     *  <code>
-     *   $array = Spyc::YAMLLoad('lucky.yaml');
-     *   print_r($array);
-     *  </code>
-     * @access public
-     * @return array
-     * @param string $input Path of YAML file or string containing YAML
-     */
-  function YAMLLoad($input) {
-    $Spyc = new Spyc;
-    return $Spyc->__load($input);
-  }
-
-  /**
-     * Load a string of YAML into a PHP array statically
-     *
-     * The load method, when supplied with a YAML string, will do its best 
-     * to convert YAML in a string into a PHP array.  Pretty simple.
-     *
-     * Note: use this function if you don't want files from the file system
-     * loaded and processed as YAML.  This is of interest to people concerned
-     * about security whose input is from a string.
-     *
-     *  Usage:
-     *  <code>
-     *   $array = Spyc::YAMLLoadString("---\n0: hello world\n");
-     *   print_r($array);
-     *  </code>
-     * @access public
-     * @return array
-     * @param string $input String containing YAML
-     */
-  function YAMLLoadString($input) {
-    $Spyc = new Spyc;
-    return $Spyc->__loadString($input);
-  }
-
-  /**
-     * Dump YAML from PHP array statically
-     *
-     * The dump method, when supplied with an array, will do its best
-     * to convert the array into friendly YAML.  Pretty simple.  Feel free to
-     * save the returned string as nothing.yaml and pass it around.
-     *
-     * Oh, and you can decide how big the indent is and what the wordwrap
-     * for folding is.  Pretty cool -- just pass in 'false' for either if
-     * you want to use the default.
-     *
-     * Indent's default is 2 spaces, wordwrap's default is 40 characters.  And
-     * you can turn off wordwrap by passing in 0.
-     *
-     * @access public
-     * @return string
-     * @param array $array PHP array
-     * @param int $indent Pass in false to use the default, which is 2
-     * @param int $wordwrap Pass in 0 for no wordwrap, false for default (40)
-     */
-  function YAMLDump($array,$indent = false,$wordwrap = false) {
-    $spyc = new Spyc;
-    return $spyc->dump($array,$indent,$wordwrap);
-  }
-
-
-  /**
-     * Dump PHP array to YAML
-     *
-     * The dump method, when supplied with an array, will do its best
-     * to convert the array into friendly YAML.  Pretty simple.  Feel free to
-     * save the returned string as tasteful.yaml and pass it around.
-     *
-     * Oh, and you can decide how big the indent is and what the wordwrap
-     * for folding is.  Pretty cool -- just pass in 'false' for either if
-     * you want to use the default.
-     *
-     * Indent's default is 2 spaces, wordwrap's default is 40 characters.  And
-     * you can turn off wordwrap by passing in 0.
-     *
-     * @access public
-     * @return string
-     * @param array $array PHP array
-     * @param int $indent Pass in false to use the default, which is 2
-     * @param int $wordwrap Pass in 0 for no wordwrap, false for default (40)
-     */
-  function dump($array,$indent = false,$wordwrap = false) {
-    // Dumps to some very clean YAML.  We'll have to add some more features
-    // and options soon.  And better support for folding.
-
-    // New features and options.
-    if ($indent === false or !is_numeric($indent)) {
-      $this->_dumpIndent = 2;
-    } else {
-      $this->_dumpIndent = $indent;
-    }
-
-    if ($wordwrap === false or !is_numeric($wordwrap)) {
-      $this->_dumpWordWrap = 40;
-    } else {
-      $this->_dumpWordWrap = $wordwrap;
-    }
-
-    // New YAML document
-    $string = "---\n";
-
-    // Start at the base of the array and move through it.
-    if ($array) {
-      $array = (array)$array;
-      $first_key = key($array);
-      
-      $previous_key = -1;
-      foreach ($array as $key => $value) {
-        $string .= $this->_yamlize($key,$value,0,$previous_key, $first_key);
-        $previous_key = $key;
-      }
-    }
-    return $string;
-  }
-
-  /**
-     * Attempts to convert a key / value array item to YAML
-     * @access private
-     * @return string
-     * @param $key The name of the key
-     * @param $value The value of the item
-     * @param $indent The indent of the current node
-     */
-  function _yamlize($key,$value,$indent, $previous_key = -1, $first_key = 0) {
-    if (is_array($value)) {
-      if (empty ($value))
-        return $this->_dumpNode($key, array(), $indent, $previous_key, $first_key);
-      // It has children.  What to do?
-      // Make it the right kind of item
-      $string = $this->_dumpNode($key, NULL, $indent, $previous_key, $first_key);
-      // Add the indent
-      $indent += $this->_dumpIndent;
-      // Yamlize the array
-      $string .= $this->_yamlizeArray($value,$indent);
-    } elseif (!is_array($value)) {
-      // It doesn't have children.  Yip.
-      $string = $this->_dumpNode($key, $value, $indent, $previous_key, $first_key);
-    }
-    return $string;
-  }
-
-  /**
-     * Attempts to convert an array to YAML
-     * @access private
-     * @return string
-     * @param $array The array you want to convert
-     * @param $indent The indent of the current level
-     */
-  function _yamlizeArray($array,$indent) {
-    if (is_array($array)) {
-      $string = '';
-      $previous_key = -1;
-      $first_key = key($array);
-      foreach ($array as $key => $value) {
-        $string .= $this->_yamlize($key, $value, $indent, $previous_key, $first_key);
-        $previous_key = $key;
-      }
-      return $string;
-    } else {
-      return false;
-    }
-  }
-
-  /**
-     * Returns YAML from a key and a value
-     * @access private
-     * @return string
-     * @param $key The name of the key
-     * @param $value The value of the item
-     * @param $indent The indent of the current node
-     */
-  function _dumpNode($key, $value, $indent, $previous_key = -1, $first_key = 0) {
-    // do some folding here, for blocks
-    if (is_string ($value) && ((strpos($value,"\n") !== false || strpos($value,": ") !== false || strpos($value,"- ") !== false ||
-      strpos($value,"*") !== false || strpos($value,"#") !== false || strpos($value,"<") !== false || strpos($value,">") !== false ||
-      strpos($value,"[") !== false || strpos($value,"]") !== false || strpos($value,"{") !== false || strpos($value,"}") !== false) || substr ($value, -1, 1) == ':')) {
-      $value = $this->_doLiteralBlock($value,$indent);
-    } else {
-      $value  = $this->_doFolding($value,$indent);
-      if (is_bool($value)) {
-        $value = ($value) ? "true" : "false";
-      }
-    }
-
-    if ($value === array()) $value = '[ ]';
-
-    $spaces = str_repeat(' ',$indent);
-
-    if (is_int($key) && $key - 1 == $previous_key && $first_key===0) {
-      // It's a sequence
-      $string = $spaces.'- '.$value."\n";
-    } else {
-      if ($first_key===0)  throw new Exception('Keys are all screwy.  The first one was zero, now it\'s "'. $key .'"');
-      // It's mapped
-      if (strpos($key, ":") !== false) { $key = '"' . $key . '"'; }
-      $string = $spaces.$key.': '.$value."\n";
-    }
-    return $string;
-  }
-
-  /**
-     * Creates a literal block for dumping
-     * @access private
-     * @return string
-     * @param $value
-     * @param $indent int The value of the indent
-     */
-  function _doLiteralBlock($value,$indent) {
-    if (strpos($value, "\n") === false && strpos($value, "'") === false) {
-      return sprintf ("'%s'", $value);
-    }
-    if (strpos($value, "\n") === false && strpos($value, '"') === false) {
-      return sprintf ('"%s"', $value);
-    }
-    $exploded = explode("\n",$value);
-    $newValue = '|';
-    $indent  += $this->_dumpIndent;
-    $spaces   = str_repeat(' ',$indent);
-    foreach ($exploded as $line) {
-      $newValue .= "\n" . $spaces . trim($line);
-    }
-    return $newValue;
-  }
-
-  /**
-     * Folds a string of text, if necessary
-     * @access private
-     * @return string
-     * @param $value The string you wish to fold
-     */
-  function _doFolding($value,$indent) {
-    // Don't do anything if wordwrap is set to 0
-
-    if ($this->_dumpWordWrap !== 0 && is_string ($value) && strlen($value) > $this->_dumpWordWrap) {
-      $indent += $this->_dumpIndent;
-      $indent = str_repeat(' ',$indent);
-      $wrapped = wordwrap($value,$this->_dumpWordWrap,"\n$indent");
-      $value   = ">\n".$indent.$wrapped;
-    } else {
-      if ($this->setting_dump_force_quotes && is_string ($value))
-        $value = '"' . $value . '"';
-    }
-
-
-    return $value;
-  }
-
-// LOADING FUNCTIONS
-
-  function __load($input) {
-    $Source = $this->loadFromSource($input);
-    return $this->loadWithSource($Source);
-  }
-
-  function __loadString($input) {
-    $Source = $this->loadFromString($input);
-    return $this->loadWithSource($Source);
-  }
-
-  function loadWithSource($Source) {
-    if (empty ($Source)) return array();
-    if ($this->setting_use_syck_is_possible && function_exists ('syck_load')) {
-      $array = syck_load (implode ('', $Source));
-      return is_array($array) ? $array : array();
-    }
-
-    $this->path = array();
-    $this->result = array();
-
-    $cnt = count($Source);
-    for ($i = 0; $i < $cnt; $i++) {
-      $line = $Source[$i];
-      
-      $this->indent = strlen($line) - strlen(ltrim($line));
-      $tempPath = $this->getParentPathByIndent($this->indent);
-      $line = $this->stripIndent($line, $this->indent);
-      if ($this->isComment($line)) continue;
-      if ($this->isEmpty($line)) continue;
-      $this->path = $tempPath;
-
-      $literalBlockStyle = $this->startsLiteralBlock($line);
-      if ($literalBlockStyle) {
-        $line = rtrim ($line, $literalBlockStyle . " \n");
-        $literalBlock = '';
-        $line .= $this->LiteralPlaceHolder;
-
-        while (++$i < $cnt && $this->literalBlockContinues($Source[$i], $this->indent)) {
-          $literalBlock = $this->addLiteralLine($literalBlock, $Source[$i], $literalBlockStyle);
-        }
-        $i--;
-      }
-
-      while (++$i < $cnt && $this->greedilyNeedNextLine($line)) {
-        $line = rtrim ($line, " \n\t\r") . ' ' . ltrim ($Source[$i], " \t");
-      }
-      $i--;
-
-
-
-      if (strpos ($line, '#')) {
-        if (strpos ($line, '"') === false && strpos ($line, "'") === false)
-          $line = preg_replace('/\s+#(.+)$/','',$line);
-      }
-
-      $lineArray = $this->_parseLine($line);
-
-      if ($literalBlockStyle)
-        $lineArray = $this->revertLiteralPlaceHolder ($lineArray, $literalBlock);
-
-      $this->addArray($lineArray, $this->indent);
-
-      foreach ($this->delayedPath as $indent => $delayedPath)
-        $this->path[$indent] = $delayedPath;
-
-      $this->delayedPath = array();
-
-    }
-    return $this->result;
-  }
-
-  function loadFromSource ($input) {
-    if (!empty($input) && strpos($input, "\n") === false && file_exists($input))
-    return file($input);
-
-    return $this->loadFromString($input);
-  }
-
-  function loadFromString ($input) {
-    $lines = explode("\n",$input);
-    foreach ($lines as $k => $_) {
-      $lines[$k] = rtrim ($_, "\r");
-    }
-    return $lines;
-  }
-
-  /**
-     * Parses YAML code and returns an array for a node
-     * @access private
-     * @return array
-     * @param string $line A line from the YAML file
-     */
-  function _parseLine($line) {
-    if (!$line) return array();
-    $line = trim($line);
-
-    if (!$line) return array();
-    $array = array();
-
-    $group = $this->nodeContainsGroup($line);
-    if ($group) {
-      $this->addGroup($line, $group);
-      $line = $this->stripGroup ($line, $group);
-    }
-
-    if ($this->startsMappedSequence($line))
-      return $this->returnMappedSequence($line);
-
-    if ($this->startsMappedValue($line))
-      return $this->returnMappedValue($line);
-
-    if ($this->isArrayElement($line))
-     return $this->returnArrayElement($line);
-
-    if ($this->isPlainArray($line))
-     return $this->returnPlainArray($line); 
-     
-     
-    return $this->returnKeyValuePair($line);
-
-  }
-
-  /**
-     * Finds the type of the passed value, returns the value as the new type.
-     * @access private
-     * @param string $value
-     * @return mixed
-     */
-  function _toType($value) {
-    if ($value === '') return null;
-    $first_character = $value[0];
-    $last_character = substr($value, -1, 1);
-
-    $is_quoted = false;
-    do {
-      if (!$value) break;
-      if ($first_character != '"' && $first_character != "'") break;
-      if ($last_character != '"' && $last_character != "'") break;
-      $is_quoted = true;
-    } while (0);
-
-    if ($is_quoted)
-      return strtr(substr ($value, 1, -1), array ('\\"' => '"', '\'\'' => '\'', '\\\'' => '\''));
-    
-    if (strpos($value, ' #') !== false)
-      $value = preg_replace('/\s+#(.+)$/','',$value);
-
-    if ($first_character == '[' && $last_character == ']') {
-      // Take out strings sequences and mappings
-      $innerValue = trim(substr ($value, 1, -1));
-      if ($innerValue === '') return array();
-      $explode = $this->_inlineEscape($innerValue);
-      // Propagate value array
-      $value  = array();
-      foreach ($explode as $v) {
-        $value[] = $this->_toType($v);
-      }
-      return $value;
-    }
-
-    if (strpos($value,': ')!==false && $first_character != '{') {
-      $array = explode(': ',$value);
-      $key   = trim($array[0]);
-      array_shift($array);
-      $value = trim(implode(': ',$array));
-      $value = $this->_toType($value);
-      return array($key => $value);
-    }
-    
-    if ($first_character == '{' && $last_character == '}') {
-      $innerValue = trim(substr ($value, 1, -1));
-      if ($innerValue === '') return array();
-      // Inline Mapping
-      // Take out strings sequences and mappings
-      $explode = $this->_inlineEscape($innerValue);
-      // Propagate value array
-      $array = array();
-      foreach ($explode as $v) {
-        $SubArr = $this->_toType($v);
-        if (empty($SubArr)) continue;
-        if (is_array ($SubArr)) {
-          $array[key($SubArr)] = $SubArr[key($SubArr)]; continue;
-        }
-        $array[] = $SubArr;
-      }
-      return $array;
-    }
-
-    if ($value == 'null' || $value == 'NULL' || $value == 'Null' || $value == '' || $value == '~') {
-      return null;
-    }
-
-    if (intval($first_character) > 0 && preg_match ('/^[1-9]+[0-9]*$/', $value)) {
-      $intvalue = (int)$value;
-      if ($intvalue != PHP_INT_MAX)
-        $value = $intvalue;
-      return $value;
-    }
-
-    if (in_array($value,
-                 array('true', 'on', '+', 'yes', 'y', 'True', 'TRUE', 'On', 'ON', 'YES', 'Yes', 'Y'))) {
-      return true;
-    }
-
-    if (in_array(strtolower($value),
-                 array('false', 'off', '-', 'no', 'n'))) {
-      return false;
-    }
-
-    if (is_numeric($value)) {
-      if ($value === '0') return 0;
-      if (trim ($value, 0) === $value)
-        $value = (float)$value;
-      return $value;
-    }
-    
-    return $value;
-  }
-
-  /**
-     * Used in inlines to check for more inlines or quoted strings
-     * @access private
-     * @return array
-     */
-  function _inlineEscape($inline) {
-    // There's gotta be a cleaner way to do this...
-    // While pure sequences seem to be nesting just fine,
-    // pure mappings and mappings with sequences inside can't go very
-    // deep.  This needs to be fixed.
-
-    $seqs = array();
-    $maps = array();
-    $saved_strings = array();
-
-    // Check for strings
-    $regex = '/(?:(")|(?:\'))((?(1)[^"]+|[^\']+))(?(1)"|\')/';
-    if (preg_match_all($regex,$inline,$strings)) {
-      $saved_strings = $strings[0];
-      $inline  = preg_replace($regex,'YAMLString',$inline);
-    }
-    unset($regex);
-
-    $i = 0;
-    do {
-
-    // Check for sequences
-    while (preg_match('/\[([^{}\[\]]+)\]/U',$inline,$matchseqs)) {
-      $seqs[] = $matchseqs[0];
-      $inline = preg_replace('/\[([^{}\[\]]+)\]/U', ('YAMLSeq' . (count($seqs) - 1) . 's'), $inline, 1);
-    }
-
-    // Check for mappings
-    while (preg_match('/{([^\[\]{}]+)}/U',$inline,$matchmaps)) {
-      $maps[] = $matchmaps[0];
-      $inline = preg_replace('/{([^\[\]{}]+)}/U', ('YAMLMap' . (count($maps) - 1) . 's'), $inline, 1);
-    }
-
-    if ($i++ >= 10) break;
-
-    } while (strpos ($inline, '[') !== false || strpos ($inline, '{') !== false);
-
-    $explode = explode(', ',$inline);
-    $stringi = 0; $i = 0;
-
-    while (1) {
-
-    // Re-add the sequences
-    if (!empty($seqs)) {
-      foreach ($explode as $key => $value) {
-        if (strpos($value,'YAMLSeq') !== false) {
-          foreach ($seqs as $seqk => $seq) {
-            $explode[$key] = str_replace(('YAMLSeq'.$seqk.'s'),$seq,$value);
-            $value = $explode[$key];
-          }
-        }
-      }
-    }
-
-    // Re-add the mappings
-    if (!empty($maps)) {
-      foreach ($explode as $key => $value) {
-        if (strpos($value,'YAMLMap') !== false) {
-          foreach ($maps as $mapk => $map) {
-            $explode[$key] = str_replace(('YAMLMap'.$mapk.'s'), $map, $value);
-            $value = $explode[$key];
-          }
-        }
-      }
-    }
-
-
-    // Re-add the strings
-    if (!empty($saved_strings)) {
-      foreach ($explode as $key => $value) {
-        while (strpos($value,'YAMLString') !== false) {
-          $explode[$key] = preg_replace('/YAMLString/',$saved_strings[$stringi],$value, 1);
-          unset($saved_strings[$stringi]);
-          ++$stringi;
-          $value = $explode[$key];
-        }
-      }
-    }
-
-    $finished = true;
-    foreach ($explode as $key => $value) {
-      if (strpos($value,'YAMLSeq') !== false) {
-        $finished = false; break;
-      }
-      if (strpos($value,'YAMLMap') !== false) {
-        $finished = false; break;
-      }
-      if (strpos($value,'YAMLString') !== false) {
-        $finished = false; break;
-      }
-    }
-    if ($finished) break;
-
-    $i++;
-    if ($i > 10) 
-      break; // Prevent infinite loops.
-    }
-
-    return $explode;
-  }
-
-  function literalBlockContinues ($line, $lineIndent) {
-    if (!trim($line)) return true;
-    if (strlen($line) - strlen(ltrim($line)) > $lineIndent) return true;
-    return false;
-  }
-
-  function referenceContentsByAlias ($alias) {
-    do {
-      if (!isset($this->SavedGroups[$alias])) { echo "Bad group name: $alias."; break; }
-      $groupPath = $this->SavedGroups[$alias];
-      $value = $this->result;
-      foreach ($groupPath as $k) {
-        $value = $value[$k];
-      }
-    } while (false);
-    return $value;
-  }
-
-  function addArrayInline ($array, $indent) {
-      $CommonGroupPath = $this->path;
-      if (empty ($array)) return false;
-      
-      foreach ($array as $k => $_) {
-        $this->addArray(array($k => $_), $indent);
-        $this->path = $CommonGroupPath;
-      }
-      return true;
-  }
-
-  function addArray ($incoming_data, $incoming_indent) {
-
-   // print_r ($incoming_data);
-
-    if (count ($incoming_data) > 1)
-      return $this->addArrayInline ($incoming_data, $incoming_indent);
-    
-    $key = key ($incoming_data);
-    $value = isset($incoming_data[$key]) ? $incoming_data[$key] : null;
-    if ($key === '__!YAMLZero') $key = '0';
-
-    if ($incoming_indent == 0 && !$this->_containsGroupAlias && !$this->_containsGroupAnchor) { // Shortcut for root-level values.
-      if ($key || $key === '' || $key === '0') {
-        $this->result[$key] = $value;
-      } else {
-        $this->result[] = $value; end ($this->result); $key = key ($this->result);
-      }
-      $this->path[$incoming_indent] = $key;
-      return;
-    }
-
-
-    
-    $history = array();
-    // Unfolding inner array tree.
-    $history[] = $_arr = $this->result;
-    foreach ($this->path as $k) {
-      $history[] = $_arr = $_arr[$k];
-    }
-
-    if ($this->_containsGroupAlias) {
-      $value = $this->referenceContentsByAlias($this->_containsGroupAlias);
-      $this->_containsGroupAlias = false;
-    }
-
-
-    // Adding string or numeric key to the innermost level or $this->arr.
-    if (is_string($key) && $key == '<<') {
-      if (!is_array ($_arr)) { $_arr = array (); }
-      $_arr = array_merge ($_arr, $value);
-    } else if ($key || $key === '' || $key === '0') {
-      $_arr[$key] = $value;
-    } else {
-      if (!is_array ($_arr)) { $_arr = array ($value); $key = 0; }
-      else { $_arr[] = $value; end ($_arr); $key = key ($_arr); }
-    }
-
-    $reverse_path = array_reverse($this->path);
-    $reverse_history = array_reverse ($history);
-    $reverse_history[0] = $_arr;
-    $cnt = count($reverse_history) - 1;
-    for ($i = 0; $i < $cnt; $i++) {
-      $reverse_history[$i+1][$reverse_path[$i]] = $reverse_history[$i];
-    }
-    $this->result = $reverse_history[$cnt];
-
-    $this->path[$incoming_indent] = $key;
-
-    if ($this->_containsGroupAnchor) {
-      $this->SavedGroups[$this->_containsGroupAnchor] = $this->path;
-      if (is_array ($value)) {
-        $k = key ($value);
-        if (!is_int ($k)) {
-          $this->SavedGroups[$this->_containsGroupAnchor][$incoming_indent + 2] = $k;
-        }
-      }
-      $this->_containsGroupAnchor = false;
-    }
-
-  }
-
-  function startsLiteralBlock ($line) {
-    $lastChar = substr (trim($line), -1);
-    if ($lastChar != '>' && $lastChar != '|') return false;
-    if ($lastChar == '|') return $lastChar;
-    // HTML tags should not be counted as literal blocks.
-    if (preg_match ('#<.*?>$#', $line)) return false;
-    return $lastChar;
-  }
-
-  function greedilyNeedNextLine($line) {
-    $line = trim ($line);
-    if (!strlen($line)) return false;
-    if (substr ($line, -1, 1) == ']') return false;
-    if ($line[0] == '[') return true;
-    if (preg_match ('#^[^:]+?:\s*\[#', $line)) return true;
-    return false;
-  }
-
-  function addLiteralLine ($literalBlock, $line, $literalBlockStyle) {
-    $line = $this->stripIndent($line);
-    $line = rtrim ($line, "\r\n\t ") . "\n";
-    if ($literalBlockStyle == '|') {
-      return $literalBlock . $line;
-    }
-    if (strlen($line) == 0)
-      return rtrim($literalBlock, ' ') . "\n";
-    if ($line == "\n" && $literalBlockStyle == '>') {
-      return rtrim ($literalBlock, " \t") . "\n";
-    }
-    if ($line != "\n")
-      $line = trim ($line, "\r\n ") . " ";
-    return $literalBlock . $line;
-  }
-
-   function revertLiteralPlaceHolder ($lineArray, $literalBlock) {
-     foreach ($lineArray as $k => $_) {
-      if (is_array($_))
-        $lineArray[$k] = $this->revertLiteralPlaceHolder ($_, $literalBlock);
-      else if (substr($_, -1 * strlen ($this->LiteralPlaceHolder)) == $this->LiteralPlaceHolder)
-	       $lineArray[$k] = rtrim ($literalBlock, " \r\n");
-     }
-     return $lineArray;
-   }
-
-  function stripIndent ($line, $indent = -1) {
-    if ($indent == -1) $indent = strlen($line) - strlen(ltrim($line));
-    return substr ($line, $indent);
-  }
-
-  function getParentPathByIndent ($indent) {
-    if ($indent == 0) return array();
-    $linePath = $this->path;
-    do {
-      end($linePath); $lastIndentInParentPath = key($linePath);
-      if ($indent <= $lastIndentInParentPath) array_pop ($linePath);
-    } while ($indent <= $lastIndentInParentPath);
-    return $linePath;
-  }
-
-
-  function clearBiggerPathValues ($indent) {
-
-
-    if ($indent == 0) $this->path = array();
-    if (empty ($this->path)) return true;
-
-    foreach ($this->path as $k => $_) {
-      if ($k > $indent) unset ($this->path[$k]);
-    }
-
-    return true;
-  }
-
-
-  function isComment ($line) {
-    if (!$line) return false;
-    if ($line[0] == '#') return true;
-    if (trim($line, " \r\n\t") == '---') return true;
-    return false;
-  }
-
-  function isEmpty ($line) {
-    return (trim ($line) === '');
-  }
-
-
-  function isArrayElement ($line) {
-    if (!$line) return false;
-    if ($line[0] != '-') return false;
-    if (strlen ($line) > 3)
-      if (substr($line,0,3) == '---') return false;
-    
-    return true;
-  }
-
-  function isHashElement ($line) {
-    return strpos($line, ':');
-  }
-
-  function isLiteral ($line) {
-    if ($this->isArrayElement($line)) return false;
-    if ($this->isHashElement($line)) return false;
-    return true;
-  }
-
-
-  function unquote ($value) {
-    if (!$value) return $value;
-    if (!is_string($value)) return $value;
-    if ($value[0] == '\'') return trim ($value, '\'');
-    if ($value[0] == '"') return trim ($value, '"');
-    return $value;
-  }
-
-  function startsMappedSequence ($line) {
-    return ($line[0] == '-' && substr ($line, -1, 1) == ':');
-  }
-
-  function returnMappedSequence ($line) {
-    $array = array();
-    $key         = $this->unquote(trim(substr($line,1,-1)));
-    $array[$key] = array();
-    $this->delayedPath = array(strpos ($line, $key) + $this->indent => $key);
-    return array($array);
-  }
-
-  function returnMappedValue ($line) {
-    $array = array();
-    $key         = $this->unquote (trim(substr($line,0,-1)));
-    $array[$key] = '';
-    return $array;
-  }
-
-  function startsMappedValue ($line) {
-    return (substr ($line, -1, 1) == ':');
-  }
-  
-  function isPlainArray ($line) {
-    return ($line[0] == '[' && substr ($line, -1, 1) == ']');
-  }
-  
-  function returnPlainArray ($line) {
-    return $this->_toType($line); 
-  }  
-
-  function returnKeyValuePair ($line) {
-    $array = array();
-    $key = '';
-    if (strpos ($line, ':')) {
-      // It's a key/value pair most likely
-      // If the key is in double quotes pull it out
-      if (($line[0] == '"' || $line[0] == "'") && preg_match('/^(["\'](.*)["\'](\s)*:)/',$line,$matches)) {
-        $value = trim(str_replace($matches[1],'',$line));
-        $key   = $matches[2];
-      } else {
-        // Do some guesswork as to the key and the value
-        $explode = explode(':',$line);
-        $key     = trim($explode[0]);
-        array_shift($explode);
-        $value   = trim(implode(':',$explode));
-      }
-      // Set the type of the value.  Int, string, etc
-      $value = $this->_toType($value);
-      if ($key === '0') $key = '__!YAMLZero';
-      $array[$key] = $value;
-    } else {
-      $array = array ($line);
-    }
-    return $array;
-
-  }
-
-
-  function returnArrayElement ($line) {
-     if (strlen($line) <= 1) return array(array()); // Weird %)
-     $array = array();
-     $value   = trim(substr($line,1));
-     $value   = $this->_toType($value);
-     $array[] = $value;
-     return $array;
-  }
-
-
-  function nodeContainsGroup ($line) {    
-    $symbolsForReference = 'A-z0-9_\-';
-    if (strpos($line, '&') === false && strpos($line, '*') === false) return false; // Please die fast ;-)
-    if ($line[0] == '&' && preg_match('/^(&['.$symbolsForReference.']+)/', $line, $matches)) return $matches[1];
-    if ($line[0] == '*' && preg_match('/^(\*['.$symbolsForReference.']+)/', $line, $matches)) return $matches[1];
-    if (preg_match('/(&['.$symbolsForReference.']+)$/', $line, $matches)) return $matches[1];
-    if (preg_match('/(\*['.$symbolsForReference.']+$)/', $line, $matches)) return $matches[1];
-    if (preg_match ('#^\s*<<\s*:\s*(\*[^\s]+).*$#', $line, $matches)) return $matches[1];
-    return false;
-
-  }
-
-  function addGroup ($line, $group) {
-    if ($group[0] == '&') $this->_containsGroupAnchor = substr ($group, 1);
-    if ($group[0] == '*') $this->_containsGroupAlias = substr ($group, 1);
-    //print_r ($this->path);
-  }
-
-  function stripGroup ($line, $group) {
-    $line = trim(str_replace($group, '', $line));
-    return $line;
-  }
-}
-
-// Enable use of Spyc from command line
-// The syntax is the following: php spyc.php spyc.yaml
-
-define ('SPYC_FROM_COMMAND_LINE', false);
-
-do {
-  if (!SPYC_FROM_COMMAND_LINE) break;
-  if (empty ($_SERVER['argc']) || $_SERVER['argc'] < 2) break;
-  if (empty ($_SERVER['PHP_SELF']) || $_SERVER['PHP_SELF'] != 'spyc.php') break;
-  $file = $argv[1];
-  printf ("Spyc loading file: %s\n", $file);
-  print_r (spyc_load_file ($file));
-} while (0);
\ No newline at end of file
diff --git a/src/spyc/php4/test.php4 b/src/spyc/php4/test.php4
deleted file mode 100644
index 315f501..0000000
--- a/src/spyc/php4/test.php4
+++ /dev/null
@@ -1,162 +0,0 @@
-<?php
-#
-#    S P Y C
-#      a simple php yaml class
-#   v0.3
-#
-# author: [chris wanstrath, chris@ozmm.org]
-# websites: [http://www.yaml.org, http://spyc.sourceforge.net/]
-# license: [MIT License, http://www.opensource.org/licenses/mit-license.php]
-# copyright: (c) 2005-2006 Chris Wanstrath
-#
-# We're gonna load a file into memory and see if we get what we expect.
-# If not, we're gonna complain.
-#
-# Pretty lo-fi.  Let's see if we can't get some unit testing going in the next,
-# I dunno, 20 months?  Alright.  Go team.
-#
-
-error_reporting(E_ALL);
-
-include('spyc.php4');
-
-$yaml = Spyc::YAMLLoad('../spyc.yaml');
-
-// print_r ($yaml);
-
-# Added in .2
-if ($yaml[1040] != "Ooo, a numeric key!")
-	die('Key: 1040 failed');
-
-# Test mappings / types
-if ($yaml['String'] != "Anyone's name, really.")
-	die('Key: String failed');
-
-if ($yaml['Int'] !== 13)
-	die('Key: Int failed');
-
-if ($yaml['True'] !== true)
-	die('Key: True failed');
-
-if ($yaml['False'] !== false)
-	die('Key: False failed');
-
-if ($yaml['Zero'] !== 0)
-	die('Key: Zero failed');
-
-if (isset($yaml['Null']))
-	die('Key: Null failed');
-
-if ($yaml['Float'] !== 5.34)
-	die('Key: Float failed');
-
-
-# Test sequences
-if ($yaml[0] != "PHP Class")
-	die('Sequence 0 failed');
-
-if ($yaml[1] != "Basic YAML Loader")
-	die('Sequence 1 failed');
-
-if ($yaml[2] != "Very Basic YAML Dumper")
-	die('Sequence 2 failed');
-
-# A sequence of a sequence
-if ($yaml[3] != array("YAML is so easy to learn.",
-											"Your config files will never be the same."))
-	die('Sequence 3 failed');
-
-# Sequence of mappings
-if ($yaml[4] != array("cpu" => "1.5ghz", "ram" => "1 gig",
-											"os" => "os x 10.4.1"))
-	die('Sequence 4 failed');
-
-# Mapped sequence
-if ($yaml['domains'] != array("yaml.org", "php.net"))
-	die("Key: 'domains' failed");
-
-# A sequence like this.
-if ($yaml[5] != array("program" => "Adium", "platform" => "OS X",
-											"type" => "Chat Client"))
-	die('Sequence 5 failed');
-
-# A folded block as a mapped value
-if ($yaml['no time'] != "There isn't any time for your tricks!\nDo you understand?")
-	die("Key: 'no time' failed");
-
-# A literal block as a mapped value
-if ($yaml['some time'] != "There is nothing but time\nfor your tricks.")
-	die("Key: 'some time' failed");
-
-# Crazy combinations
-if ($yaml['databases'] != array( array("name" => "spartan", "notes" =>
-																			array( "Needs to be backed up",
-																						 "Needs to be normalized" ),
-																			 "type" => "mysql" )))
-  die("Key: 'databases' failed");
-
-# You can be a bit tricky
-if ($yaml["if: you'd"] != "like")
-	die("Key: 'if: you\'d' failed");
-
-# Inline sequences
-if ($yaml[6] != array("One", "Two", "Three", "Four"))
-	die("Sequence 6 failed");
-
-# Nested Inline Sequences
-if ($yaml[7] != array("One", array("Two", "And", "Three"), "Four", "Five"))
-	die("Sequence 7 failed");
-
-# Nested Nested Inline Sequences
-if ($yaml[8] != array( "This", array("Is", "Getting", array("Ridiculous", "Guys")),
-									"Seriously", array("Show", "Mercy")))
-	die("Sequence 8 failed");
-
-# Inline mappings
-if ($yaml[9] != array("name" => "chris", "age" => "young", "brand" => "lucky strike"))
-	die("Sequence 9 failed");
-
-# Nested inline mappings
-if ($yaml[10] != array("name" => "mark", "age" => "older than chris",
-											 "brand" => array("marlboro", "lucky strike")))
-	die("Sequence 10 failed");
-
-# References -- they're shaky, but functional
-if ($yaml['dynamic languages'] != array('Perl', 'Python', 'PHP', 'Ruby'))
-	die("Key: 'dynamic languages' failed");
-
-if ($yaml['compiled languages'] != array('C/C++', 'Java'))
-	die("Key: 'compiled languages' failed");
-
-if ($yaml['all languages'] != array(
-																		array('Perl', 'Python', 'PHP', 'Ruby'),
-																		array('C/C++', 'Java')
-																	 ))
-	die("Key: 'all languages' failed");
-
-# Added in .2.2: Escaped quotes
-if ($yaml[11] != "you know, this shouldn't work.  but it does.")
-	die("Sequence 11 failed.");
-
-if ($yaml[12] != "that's my value.")
-	die("Sequence 12 failed.");
-
-if ($yaml[13] != "again, that's my value.")
-	die("Sequence 13 failed.");
-
-if ($yaml[14] != "here's to \"quotes\", boss.")
-	die("Sequence 14 failed.");
-
-if ($yaml[15] != array( 'name' => "Foo, Bar's", 'age' => 20))
-	die("Sequence 15 failed.");
-
-if ($yaml[16] != array( 0 => "a", 1 => array (0 => 1, 1 => 2), 2 => "b"))
-	die("Sequence 16 failed.");
-
-if ($yaml['endloop'] != "Does this line in the end indeed make Spyc go to an infinite loop?")
-	die("[endloop] failed.");
-
-
-print "spyc.yaml parsed correctly\n";
-
-?>
\ No newline at end of file
diff --git a/src/spyc/spyc.php b/src/spyc/spyc.php
deleted file mode 100644
index 8b67c82..0000000
--- a/src/spyc/spyc.php
+++ /dev/null
@@ -1,1046 +0,0 @@
-<?php
-	/**
-	* Spyc -- A Simple PHP YAML Class
-	* @version 0.5
-	* @author Vlad Andersen <vlad.andersen@gmail.com>
-	* @author Chris Wanstrath <chris@ozmm.org>
-	* @link http://code.google.com/p/spyc/
-	* @copyright Copyright 2005-2006 Chris Wanstrath, 2006-2011 Vlad Andersen
-	* @license http://www.opensource.org/licenses/mit-license.php MIT License
-	* @package Spyc
-	**/
-
-if (!function_exists('spyc_load')) {
-	/**
-	* Parses YAML to array.
-	* @param string $string YAML string.
-	* @return array
-	*/
-	function spyc_load ($string) {
-		return Spyc::YAMLLoadString($string);
-	}
-}
-
-if (!function_exists('spyc_load_file')) {
-	/**
-	* Parses YAML to array.
-	* @param string $file Path to YAML file.
-	* @return array
-	*/
-	function spyc_load_file ($file) {
-		return Spyc::YAMLLoad($file);
-	}
-}
-
-/**
-* The Simple PHP YAML Class.
-*
-* This class can be used to read a YAML file and convert its contents
-* into a PHP array.  It currently supports a very limited subsection of
-* the YAML spec.
-*
-* Usage:
-* <code>
-*   $Spyc  = new Spyc;
-*   $array = $Spyc->load($file);
-* </code>
-* or:
-* <code>
-*   $array = Spyc::YAMLLoad($file);
-* </code>
-* or:
-* <code>
-*   $array = spyc_load_file($file);
-* </code>
-* @package Spyc
-**/
-class Spyc {
-
-  // SETTINGS
-
-  const REMPTY = "\0\0\0\0\0";
-
-  /**
-   * Setting this to true will force YAMLDump to enclose any string value in
-   * quotes.  False by default.
-   *
-   * @var bool
-   */
-  public $setting_dump_force_quotes = false;
-
-  /**
-   * Setting this to true will forse YAMLLoad to use syck_load function when
-   * possible. False by default.
-   * @var bool
-   */
-  public $setting_use_syck_is_possible = false;
-
-
-
-  /**#@+
-  * @access private
-  * @var mixed
-  */
-  private $_dumpIndent;
-  private $_dumpWordWrap;
-  private $_containsGroupAnchor = false;
-  private $_containsGroupAlias = false;
-  private $path;
-  private $result;
-  private $LiteralPlaceHolder = '___YAML_Literal_Block___';
-  private $SavedGroups = array();
-  private $indent;
-  /**
-   * Path modifier that should be applied after adding current element.
-   * @var array
-   */
-  private $delayedPath = array();
-
-  /**#@+
-  * @access public
-  * @var mixed
-  */
-  public $_nodeId;
-
-/**
- * Load a valid YAML string to Spyc.
- * @param string $input
- * @return array
- */
-  public function load ($input) {
-    return $this->__loadString($input);
-  }
-
- /**
- * Load a valid YAML file to Spyc.
- * @param string $file
- * @return array
- */
-  public function loadFile ($file) {
-    return $this->__load($file);
-  }
-
-  /**
-     * Load YAML into a PHP array statically
-     *
-     * The load method, when supplied with a YAML stream (string or file),
-     * will do its best to convert YAML in a file into a PHP array.  Pretty
-     * simple.
-     *  Usage:
-     *  <code>
-     *   $array = Spyc::YAMLLoad('lucky.yaml');
-     *   print_r($array);
-     *  </code>
-     * @access public
-     * @return array
-     * @param string $input Path of YAML file or string containing YAML
-     */
-  public static function YAMLLoad($input) {
-    $Spyc = new Spyc;
-    return $Spyc->__load($input);
-  }
-
-  /**
-     * Load a string of YAML into a PHP array statically
-     *
-     * The load method, when supplied with a YAML string, will do its best
-     * to convert YAML in a string into a PHP array.  Pretty simple.
-     *
-     * Note: use this function if you don't want files from the file system
-     * loaded and processed as YAML.  This is of interest to people concerned
-     * about security whose input is from a string.
-     *
-     *  Usage:
-     *  <code>
-     *   $array = Spyc::YAMLLoadString("---\n0: hello world\n");
-     *   print_r($array);
-     *  </code>
-     * @access public
-     * @return array
-     * @param string $input String containing YAML
-     */
-  public static function YAMLLoadString($input) {
-    $Spyc = new Spyc;
-    return $Spyc->__loadString($input);
-  }
-
-  /**
-     * Dump YAML from PHP array statically
-     *
-     * The dump method, when supplied with an array, will do its best
-     * to convert the array into friendly YAML.  Pretty simple.  Feel free to
-     * save the returned string as nothing.yaml and pass it around.
-     *
-     * Oh, and you can decide how big the indent is and what the wordwrap
-     * for folding is.  Pretty cool -- just pass in 'false' for either if
-     * you want to use the default.
-     *
-     * Indent's default is 2 spaces, wordwrap's default is 40 characters.  And
-     * you can turn off wordwrap by passing in 0.
-     *
-     * @access public
-     * @return string
-     * @param array $array PHP array
-     * @param int $indent Pass in false to use the default, which is 2
-     * @param int $wordwrap Pass in 0 for no wordwrap, false for default (40)
-     */
-  public static function YAMLDump($array,$indent = false,$wordwrap = false) {
-    $spyc = new Spyc;
-    return $spyc->dump($array,$indent,$wordwrap);
-  }
-
-
-  /**
-     * Dump PHP array to YAML
-     *
-     * The dump method, when supplied with an array, will do its best
-     * to convert the array into friendly YAML.  Pretty simple.  Feel free to
-     * save the returned string as tasteful.yaml and pass it around.
-     *
-     * Oh, and you can decide how big the indent is and what the wordwrap
-     * for folding is.  Pretty cool -- just pass in 'false' for either if
-     * you want to use the default.
-     *
-     * Indent's default is 2 spaces, wordwrap's default is 40 characters.  And
-     * you can turn off wordwrap by passing in 0.
-     *
-     * @access public
-     * @return string
-     * @param array $array PHP array
-     * @param int $indent Pass in false to use the default, which is 2
-     * @param int $wordwrap Pass in 0 for no wordwrap, false for default (40)
-     */
-  public function dump($array,$indent = false,$wordwrap = false) {
-    // Dumps to some very clean YAML.  We'll have to add some more features
-    // and options soon.  And better support for folding.
-
-    // New features and options.
-    if ($indent === false or !is_numeric($indent)) {
-      $this->_dumpIndent = 2;
-    } else {
-      $this->_dumpIndent = $indent;
-    }
-
-    if ($wordwrap === false or !is_numeric($wordwrap)) {
-      $this->_dumpWordWrap = 40;
-    } else {
-      $this->_dumpWordWrap = $wordwrap;
-    }
-
-    // New YAML document
-    $string = "---\n";
-
-    // Start at the base of the array and move through it.
-    if ($array) {
-      $array = (array)$array;
-      $previous_key = -1;
-      foreach ($array as $key => $value) {
-        if (!isset($first_key)) $first_key = $key;
-        $string .= $this->_yamlize($key,$value,0,$previous_key, $first_key, $array);
-        $previous_key = $key;
-      }
-    }
-    return $string;
-  }
-
-  /**
-     * Attempts to convert a key / value array item to YAML
-     * @access private
-     * @return string
-     * @param $key The name of the key
-     * @param $value The value of the item
-     * @param $indent The indent of the current node
-     */
-  private function _yamlize($key,$value,$indent, $previous_key = -1, $first_key = 0, $source_array = null) {
-    if (is_array($value)) {
-      if (empty ($value))
-        return $this->_dumpNode($key, array(), $indent, $previous_key, $first_key, $source_array);
-      // It has children.  What to do?
-      // Make it the right kind of item
-      $string = $this->_dumpNode($key, self::REMPTY, $indent, $previous_key, $first_key, $source_array);
-      // Add the indent
-      $indent += $this->_dumpIndent;
-      // Yamlize the array
-      $string .= $this->_yamlizeArray($value,$indent);
-    } elseif (!is_array($value)) {
-      // It doesn't have children.  Yip.
-      $string = $this->_dumpNode($key, $value, $indent, $previous_key, $first_key, $source_array);
-    }
-    return $string;
-  }
-
-  /**
-     * Attempts to convert an array to YAML
-     * @access private
-     * @return string
-     * @param $array The array you want to convert
-     * @param $indent The indent of the current level
-     */
-  private function _yamlizeArray($array,$indent) {
-    if (is_array($array)) {
-      $string = '';
-      $previous_key = -1;
-      foreach ($array as $key => $value) {
-        if (!isset($first_key)) $first_key = $key;
-        $string .= $this->_yamlize($key, $value, $indent, $previous_key, $first_key, $array);
-        $previous_key = $key;
-      }
-      return $string;
-    } else {
-      return false;
-    }
-  }
-
-  /**
-     * Returns YAML from a key and a value
-     * @access private
-     * @return string
-     * @param $key The name of the key
-     * @param $value The value of the item
-     * @param $indent The indent of the current node
-     */
-  private function _dumpNode($key, $value, $indent, $previous_key = -1, $first_key = 0, $source_array = null) {
-    // do some folding here, for blocks
-    if (is_string ($value) && ((strpos($value,"\n") !== false || strpos($value,": ") !== false || strpos($value,"- ") !== false ||
-      strpos($value,"*") !== false || strpos($value,"#") !== false || strpos($value,"<") !== false || strpos($value,">") !== false || strpos ($value, '  ') !== false ||
-      strpos($value,"[") !== false || strpos($value,"]") !== false || strpos($value,"{") !== false || strpos($value,"}") !== false) || strpos($value,"&") !== false || strpos($value, "'") !== false || strpos($value, "!") === 0 ||
-      substr ($value, -1, 1) == ':')
-    ) {
-      $value = $this->_doLiteralBlock($value,$indent);
-    } else {
-      $value  = $this->_doFolding($value,$indent);
-    }
-
-    if ($value === array()) $value = '[ ]';
-    if (in_array ($value, array ('true', 'TRUE', 'false', 'FALSE', 'y', 'Y', 'n', 'N', 'null', 'NULL'), true)) {
-       $value = $this->_doLiteralBlock($value,$indent);
-    }
-    if (trim ($value) != $value)
-       $value = $this->_doLiteralBlock($value,$indent);
-
-    if (is_bool($value)) {
-       $value = ($value) ? "true" : "false";
-    }
-
-    if ($value === null) $value = 'null';
-    if ($value === "'" . self::REMPTY . "'") $value = null;
-
-    $spaces = str_repeat(' ',$indent);
-
-    //if (is_int($key) && $key - 1 == $previous_key && $first_key===0) {
-    if (is_array ($source_array) && array_keys($source_array) === range(0, count($source_array) - 1)) {
-      // It's a sequence
-      $string = $spaces.'- '.$value."\n";
-    } else {
-      // if ($first_key===0)  throw new Exception('Keys are all screwy.  The first one was zero, now it\'s "'. $key .'"');
-      // It's mapped
-      if (strpos($key, ":") !== false || strpos($key, "#") !== false) { $key = '"' . $key . '"'; }
-      $string = rtrim ($spaces.$key.': '.$value)."\n";
-    }
-    return $string;
-  }
-
-  /**
-     * Creates a literal block for dumping
-     * @access private
-     * @return string
-     * @param $value
-     * @param $indent int The value of the indent
-     */
-  private function _doLiteralBlock($value,$indent) {
-    if ($value === "\n") return '\n';
-    if (strpos($value, "\n") === false && strpos($value, "'") === false) {
-      return sprintf ("'%s'", $value);
-    }
-    if (strpos($value, "\n") === false && strpos($value, '"') === false) {
-      return sprintf ('"%s"', $value);
-    }
-    $exploded = explode("\n",$value);
-    $newValue = '|';
-    $indent  += $this->_dumpIndent;
-    $spaces   = str_repeat(' ',$indent);
-    foreach ($exploded as $line) {
-      $newValue .= "\n" . $spaces . ($line);
-    }
-    return $newValue;
-  }
-
-  /**
-     * Folds a string of text, if necessary
-     * @access private
-     * @return string
-     * @param $value The string you wish to fold
-     */
-  private function _doFolding($value,$indent) {
-    // Don't do anything if wordwrap is set to 0
-
-    if ($this->_dumpWordWrap !== 0 && is_string ($value) && strlen($value) > $this->_dumpWordWrap) {
-      $indent += $this->_dumpIndent;
-      $indent = str_repeat(' ',$indent);
-      $wrapped = wordwrap($value,$this->_dumpWordWrap,"\n$indent");
-      $value   = ">\n".$indent.$wrapped;
-    } else {
-      if ($this->setting_dump_force_quotes && is_string ($value) && $value !== self::REMPTY)
-        $value = '"' . $value . '"';
-    }
-
-
-    return $value;
-  }
-
-// LOADING FUNCTIONS
-
-  private function __load($input) {
-    $Source = $this->loadFromSource($input);
-    return $this->loadWithSource($Source);
-  }
-
-  private function __loadString($input) {
-    $Source = $this->loadFromString($input);
-    return $this->loadWithSource($Source);
-  }
-
-  private function loadWithSource($Source) {
-    if (empty ($Source)) return array();
-    if ($this->setting_use_syck_is_possible && function_exists ('syck_load')) {
-      $array = syck_load (implode ('', $Source));
-      return is_array($array) ? $array : array();
-    }
-
-    $this->path = array();
-    $this->result = array();
-
-    $cnt = count($Source);
-    for ($i = 0; $i < $cnt; $i++) {
-      $line = $Source[$i];
-
-      $this->indent = strlen($line) - strlen(ltrim($line));
-      $tempPath = $this->getParentPathByIndent($this->indent);
-      $line = self::stripIndent($line, $this->indent);
-      if (self::isComment($line)) continue;
-      if (self::isEmpty($line)) continue;
-      $this->path = $tempPath;
-
-      $literalBlockStyle = self::startsLiteralBlock($line);
-      if ($literalBlockStyle) {
-        $line = rtrim ($line, $literalBlockStyle . " \n");
-        $literalBlock = '';
-        $line .= $this->LiteralPlaceHolder;
-        $literal_block_indent = strlen($Source[$i+1]) - strlen(ltrim($Source[$i+1]));
-        while (++$i < $cnt && $this->literalBlockContinues($Source[$i], $this->indent)) {
-          $literalBlock = $this->addLiteralLine($literalBlock, $Source[$i], $literalBlockStyle, $literal_block_indent);
-        }
-        $i--;
-      }
-
-      while (++$i < $cnt && self::greedilyNeedNextLine($line)) {
-        $line = rtrim ($line, " \n\t\r") . ' ' . ltrim ($Source[$i], " \t");
-      }
-      $i--;
-
-
-
-      if (strpos ($line, '#')) {
-        if (strpos ($line, '"') === false && strpos ($line, "'") === false)
-          $line = preg_replace('/\s+#(.+)$/','',$line);
-      }
-
-      $lineArray = $this->_parseLine($line);
-
-      if ($literalBlockStyle)
-        $lineArray = $this->revertLiteralPlaceHolder ($lineArray, $literalBlock);
-
-      $this->addArray($lineArray, $this->indent);
-
-      foreach ($this->delayedPath as $indent => $delayedPath)
-        $this->path[$indent] = $delayedPath;
-
-      $this->delayedPath = array();
-
-    }
-    return $this->result;
-  }
-
-  private function loadFromSource ($input) {
-    if (!empty($input) && strpos($input, "\n") === false && file_exists($input))
-    return file($input);
-
-    return $this->loadFromString($input);
-  }
-
-  private function loadFromString ($input) {
-    $lines = explode("\n",$input);
-    foreach ($lines as $k => $_) {
-      $lines[$k] = rtrim ($_, "\r");
-    }
-    return $lines;
-  }
-
-  /**
-     * Parses YAML code and returns an array for a node
-     * @access private
-     * @return array
-     * @param string $line A line from the YAML file
-     */
-  private function _parseLine($line) {
-    if (!$line) return array();
-    $line = trim($line);
-    if (!$line) return array();
-
-    $array = array();
-
-    $group = $this->nodeContainsGroup($line);
-    if ($group) {
-      $this->addGroup($line, $group);
-      $line = $this->stripGroup ($line, $group);
-    }
-
-    if ($this->startsMappedSequence($line))
-      return $this->returnMappedSequence($line);
-
-    if ($this->startsMappedValue($line))
-      return $this->returnMappedValue($line);
-
-    if ($this->isArrayElement($line))
-     return $this->returnArrayElement($line);
-
-    if ($this->isPlainArray($line))
-     return $this->returnPlainArray($line);
-
-
-    return $this->returnKeyValuePair($line);
-
-  }
-
-  /**
-     * Finds the type of the passed value, returns the value as the new type.
-     * @access private
-     * @param string $value
-     * @return mixed
-     */
-  private function _toType($value) {
-    if ($value === '') return null;
-    $first_character = $value[0];
-    $last_character = substr($value, -1, 1);
-
-    $is_quoted = false;
-    do {
-      if (!$value) break;
-      if ($first_character != '"' && $first_character != "'") break;
-      if ($last_character != '"' && $last_character != "'") break;
-      $is_quoted = true;
-    } while (0);
-
-    if ($is_quoted)
-      return strtr(substr ($value, 1, -1), array ('\\"' => '"', '\'\'' => '\'', '\\\'' => '\''));
-
-    if (strpos($value, ' #') !== false && !$is_quoted)
-      $value = preg_replace('/\s+#(.+)$/','',$value);
-
-    if (!$is_quoted) $value = str_replace('\n', "\n", $value);
-
-    if ($first_character == '[' && $last_character == ']') {
-      // Take out strings sequences and mappings
-      $innerValue = trim(substr ($value, 1, -1));
-      if ($innerValue === '') return array();
-      $explode = $this->_inlineEscape($innerValue);
-      // Propagate value array
-      $value  = array();
-      foreach ($explode as $v) {
-        $value[] = $this->_toType($v);
-      }
-      return $value;
-    }
-
-    if (strpos($value,': ')!==false && $first_character != '{') {
-      $array = explode(': ',$value);
-      $key   = trim($array[0]);
-      array_shift($array);
-      $value = trim(implode(': ',$array));
-      $value = $this->_toType($value);
-      return array($key => $value);
-    }
-
-    if ($first_character == '{' && $last_character == '}') {
-      $innerValue = trim(substr ($value, 1, -1));
-      if ($innerValue === '') return array();
-      // Inline Mapping
-      // Take out strings sequences and mappings
-      $explode = $this->_inlineEscape($innerValue);
-      // Propagate value array
-      $array = array();
-      foreach ($explode as $v) {
-        $SubArr = $this->_toType($v);
-        if (empty($SubArr)) continue;
-        if (is_array ($SubArr)) {
-          $array[key($SubArr)] = $SubArr[key($SubArr)]; continue;
-        }
-        $array[] = $SubArr;
-      }
-      return $array;
-    }
-
-    if ($value == 'null' || $value == 'NULL' || $value == 'Null' || $value == '' || $value == '~') {
-      return null;
-    }
-
-    if ( is_numeric($value) && preg_match ('/^(-|)[1-9]+[0-9]*$/', $value) ){
-      $intvalue = (int)$value;
-      if ($intvalue != PHP_INT_MAX)
-        $value = $intvalue;
-      return $value;
-    }
-
-    if (in_array($value,
-                 array('true', 'on', '+', 'yes', 'y', 'True', 'TRUE', 'On', 'ON', 'YES', 'Yes', 'Y'))) {
-      return true;
-    }
-
-    if (in_array(strtolower($value),
-                 array('false', 'off', '-', 'no', 'n'))) {
-      return false;
-    }
-
-    if (is_numeric($value)) {
-      if ($value === '0') return 0;
-      if (rtrim ($value, 0) === $value)
-        $value = (float)$value;
-      return $value;
-    }
-
-    return $value;
-  }
-
-  /**
-     * Used in inlines to check for more inlines or quoted strings
-     * @access private
-     * @return array
-     */
-  private function _inlineEscape($inline) {
-    // There's gotta be a cleaner way to do this...
-    // While pure sequences seem to be nesting just fine,
-    // pure mappings and mappings with sequences inside can't go very
-    // deep.  This needs to be fixed.
-
-    $seqs = array();
-    $maps = array();
-    $saved_strings = array();
-
-    // Check for strings
-    $regex = '/(?:(")|(?:\'))((?(1)[^"]+|[^\']+))(?(1)"|\')/';
-    if (preg_match_all($regex,$inline,$strings)) {
-      $saved_strings = $strings[0];
-      $inline  = preg_replace($regex,'YAMLString',$inline);
-    }
-    unset($regex);
-
-    $i = 0;
-    do {
-
-    // Check for sequences
-    while (preg_match('/\[([^{}\[\]]+)\]/U',$inline,$matchseqs)) {
-      $seqs[] = $matchseqs[0];
-      $inline = preg_replace('/\[([^{}\[\]]+)\]/U', ('YAMLSeq' . (count($seqs) - 1) . 's'), $inline, 1);
-    }
-
-    // Check for mappings
-    while (preg_match('/{([^\[\]{}]+)}/U',$inline,$matchmaps)) {
-      $maps[] = $matchmaps[0];
-      $inline = preg_replace('/{([^\[\]{}]+)}/U', ('YAMLMap' . (count($maps) - 1) . 's'), $inline, 1);
-    }
-
-    if ($i++ >= 10) break;
-
-    } while (strpos ($inline, '[') !== false || strpos ($inline, '{') !== false);
-
-    $explode = explode(', ',$inline);
-    $stringi = 0; $i = 0;
-
-    while (1) {
-
-    // Re-add the sequences
-    if (!empty($seqs)) {
-      foreach ($explode as $key => $value) {
-        if (strpos($value,'YAMLSeq') !== false) {
-          foreach ($seqs as $seqk => $seq) {
-            $explode[$key] = str_replace(('YAMLSeq'.$seqk.'s'),$seq,$value);
-            $value = $explode[$key];
-          }
-        }
-      }
-    }
-
-    // Re-add the mappings
-    if (!empty($maps)) {
-      foreach ($explode as $key => $value) {
-        if (strpos($value,'YAMLMap') !== false) {
-          foreach ($maps as $mapk => $map) {
-            $explode[$key] = str_replace(('YAMLMap'.$mapk.'s'), $map, $value);
-            $value = $explode[$key];
-          }
-        }
-      }
-    }
-
-
-    // Re-add the strings
-    if (!empty($saved_strings)) {
-      foreach ($explode as $key => $value) {
-        while (strpos($value,'YAMLString') !== false) {
-          $explode[$key] = preg_replace('/YAMLString/',$saved_strings[$stringi],$value, 1);
-          unset($saved_strings[$stringi]);
-          ++$stringi;
-          $value = $explode[$key];
-        }
-      }
-    }
-
-    $finished = true;
-    foreach ($explode as $key => $value) {
-      if (strpos($value,'YAMLSeq') !== false) {
-        $finished = false; break;
-      }
-      if (strpos($value,'YAMLMap') !== false) {
-        $finished = false; break;
-      }
-      if (strpos($value,'YAMLString') !== false) {
-        $finished = false; break;
-      }
-    }
-    if ($finished) break;
-
-    $i++;
-    if ($i > 10)
-      break; // Prevent infinite loops.
-    }
-
-    return $explode;
-  }
-
-  private function literalBlockContinues ($line, $lineIndent) {
-    if (!trim($line)) return true;
-    if (strlen($line) - strlen(ltrim($line)) > $lineIndent) return true;
-    return false;
-  }
-
-  private function referenceContentsByAlias ($alias) {
-    do {
-      if (!isset($this->SavedGroups[$alias])) { echo "Bad group name: $alias."; break; }
-      $groupPath = $this->SavedGroups[$alias];
-      $value = $this->result;
-      foreach ($groupPath as $k) {
-        $value = $value[$k];
-      }
-    } while (false);
-    return $value;
-  }
-
-  private function addArrayInline ($array, $indent) {
-      $CommonGroupPath = $this->path;
-      if (empty ($array)) return false;
-
-      foreach ($array as $k => $_) {
-        $this->addArray(array($k => $_), $indent);
-        $this->path = $CommonGroupPath;
-      }
-      return true;
-  }
-
-  private function addArray ($incoming_data, $incoming_indent) {
-
-   // print_r ($incoming_data);
-
-    if (count ($incoming_data) > 1)
-      return $this->addArrayInline ($incoming_data, $incoming_indent);
-
-    $key = key ($incoming_data);
-    $value = isset($incoming_data[$key]) ? $incoming_data[$key] : null;
-    if ($key === '__!YAMLZero') $key = '0';
-
-    if ($incoming_indent == 0 && !$this->_containsGroupAlias && !$this->_containsGroupAnchor) { // Shortcut for root-level values.
-      if ($key || $key === '' || $key === '0') {
-        $this->result[$key] = $value;
-      } else {
-        $this->result[] = $value; end ($this->result); $key = key ($this->result);
-      }
-      $this->path[$incoming_indent] = $key;
-      return;
-    }
-
-
-
-    $history = array();
-    // Unfolding inner array tree.
-    $history[] = $_arr = $this->result;
-    foreach ($this->path as $k) {
-      $history[] = $_arr = $_arr[$k];
-    }
-
-    if ($this->_containsGroupAlias) {
-      $value = $this->referenceContentsByAlias($this->_containsGroupAlias);
-      $this->_containsGroupAlias = false;
-    }
-
-
-    // Adding string or numeric key to the innermost level or $this->arr.
-    if (is_string($key) && $key == '<<') {
-      if (!is_array ($_arr)) { $_arr = array (); }
-
-      $_arr = array_merge ($_arr, $value);
-    } else if ($key || $key === '' || $key === '0') {
-      if (!is_array ($_arr))
-        $_arr = array ($key=>$value);
-      else
-        $_arr[$key] = $value;
-    } else {
-      if (!is_array ($_arr)) { $_arr = array ($value); $key = 0; }
-      else { $_arr[] = $value; end ($_arr); $key = key ($_arr); }
-    }
-
-    $reverse_path = array_reverse($this->path);
-    $reverse_history = array_reverse ($history);
-    $reverse_history[0] = $_arr;
-    $cnt = count($reverse_history) - 1;
-    for ($i = 0; $i < $cnt; $i++) {
-      $reverse_history[$i+1][$reverse_path[$i]] = $reverse_history[$i];
-    }
-    $this->result = $reverse_history[$cnt];
-
-    $this->path[$incoming_indent] = $key;
-
-    if ($this->_containsGroupAnchor) {
-      $this->SavedGroups[$this->_containsGroupAnchor] = $this->path;
-      if (is_array ($value)) {
-        $k = key ($value);
-        if (!is_int ($k)) {
-          $this->SavedGroups[$this->_containsGroupAnchor][$incoming_indent + 2] = $k;
-        }
-      }
-      $this->_containsGroupAnchor = false;
-    }
-
-  }
-
-  private static function startsLiteralBlock ($line) {
-    $lastChar = substr (trim($line), -1);
-    if ($lastChar != '>' && $lastChar != '|') return false;
-    if ($lastChar == '|') return $lastChar;
-    // HTML tags should not be counted as literal blocks.
-    if (preg_match ('#<.*?>$#', $line)) return false;
-    return $lastChar;
-  }
-
-  private static function greedilyNeedNextLine($line) {
-    $line = trim ($line);
-    if (!strlen($line)) return false;
-    if (substr ($line, -1, 1) == ']') return false;
-    if ($line[0] == '[') return true;
-    if (preg_match ('#^[^:]+?:\s*\[#', $line)) return true;
-    return false;
-  }
-
-  private function addLiteralLine ($literalBlock, $line, $literalBlockStyle, $indent = -1) {
-    $line = self::stripIndent($line, $indent);
-    if ($literalBlockStyle !== '|') {
-        $line = self::stripIndent($line);
-    }
-    $line = rtrim ($line, "\r\n\t ") . "\n";
-    if ($literalBlockStyle == '|') {
-      return $literalBlock . $line;
-    }
-    if (strlen($line) == 0)
-      return rtrim($literalBlock, ' ') . "\n";
-    if ($line == "\n" && $literalBlockStyle == '>') {
-      return rtrim ($literalBlock, " \t") . "\n";
-    }
-    if ($line != "\n")
-      $line = trim ($line, "\r\n ") . " ";
-    return $literalBlock . $line;
-  }
-
-   function revertLiteralPlaceHolder ($lineArray, $literalBlock) {
-     foreach ($lineArray as $k => $_) {
-      if (is_array($_))
-        $lineArray[$k] = $this->revertLiteralPlaceHolder ($_, $literalBlock);
-      else if (substr($_, -1 * strlen ($this->LiteralPlaceHolder)) == $this->LiteralPlaceHolder)
-	       $lineArray[$k] = rtrim ($literalBlock, " \r\n");
-     }
-     return $lineArray;
-   }
-
-  private static function stripIndent ($line, $indent = -1) {
-    if ($indent == -1) $indent = strlen($line) - strlen(ltrim($line));
-    return substr ($line, $indent);
-  }
-
-  private function getParentPathByIndent ($indent) {
-    if ($indent == 0) return array();
-    $linePath = $this->path;
-    do {
-      end($linePath); $lastIndentInParentPath = key($linePath);
-      if ($indent <= $lastIndentInParentPath) array_pop ($linePath);
-    } while ($indent <= $lastIndentInParentPath);
-    return $linePath;
-  }
-
-
-  private function clearBiggerPathValues ($indent) {
-
-
-    if ($indent == 0) $this->path = array();
-    if (empty ($this->path)) return true;
-
-    foreach ($this->path as $k => $_) {
-      if ($k > $indent) unset ($this->path[$k]);
-    }
-
-    return true;
-  }
-
-
-  private static function isComment ($line) {
-    if (!$line) return false;
-    if ($line[0] == '#') return true;
-    if (trim($line, " \r\n\t") == '---') return true;
-    return false;
-  }
-
-  private static function isEmpty ($line) {
-    return (trim ($line) === '');
-  }
-
-
-  private function isArrayElement ($line) {
-    if (!$line) return false;
-    if ($line[0] != '-') return false;
-    if (strlen ($line) > 3)
-      if (substr($line,0,3) == '---') return false;
-
-    return true;
-  }
-
-  private function isHashElement ($line) {
-    return strpos($line, ':');
-  }
-
-  private function isLiteral ($line) {
-    if ($this->isArrayElement($line)) return false;
-    if ($this->isHashElement($line)) return false;
-    return true;
-  }
-
-
-  private static function unquote ($value) {
-    if (!$value) return $value;
-    if (!is_string($value)) return $value;
-    if ($value[0] == '\'') return trim ($value, '\'');
-    if ($value[0] == '"') return trim ($value, '"');
-    return $value;
-  }
-
-  private function startsMappedSequence ($line) {
-    return ($line[0] == '-' && substr ($line, -1, 1) == ':');
-  }
-
-  private function returnMappedSequence ($line) {
-    $array = array();
-    $key         = self::unquote(trim(substr($line,1,-1)));
-    $array[$key] = array();
-    $this->delayedPath = array(strpos ($line, $key) + $this->indent => $key);
-    return array($array);
-  }
-
-  private function returnMappedValue ($line) {
-    $array = array();
-    $key         = self::unquote (trim(substr($line,0,-1)));
-    $array[$key] = '';
-    return $array;
-  }
-
-  private function startsMappedValue ($line) {
-    return (substr ($line, -1, 1) == ':');
-  }
-
-  private function isPlainArray ($line) {
-    return ($line[0] == '[' && substr ($line, -1, 1) == ']');
-  }
-
-  private function returnPlainArray ($line) {
-    return $this->_toType($line);
-  }
-
-  private function returnKeyValuePair ($line) {
-    $array = array();
-    $key = '';
-    if (strpos ($line, ':')) {
-      // It's a key/value pair most likely
-      // If the key is in double quotes pull it out
-      if (($line[0] == '"' || $line[0] == "'") && preg_match('/^(["\'](.*)["\'](\s)*:)/',$line,$matches)) {
-        $value = trim(str_replace($matches[1],'',$line));
-        $key   = $matches[2];
-      } else {
-        // Do some guesswork as to the key and the value
-        $explode = explode(':',$line);
-        $key     = trim($explode[0]);
-        array_shift($explode);
-        $value   = trim(implode(':',$explode));
-      }
-      // Set the type of the value.  Int, string, etc
-      $value = $this->_toType($value);
-      if ($key === '0') $key = '__!YAMLZero';
-      $array[$key] = $value;
-    } else {
-      $array = array ($line);
-    }
-    return $array;
-
-  }
-
-
-  private function returnArrayElement ($line) {
-     if (strlen($line) <= 1) return array(array()); // Weird %)
-     $array = array();
-     $value   = trim(substr($line,1));
-     $value   = $this->_toType($value);
-     $array[] = $value;
-     return $array;
-  }
-
-
-  private function nodeContainsGroup ($line) {
-    $symbolsForReference = 'A-z0-9_\-';
-    if (strpos($line, '&') === false && strpos($line, '*') === false) return false; // Please die fast ;-)
-    if ($line[0] == '&' && preg_match('/^(&['.$symbolsForReference.']+)/', $line, $matches)) return $matches[1];
-    if ($line[0] == '*' && preg_match('/^(\*['.$symbolsForReference.']+)/', $line, $matches)) return $matches[1];
-    if (preg_match('/(&['.$symbolsForReference.']+)$/', $line, $matches)) return $matches[1];
-    if (preg_match('/(\*['.$symbolsForReference.']+$)/', $line, $matches)) return $matches[1];
-    if (preg_match ('#^\s*<<\s*:\s*(\*[^\s]+).*$#', $line, $matches)) return $matches[1];
-    return false;
-
-  }
-
-  private function addGroup ($line, $group) {
-    if ($group[0] == '&') $this->_containsGroupAnchor = substr ($group, 1);
-    if ($group[0] == '*') $this->_containsGroupAlias = substr ($group, 1);
-    //print_r ($this->path);
-  }
-
-  private function stripGroup ($line, $group) {
-    $line = trim(str_replace($group, '', $line));
-    return $line;
-  }
-}
-
-// Enable use of Spyc from command line
-// The syntax is the following: php spyc.php spyc.yaml
-
-define ('SPYC_FROM_COMMAND_LINE', false);
-
-do {
-  if (!SPYC_FROM_COMMAND_LINE) break;
-  if (empty ($_SERVER['argc']) || $_SERVER['argc'] < 2) break;
-  if (empty ($_SERVER['PHP_SELF']) || $_SERVER['PHP_SELF'] != 'spyc.php') break;
-  $file = $argv[1];
-  printf ("Spyc loading file: %s\n", $file);
-  print_r (spyc_load_file ($file));
-} while (0);
\ No newline at end of file
diff --git a/src/spyc/spyc.yaml b/src/spyc/spyc.yaml
deleted file mode 100644
index 930149e..0000000
--- a/src/spyc/spyc.yaml
+++ /dev/null
@@ -1,203 +0,0 @@
-#
-#    S P Y C
-#      a simple php yaml class
-#
-# authors: [vlad andersen (vlad.andersen@gmail.com), chris wanstrath (chris@ozmm.org)]
-# websites: [http://www.yaml.org, http://spyc.sourceforge.net/]
-# license: [MIT License, http://www.opensource.org/licenses/mit-license.php]
-# copyright: (c) 2005-2006 Chris Wanstrath, 2006-2011 Vlad Andersen
-#
-# spyc.yml - A file containing the YAML that Spyc understands.
-
----
-
-# Mappings - with proper types
-String: Anyone's name, really.
-Int: 13
-True: true
-False: false
-Zero: 0
-Null: NULL
-NotNull: 'null'
-NotTrue: 'y'
-NotBoolTrue: 'true'
-NotInt: '5'
-Float: 5.34
-Negative: -90
-SmallFloat: 0.7
-NewLine: \n
-
-# A sequence
-- PHP Class
-- Basic YAML Loader
-- Very Basic YAML Dumper
-
-# A sequence of a sequence
--
-  - YAML is so easy to learn.
-  - Your config files will never be the same.
-
-# Sequence of mappings
--
-  cpu: 1.5ghz
-  ram: 1 gig
-  os : os x 10.4.1
-
-# Mapped sequence
-domains:
-  - yaml.org
-  - php.net
-
-# A sequence like this.
-- program: Adium
-  platform: OS X
-  type: Chat Client
-
-# A folded block as a mapped value
-no time: >
-  There isn't any time
-  for your tricks!
-
-  Do you understand?
-
-# A literal block as a mapped value
-some time: |
-  There is nothing but time
-  for your tricks.
-
-# Crazy combinations
-databases:
-  - name: spartan
-    notes:
-      - Needs to be backed up
-      - Needs to be normalized
-    type: mysql
-
-# You can be a bit tricky
-"if: you'd": like
-
-# Inline sequences
-- [One, Two, Three, Four]
-
-# Nested Inline Sequences
-- [One, [Two, And, Three], Four, Five]
-
-# Nested Nested Inline Sequences
-- [This, [Is, Getting, [Ridiculous, Guys]], Seriously, [Show, Mercy]]
-
-# Inline mappings
-- {name: chris, age: young, brand: lucky strike}
-
-# Nested inline mappings
-- {name: mark, age: older than chris, brand: [marlboro, lucky strike]}
-
-# References -- they're shaky, but functional
-dynamic languages: &DLANGS
-  - Perl
-  - Python
-  - PHP
-  - Ruby
-compiled languages: &CLANGS
-  - C/C++
-  - Java
-all languages:
-  - *DLANGS
-  - *CLANGS
-
-# Added in .2.2: Escaped quotes
-- you know, this shouldn't work.  but it does.
-- 'that''s my value.'
-- 'again, that\'s my value.'
-- "here's to \"quotes\", boss."
-
-# added in .2.3
-- {name: "Foo, Bar's", age: 20}
-
-# Added in .2.4: bug [ 1418193 ] Quote Values in Nested Arrays
-- [a, ['1', "2"], b]
-
-# Added in .2.4: malformed YAML
-all
-  javascripts:     [dom1.js, dom.js]
-
-# Added in .2
-1040: Ooo, a numeric key! # And working comments? Wow! Colons in comments: a menace (0.3).
-
-hash_1: Hash #and a comment
-hash_2: "Hash #and a comment"
-"hash#3": "Hash (#) can appear in key too"
-
-float_test: 1.0
-float_test_with_quotes: '1.0'
-float_inverse_test: 001
-
-a_really_large_number: 115792089237316195423570985008687907853269984665640564039457584007913129639936 # 2^256
-
-int array: [ 1, 2, 3 ]
-
-array on several lines:
-  [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
-    10, 11, 12, 13, 14, 15, 16, 17, 18, 19 ]
-
-morelesskey: "<value>"
-
-array_of_zero: [0]
-sophisticated_array_of_zero: {rx: {tx: [0]} }
-
-switches:
-  - { row: 0, col: 0, func: {tx: [0, 1]} }
-
-empty_sequence: [ ]
-empty_hash: { }
-
-special_characters: "[{]]{{]]"
-
-asterisks: "*"
-
-empty_key:
-  :
-    key: value
-
-trailing_colon: "foo:"
-
-multiline_items:
-  - type: SomeItem
-    values: [blah, blah, blah,
-      blah]
-    ints: [2, 54, 12,
-      2143]
-
-many_lines: |
-  A quick
-  fox
-
-
-  jumped
-  over
-
-
-
-
-
-  a lazy
-
-
-
-  dog
-
-
-werte:
-  1: nummer 1
-  0: Stunde 0
-
-noindent_records:
-- record1: value1
-- record2: value2
-
-"a:1": [1000]
-"a:2":
-  - 2000
-
-# [Endloop]
-endloop: |
-  Does this line in the end indeed make Spyc go to an infinite loop?
\ No newline at end of file
diff --git a/src/spyc/tests/DumpTest.php b/src/spyc/tests/DumpTest.php
deleted file mode 100644
index 0b9e5fa..0000000
--- a/src/spyc/tests/DumpTest.php
+++ /dev/null
@@ -1,130 +0,0 @@
-<?php
-
-require_once ("../spyc.php");
-
-class DumpTest extends PHPUnit_Framework_TestCase {
-
-    private $files_to_test = array();
-
-    public function setUp() {
-      $this->files_to_test = array ('../spyc.yaml', 'failing1.yaml', 'indent_1.yaml', 'quotes.yaml');
-    }
-
-    public function testDump() {
-      foreach ($this->files_to_test as $file) {
-        $yaml = spyc_load(file_get_contents($file));
-        $dump = Spyc::YAMLDump ($yaml);
-        $yaml_after_dump = Spyc::YAMLLoad ($dump);
-        $this->assertEquals ($yaml, $yaml_after_dump);
-      }
-    }
-
-    public function testDumpWithQuotes() {
-      $Spyc = new Spyc();
-      $Spyc->setting_dump_force_quotes = true;
-      foreach ($this->files_to_test as $file) {
-        $yaml = $Spyc->load(file_get_contents($file));
-        $dump = $Spyc->dump ($yaml);
-        $yaml_after_dump = Spyc::YAMLLoad ($dump);
-        $this->assertEquals ($yaml, $yaml_after_dump);
-      }
-    }
-
-    public function testDumpArrays() {
-      $dump = Spyc::YAMLDump(array ('item1', 'item2', 'item3'));
-      $awaiting = "---\n- item1\n- item2\n- item3\n";
-      $this->assertEquals ($awaiting, $dump);
-    }
-    
-    public function testNull() {
-        $dump = Spyc::YAMLDump(array('a' => 1, 'b' => null, 'c' => 3));
-        $awaiting = "---\na: 1\nb: null\nc: 3\n";
-        $this->assertEquals ($awaiting, $dump);
-    }
-    
-    public function testNext() {
-        $array = array("aaa", "bbb", "ccc");
-        #set arrays internal pointer to next element
-        next($array);
-        $dump = Spyc::YAMLDump($array);        
-        $awaiting = "---\n- aaa\n- bbb\n- ccc\n";
-        $this->assertEquals ($awaiting, $dump);        
-    }
-    
-    public function testDumpingMixedArrays() {
-        $array = array();
-        $array[] = 'Sequence item';
-        $array['The Key'] = 'Mapped value';
-        $array[] = array('A sequence','of a sequence');
-        $array[] = array('first' => 'A sequence','second' => 'of mapped values');
-        $array['Mapped'] = array('A sequence','which is mapped');
-        $array['A Note'] = 'What if your text is too long?';
-        $array['Another Note'] = 'If that is the case, the dumper will probably fold your text by using a block.  Kinda like this.';
-        $array['The trick?'] = 'The trick is that we overrode the default indent, 2, to 4 and the default wordwrap, 40, to 60.';
-        $array['Old Dog'] = "And if you want\n to preserve line breaks, \ngo ahead!";
-        $array['key:withcolon'] = "Should support this to";
-
-        $yaml = Spyc::YAMLDump($array,4,60);        
-    }
-    
-    public function testMixed() {
-        $dump = Spyc::YAMLDump(array(0 => 1, 'b' => 2, 1 => 3));
-        $awaiting = "---\n0: 1\nb: 2\n1: 3\n";
-        $this->assertEquals ($awaiting, $dump);
-    }    
-
-    public function testDumpNumerics() {
-      $dump = Spyc::YAMLDump(array ('404', '405', '500'));
-      $awaiting = "---\n- 404\n- 405\n- 500\n";
-      $this->assertEquals ($awaiting, $dump);
-    }
-
-    public function testDumpAsterisks() {
-      $dump = Spyc::YAMLDump(array ('*'));
-      $awaiting = "---\n- '*'\n";
-      $this->assertEquals ($awaiting, $dump);
-    }
-
-    public function testDumpAmpersands() {
-      $dump = Spyc::YAMLDump(array ('some' => '&foo'));
-      $awaiting = "---\nsome: '&foo'\n";
-      $this->assertEquals ($awaiting, $dump);
-    }
-    
-    public function testDumpExclamations() {
-      $dump = Spyc::YAMLDump(array ('some' => '!foo'));
-      $awaiting = "---\nsome: '!foo'\n";
-      $this->assertEquals ($awaiting, $dump);
-    }
-
-    public function testDumpExclamations2() {
-      $dump = Spyc::YAMLDump(array ('some' => 'foo!'));
-      $awaiting = "---\nsome: foo!\n";
-      $this->assertEquals ($awaiting, $dump);
-    }
-
-    public function testDumpApostrophes() {
-      $dump = Spyc::YAMLDump(array ('some' => "'Biz' pimpt bedrijventerreinen"));
-      $awaiting = "---\nsome: \"'Biz' pimpt bedrijventerreinen\"\n";
-      $this->assertEquals ($awaiting, $dump);
-    }
-
-    public function testDumpNumericHashes() {
-      $dump = Spyc::YAMLDump(array ("titel"=> array("0" => "", 1 => "Dr.", 5 => "Prof.", 6 => "Prof. Dr.")));
-      $awaiting = "---\ntitel:\n  0:\n  1: Dr.\n  5: Prof.\n  6: Prof. Dr.\n";
-      $this->assertEquals ($awaiting, $dump);
-    }
-
-    public function testEmpty() {
-      $dump = Spyc::YAMLDump(array("foo" => array()));
-      $awaiting = "---\nfoo: [ ]\n";
-      $this->assertEquals ($awaiting, $dump);
-    }
-
-    public function testHashesInKeys() {
-      $dump = Spyc::YAMLDump(array ('#color' => '#ffffff'));
-      $awaiting = "---\n\"#color\": '#ffffff'\n";
-      $this->assertEquals ($awaiting, $dump);
-    }
-
-}
\ No newline at end of file
diff --git a/src/spyc/tests/IndentTest.php b/src/spyc/tests/IndentTest.php
deleted file mode 100644
index 5b6dc86..0000000
--- a/src/spyc/tests/IndentTest.php
+++ /dev/null
@@ -1,65 +0,0 @@
-<?php
-
-require_once ("../spyc.php");
-
-class IndentTest extends PHPUnit_Framework_TestCase {
-
-    protected $Y;
-
-    protected function setUp() {
-      $this->Y = Spyc::YAMLLoad("indent_1.yaml");
-    }
-
-    public function testIndent_1() {
-      $this->assertEquals (array ('child_1' => 2, 'child_2' => 0, 'child_3' => 1), $this->Y['root']);
-    }
-
-    public function testIndent_2() {
-      $this->assertEquals (array ('child_1' => 1, 'child_2' => 2), $this->Y['root2']);
-    }
-
-    public function testIndent_3() {
-      $this->assertEquals (array (array ('resolutions' => array (1024 => 768, 1920 => 1200), 'producer' => 'Nec')), $this->Y['display']);
-    }
-
-    public function testIndent_4() {
-      $this->assertEquals (array (
-          array ('resolutions' => array (1024 => 768)),
-          array ('resolutions' => array (1920 => 1200)),
-        ), $this->Y['displays']);
-    }
-
-    public function testIndent_5() {
-      $this->assertEquals (array (array (
-        'row' => 0,
-        'col' => 0,
-        'headsets_affected' => array (
-            array (
-              'ports' => array (0),
-              'side' => 'left',
-            )
-        ),
-        'switch_function' => array (
-          'ics_ptt' => true
-        )
-      )), $this->Y['nested_hashes_and_seqs']);
-    }
-
-    public function testIndent_6() {
-      $this->assertEquals (array (
-        'h' => array (
-          array ('a' => 'b', 'a1' => 'b1'),
-          array ('c' => 'd')
-        )
-      ), $this->Y['easier_nest']);
-    }
-
-    public function testIndent_space() {
-      $this->assertEquals ("By four\n  spaces", $this->Y['one_space']);
-    }
-
-    public function testListAndComment() {
-      $this->assertEquals (array ('one', 'two', 'three'), $this->Y['list_and_comment']);
-    }
-
-}
\ No newline at end of file
diff --git a/src/spyc/tests/ParseTest.php b/src/spyc/tests/ParseTest.php
deleted file mode 100644
index f7045bd..0000000
--- a/src/spyc/tests/ParseTest.php
+++ /dev/null
@@ -1,322 +0,0 @@
-<?php
-
-require_once 'PHPUnit/Framework.php';
-require_once ("../spyc.php");
-
-class ParseTest extends PHPUnit_Framework_TestCase {
-
-    protected $yaml;
-
-    protected function setUp() {
-      $this->yaml = spyc_load_file('../spyc.yaml');
-    }
-
-    public function testMergeHashKeys() {
-      $Expected =  array (
-        array ('step' => array('instrument' => 'Lasik 2000', 'pulseEnergy' => 5.4, 'pulseDuration' => 12, 'repetition' => 1000, 'spotSize' => '1mm')),
-        array ('step' => array('instrument' => 'Lasik 2000', 'pulseEnergy' => 5.4, 'pulseDuration' => 12, 'repetition' => 1000, 'spotSize' => '2mm')),
-      );
-      $Actual = spyc_load_file ('indent_1.yaml');
-      $this->assertEquals ($Expected, $Actual['steps']);
-    }
-
-    public function testDeathMasks() {
-      $Expected = array ('sad' => 2, 'magnificent' => 4);
-      $Actual = spyc_load_file ('indent_1.yaml');
-      $this->assertEquals ($Expected, $Actual['death masks are']);
-    }
-
-    public function testDevDb() {
-      $Expected = array ('adapter' => 'mysql', 'host' => 'localhost', 'database' => 'rails_dev');
-      $Actual = spyc_load_file ('indent_1.yaml');
-      $this->assertEquals ($Expected, $Actual['development']);
-    }
-
-    public function testNumericKey() {
-      $this->assertEquals ("Ooo, a numeric key!", $this->yaml[1040]);
-    }
-
-    public function testMappingsString() {
-      $this->assertEquals ("Anyone's name, really.", $this->yaml['String']);
-    }
-
-    public function testMappingsInt() {
-      $this->assertSame (13, $this->yaml['Int']);
-    }
-
-    public function testMappingsBooleanTrue() {
-      $this->assertSame (true, $this->yaml['True']);
-    }
-
-    public function testMappingsBooleanFalse() {
-      $this->assertSame (false, $this->yaml['False']);
-    }
-
-    public function testMappingsZero() {
-      $this->assertSame (0, $this->yaml['Zero']);
-    }
-
-    public function testMappingsNull() {
-      $this->assertSame (null, $this->yaml['Null']);
-    }
-
-    public function testMappingsNotNull() {
-      $this->assertSame ('null', $this->yaml['NotNull']);
-    }
-
-    public function testMappingsFloat() {
-      $this->assertSame (5.34, $this->yaml['Float']);
-    }
-    
-    public function testMappingsNegative() {
-      $this->assertSame (-90, $this->yaml['Negative']);
-    }
-
-    public function testMappingsSmallFloat() {
-      $this->assertSame (0.7, $this->yaml['SmallFloat']);
-    }
-
-    public function testNewline() {
-      $this->assertSame ("\n", $this->yaml['NewLine']);
-    }
-
-
-    public function testSeq0() {
-      $this->assertEquals ("PHP Class", $this->yaml[0]);
-    }
-
-    public function testSeq1() {
-      $this->assertEquals ("Basic YAML Loader", $this->yaml[1]);
-    }
-
-    public function testSeq2() {
-      $this->assertEquals ("Very Basic YAML Dumper", $this->yaml[2]);
-    }
-
-    public function testSeq3() {
-      $this->assertEquals (array("YAML is so easy to learn.",
-											"Your config files will never be the same."), $this->yaml[3]);
-    }
-
-    public function testSeqMap() {
-      $this->assertEquals (array("cpu" => "1.5ghz", "ram" => "1 gig",
-											"os" => "os x 10.4.1"), $this->yaml[4]);
-    }
-
-    public function testMappedSequence() {
-      $this->assertEquals (array("yaml.org", "php.net"), $this->yaml['domains']);
-    }
-
-    public function testAnotherSequence() {
-      $this->assertEquals (array("program" => "Adium", "platform" => "OS X",
-											"type" => "Chat Client"), $this->yaml[5]);
-    }
-
-    public function testFoldedBlock() {
-      $this->assertEquals ("There isn't any time for your tricks!\nDo you understand?", $this->yaml['no time']);
-    }
-
-    public function testLiteralAsMapped() {
-      $this->assertEquals ("There is nothing but time\nfor your tricks.", $this->yaml['some time']);
-    }
-
-    public function testCrazy() {
-      $this->assertEquals (array( array("name" => "spartan", "notes" =>
-																			array( "Needs to be backed up",
-																						 "Needs to be normalized" ),
-																			 "type" => "mysql" )), $this->yaml['databases']);
-    }
-
-    public function testColons() {
-      $this->assertEquals ("like", $this->yaml["if: you'd"]);
-    }
-
-    public function testInline() {
-      $this->assertEquals (array("One", "Two", "Three", "Four"), $this->yaml[6]);
-    }
-
-    public function testNestedInline() {
-      $this->assertEquals (array("One", array("Two", "And", "Three"), "Four", "Five"), $this->yaml[7]);
-    }
-
-    public function testNestedNestedInline() {
-      $this->assertEquals (array( "This", array("Is", "Getting", array("Ridiculous", "Guys")),
-									"Seriously", array("Show", "Mercy")), $this->yaml[8]);
-    }
-
-    public function testInlineMappings() {
-      $this->assertEquals (array("name" => "chris", "age" => "young", "brand" => "lucky strike"), $this->yaml[9]);
-    }
-
-    public function testNestedInlineMappings() {
-      $this->assertEquals (array("name" => "mark", "age" => "older than chris",
-											 "brand" => array("marlboro", "lucky strike")), $this->yaml[10]);
-    }
-
-    public function testReferences() {
-      $this->assertEquals (array('Perl', 'Python', 'PHP', 'Ruby'), $this->yaml['dynamic languages']);
-    }
-
-    public function testReferences2() {
-      $this->assertEquals (array('C/C++', 'Java'), $this->yaml['compiled languages']);
-    }
-
-    public function testReferences3() {
-      $this->assertEquals (array(
-																		array('Perl', 'Python', 'PHP', 'Ruby'),
-																		array('C/C++', 'Java')
-																	 ), $this->yaml['all languages']);
-    }
-
-    public function testEscapedQuotes() {
-      $this->assertEquals ("you know, this shouldn't work.  but it does.", $this->yaml[11]);
-    }
-
-    public function testEscapedQuotes_2() {
-      $this->assertEquals ( "that's my value.", $this->yaml[12]);
-    }
-
-    public function testEscapedQuotes_3() {
-      $this->assertEquals ("again, that's my value.", $this->yaml[13]);
-    }
-
-    public function testQuotes() {
-      $this->assertEquals ("here's to \"quotes\", boss.", $this->yaml[14]);
-    }
-
-    public function testQuoteSequence() {
-      $this->assertEquals ( array( 'name' => "Foo, Bar's", 'age' => 20), $this->yaml[15]);
-    }
-
-    public function testShortSequence() {
-      $this->assertEquals (array( 0 => "a", 1 => array (0 => 1, 1 => 2), 2 => "b"), $this->yaml[16]);
-    }
-
-    public function testHash_1() {
-      $this->assertEquals ("Hash", $this->yaml['hash_1']);
-    }
-
-    public function testHash_2() {
-      $this->assertEquals ('Hash #and a comment', $this->yaml['hash_2']);
-    }
-
-    public function testHash_3() {
-      $this->assertEquals ('Hash (#) can appear in key too', $this->yaml['hash#3']);
-    }
-
-    public function testEndloop() {
-      $this->assertEquals ("Does this line in the end indeed make Spyc go to an infinite loop?", $this->yaml['endloop']);
-    }
-
-    public function testReallyLargeNumber() {
-      $this->assertEquals ('115792089237316195423570985008687907853269984665640564039457584007913129639936', $this->yaml['a_really_large_number']);
-    }
-
-    public function testFloatWithZeros() {
-      $this->assertSame ('1.0', $this->yaml['float_test']);
-    }
-
-    public function testFloatWithQuotes() {
-      $this->assertSame ('1.0', $this->yaml['float_test_with_quotes']);
-    }
-
-    public function testFloatInverse() {
-      $this->assertEquals ('001', $this->yaml['float_inverse_test']);
-    }
-
-    public function testIntArray() {
-      $this->assertEquals (array (1, 2, 3), $this->yaml['int array']);
-    }
-
-    public function testArrayOnSeveralLines() {
-      $this->assertEquals (array (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19), $this->yaml['array on several lines']);
-    }
-
-    public function testmoreLessKey() {
-      $this->assertEquals ('<value>', $this->yaml['morelesskey']);
-    }
-
-    public function testArrayOfZero() {
-      $this->assertSame (array(0), $this->yaml['array_of_zero']);
-    }
-
-    public function testSophisticatedArrayOfZero() {
-      $this->assertSame (array('rx' => array ('tx' => array (0))), $this->yaml['sophisticated_array_of_zero']);
-    }
-
-    public function testSwitches() {
-      $this->assertEquals (array (array ('row' => 0, 'col' => 0, 'func' => array ('tx' => array(0, 1)))), $this->yaml['switches']);
-    }
-
-    public function testEmptySequence() {
-      $this->assertSame (array(), $this->yaml['empty_sequence']);
-    }
-
-    public function testEmptyHash() {
-      $this->assertSame (array(), $this->yaml['empty_hash']);
-    }
-
-    public function testEmptykey() {
-      $this->assertSame (array('' => array ('key' => 'value')), $this->yaml['empty_key']);
-    }
-
-    public function testMultilines() {
-      $this->assertSame (array(array('type' => 'SomeItem', 'values' => array ('blah', 'blah', 'blah', 'blah'), 'ints' => array(2, 54, 12, 2143))), $this->yaml['multiline_items']);
-    }
-
-    public function testManyNewlines() {
-      $this->assertSame ('A quick
-fox
-
-
-jumped
-over
-
-
-
-
-
-a lazy
-
-
-
-dog', $this->yaml['many_lines']);
-    }
-
-    public function testWerte() {
-      $this->assertSame (array ('1' => 'nummer 1', '0' => 'Stunde 0'), $this->yaml['werte']);
-    }
-
-    /* public function testNoIndent() {
-      $this->assertSame (array(
-        array ('record1'=>'value1'),
-        array ('record2'=>'value2')
-      )
-      , $this->yaml['noindent_records']);
-    } */
-
-    public function testColonsInKeys() {
-      $this->assertSame (array (1000), $this->yaml['a:1']);
-    }
-
-    public function testColonsInKeys2() {
-      $this->assertSame (array (2000), $this->yaml['a:2']);
-    }
-
-    public function testSpecialCharacters() {
-      $this->assertSame ('[{]]{{]]', $this->yaml['special_characters']);
-    }
-
-    public function testAngleQuotes() {
-      $Quotes = Spyc::YAMLLoad('quotes.yaml');
-      $this->assertEquals (array ('html_tags' => array ('<br>', '<p>'), 'html_content' => array ('<p>hello world</p>', 'hello<br>world'), 'text_content' => array ('hello world')),
-          $Quotes);
-    }
-
-    public function testFailingColons() {
-      $Failing = Spyc::YAMLLoad('failing1.yaml');
-      $this->assertSame (array ('MyObject' => array ('Prop1' => array ('key1:val1'))),
-          $Failing);
-    }
-
-}
\ No newline at end of file
diff --git a/src/spyc/tests/RoundTripTest.php b/src/spyc/tests/RoundTripTest.php
deleted file mode 100644
index 4a906e2..0000000
--- a/src/spyc/tests/RoundTripTest.php
+++ /dev/null
@@ -1,61 +0,0 @@
-<?php
-
-require_once ("../spyc.php");
-
-function roundTrip($a) { return Spyc::YAMLLoad(Spyc::YAMLDump(array('x' => $a))); }
-
-
-class RoundTripTest extends PHPUnit_Framework_TestCase {
-
-    protected function setUp() {
-    }
-
-    public function testNull() {
-      $this->assertEquals (array ('x' => null), roundTrip (null));
-    }
-
-    public function testY() {
-      $this->assertEquals (array ('x' => 'y'), roundTrip ('y'));
-    }
-    
-    public function testExclam() {
-      $this->assertEquals (array ('x' => '!yeah'), roundTrip ('!yeah'));
-    }
-
-    public function test5() {
-      $this->assertEquals (array ('x' => '5'), roundTrip ('5'));
-    }
-
-    public function testSpaces() {
-      $this->assertEquals (array ('x' => 'x '), roundTrip ('x '));
-    }
-    
-    public function testApostrophes() {
-      $this->assertEquals (array ('x' => "'biz'"), roundTrip ("'biz'"));
-    }
-
-    public function testNewLines() {
-      $this->assertEquals (array ('x' => "\n"), roundTrip ("\n"));
-    }
-
-    public function testHashes() {
-      $this->assertEquals (array ('x' => array ("#color" => '#fff')), roundTrip (array ("#color" => '#fff')));
-    }
-
-    public function testWordWrap() {
-      $this->assertEquals (array ('x' => "aaaaaaaaaaaaaaaaaaaaaaaaaaaa  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), roundTrip ("aaaaaaaaaaaaaaaaaaaaaaaaaaaa  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
-    }
-
-    public function testABCD() {
-      $this->assertEquals (array ('a', 'b', 'c', 'd'), Spyc::YAMLLoad(Spyc::YAMLDump(array('a', 'b', 'c', 'd'))));
-    }
-    
-    public function testABCD2() {
-        $a = array('a', 'b', 'c', 'd'); // Create a simple list
-        $b = Spyc::YAMLDump($a);        // Dump the list as YAML
-        $c = Spyc::YAMLLoad($b);        // Load the dumped YAML
-        $d = Spyc::YAMLDump($c);        // Re-dump the data
-        $this->assertSame($b, $d);
-    }
-   
-}
\ No newline at end of file
diff --git a/src/spyc/tests/failing1.yaml b/src/spyc/tests/failing1.yaml
deleted file mode 100644
index 6906a51..0000000
--- a/src/spyc/tests/failing1.yaml
+++ /dev/null
@@ -1,2 +0,0 @@
-MyObject:
-  Prop1: {key1:val1}
\ No newline at end of file
diff --git a/src/spyc/tests/indent_1.yaml b/src/spyc/tests/indent_1.yaml
deleted file mode 100644
index 85a0b59..0000000
--- a/src/spyc/tests/indent_1.yaml
+++ /dev/null
@@ -1,59 +0,0 @@
-root:
-  child_1: 2
-
-  child_2: 0
-  child_3: 1
-
-root2:
-  child_1: 1
-# A comment
-  child_2: 2
-
-displays:
-  - resolutions:
-      1024: 768
-  - resolutions:
-      1920: 1200
-
-display:
-  - resolutions:
-      1024: 768
-      1920: 1200
-    producer: "Nec"
-
-nested_hashes_and_seqs:
- - { row: 0, col: 0, headsets_affected: [{ports: [0], side: left}], switch_function: {ics_ptt: true} }
-
-easier_nest: { h: [{a: b, a1: b1}, {c: d}] }
-
-one_space: |
-    By four
-      spaces
-
-steps:
-  - step: &id001
-      instrument:      Lasik 2000
-      pulseEnergy:     5.4
-      pulseDuration:   12
-      repetition:      1000
-      spotSize:        1mm
-  - step:
-      <<: *id001
-      spotSize:       2mm
-
-death masks are:
-   sad: 2
-   <<: {magnificent: 4}
-
-login: &login
-   adapter: mysql
-   host: localhost
-
-development:
-   database: rails_dev
-   <<: *login
-
-"key": "value:"
-colon_only: ":"
-
-list_and_comment: [one, two, three] # comment
\ No newline at end of file
diff --git a/src/spyc/tests/quotes.yaml b/src/spyc/tests/quotes.yaml
deleted file mode 100644
index 2ceea86..0000000
--- a/src/spyc/tests/quotes.yaml
+++ /dev/null
@@ -1,8 +0,0 @@
-html_tags:
-  - <br>
-  - <p>
-html_content:
-  - <p>hello world</p>
-  - hello<br>world
-text_content:
-  - hello world
\ No newline at end of file
diff --git a/tests/Bootstrap.php b/tests/Bootstrap.php
new file mode 100644
index 0000000..728f2cb
--- /dev/null
+++ b/tests/Bootstrap.php
@@ -0,0 +1,5 @@
+<?php
+
+if (!@include_once __DIR__ . '/../vendor/autoload.php') {
+	exit("Misisng projecte dependencies.");
+}
diff --git a/tests/FormatterTest.php b/tests/FormatterTest.php
deleted file mode 100644
index 6e8f579..0000000
--- a/tests/FormatterTest.php
+++ /dev/null
@@ -1,105 +0,0 @@
-<?php
-
-use SoapBox\Formatter\Formatter;
-//use Mockery as m;
-
-class FormatterTest extends Orchestra\Testbench\TestCase {
-
-	public function setUp() {
-		parent::setUp();
-
-	}
-	/**
-	 * A basic functional test for JSON to Array conversion
-	 *
-	 * @return void
-	 */
-	public function testJsonToArray() {
-		$data = '{"foo":"bar","bar":"foo"}';
-		$result = Formatter::make($data, 'json')->to_array();
-		$expected = array('foo'=>'bar', 'bar'=>'foo');
-		$this->assertEquals($expected, $result);
-	}
-
-	/**
-	 * A basic functional test for Array to JSON conversion
-	 *
-	 * @return void
-	 */
-	public function testArrayToJson() {
-		$data = array('foo'=>'bar', 'bar'=>'foo');
-		$result = Formatter::make($data)->to_json();
-		$expected = '{"foo":"bar","bar":"foo"}';
-		$this->assertEquals($expected, $result);
-	}
-
-	/**
-	 * A basic functional test for testJSONToXMLToArrayToJsonToArray data to array
-	 *
-	 * @return void
-	 */
-	public function testJSONToXMLToArrayToJsonToArray() {
-		$data = '{"foo":"bar","bar":"foo"}';
-		$result = Formatter::make($data, 'json')->to_xml();
-		$result = Formatter::make($result, 'xml')->to_array();
-		$result = Formatter::make($result, 'array')->to_json();
-		$result = Formatter::make($result, 'json')->to_array();
-		$expected = array('foo'=>'bar', 'bar'=>'foo');
-		$this->assertEquals($expected, $result);
-	}
-
-	/**
-	 * A basic functional test for CSV data to array
-	 *
-	 * @return void
-	 */
-	public function testCSVToArray() {
-		$data = 'foo,bar,bing,bam,boom';
-		$result = Formatter::make($data, 'csv')->to_array();
-		$expected = array('foo','bar','bing','bam','boom');
-		$this->assertEquals($expected, $result);
-	}
-
-	/**
-	* A complex multi-dimentional test for CSV data to array
-	*
-	* @return void
-	*/
-	public function testComplexCSVToArray() {
-/*
-		$data = '
-		{
-			"simple":"118",
-			"date":"2014-05-20 21:03:59.333",
-			"time":"4067",
-			"duration_onset":null,
-			"devicename":"My Device",
-			"calc_data":[
-				[
-					1400609039,
-					0,
-					37,
-					0,
-					0,
-					1
-				],
-				[
-					1400609039,
-					0,
-					37,
-					0,
-					0,
-					1
-				]
-			]
-		}
-		';
-
-		$result = Formatter::make($data, 'json')->to_csv();
-
-		dd($result);
-*/
-		$this->assertEquals(true,true);
-	}
-
-}
diff --git a/tests/TestCase.php b/tests/TestCase.php
new file mode 100644
index 0000000..8b16b03
--- /dev/null
+++ b/tests/TestCase.php
@@ -0,0 +1,17 @@
+<?php namespace SoapBox\Formatter\Test;
+
+abstract class TestCase extends \PHPUnit_Framework_TestCase {
+
+	/**
+	 * Runs prior to every test in the suite.
+	 */
+	public function setUp() {
+	}
+
+	/**
+	 * Runs after every test in the suite.
+	 */
+	protected function tearDown() {
+	}
+
+}
diff --git a/tests/bootstrap.php b/tests/bootstrap.php
deleted file mode 100644
index 5e74e53..0000000
--- a/tests/bootstrap.php
+++ /dev/null
@@ -1,3 +0,0 @@
-<?php
-
-require dirname(__DIR__) . '/src/SoapBox/Formatter/Formatter.php';
diff --git a/tests/unit/FormatterTest.php b/tests/unit/FormatterTest.php
new file mode 100644
index 0000000..d1e96a5
--- /dev/null
+++ b/tests/unit/FormatterTest.php
@@ -0,0 +1,54 @@
+<?php namespace SoapBox\Formatter\Test;
+
+use SoapBox\Formatter\Formatter;
+
+class FormatterTest extends TestCase {
+
+	public function testFormatterProvidesCsvConstant() {
+		$expected = 'csv';
+		$actual = Formatter::CSV;
+
+		$this->assertEquals($expected, $actual);
+	}
+
+	public function testFormatterProvidesJsonConstant() {
+		$expected = 'json';
+		$actual = Formatter::JSON;
+
+		$this->assertEquals($expected, $actual);
+	}
+
+	public function testFormatterProvidesXmlConstant() {
+		$expected = 'xml';
+		$actual = Formatter::XML;
+
+		$this->assertEquals($expected, $actual);
+	}
+
+	public function testFormatterProvidesArrayConstant() {
+		$expected = 'array';
+		$actual = Formatter::ARR;
+
+		$this->assertEquals($expected, $actual);
+	}
+
+	public function testFormatterProvidesYamlConstant() {
+		$expected = 'yaml';
+		$actual = Formatter::YAML;
+
+		$this->assertEquals($expected, $actual);
+	}
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+	public function testFormatterMakeThrowsInvalidTypeException() {
+		$formatter = Formatter::make('', 'blue');
+	}
+
+	public function testFormatterMakeReturnsInstanceOfFormatter() {
+		$formatter = Formatter::make('', Formatter::CSV);
+		$this->assertTrue($formatter instanceof Formatter);
+	}
+
+}
diff --git a/tests/unit/ParserTest.php b/tests/unit/ParserTest.php
new file mode 100644
index 0000000..b2ac0d5
--- /dev/null
+++ b/tests/unit/ParserTest.php
@@ -0,0 +1,101 @@
+<?php namespace SoapBox\Formatter\Test;
+
+use SoapBox\Formatter\Formatter;
+
+class ParserTest extends TestCase {
+
+	/**
+	 * A basic functional test for JSON to Array conversion
+	 *
+	 * @return void
+	 */
+	public function testJsonToArray() {
+		$data = '{"foo":"bar","bar":"foo"}';
+
+		$actual = Formatter::make($data, Formatter::JSON)->toArray();
+		$expected = ['foo'=>'bar', 'bar'=>'foo'];
+
+		$this->assertEquals($expected, $actual);
+	}
+
+	/**
+	 * A basic functional test for Array to JSON conversion
+	 *
+	 * @return void
+	 */
+	public function testArrayToJson() {
+		$data = ['foo'=>'bar', 'bar'=>'foo'];
+
+		$actual = Formatter::make($data, Formatter::ARR)->toJson();
+		$expected = '{"foo":"bar","bar":"foo"}';
+
+		$this->assertEquals($expected, $actual);
+	}
+
+	/**
+	 * A basic functional test for CSV data to array
+	 *
+	 * @return void
+	 */
+	public function testCSVToArray() {
+		$data = 'foo,bar,bing,bam,boom';
+
+		$actual = Formatter::make($data, Formatter::CSV)->toArray();
+		$expected = array('foo','bar','bing','bam','boom');
+
+		$this->assertEquals($expected, $actual);
+	}
+
+	/**
+	 * A basic functional test for testJSONToXMLToArrayToJsonToArray data to array
+	 *
+	 * @return void
+	 */
+	public function testJSONToXMLToArrayToJsonToArray() {
+		$data = '{"foo":"bar","bar":"foo"}';
+
+		$result = Formatter::make($data, Formatter::JSON)->toXml();
+		$result = Formatter::make($result, Formatter::XML)->toArray();
+		$result = Formatter::make($result, Formatter::ARR)->toJson();
+		$actual = Formatter::make($result, Formatter::JSON)->toArray();
+
+		$expected = ['foo'=>'bar', 'bar'=>'foo'];
+
+		$this->assertEquals($expected, $actual);
+	}
+
+	public function testMultiDimensionalArrayFromJsonToCsv() {
+		$expected = "simple,date,time,duration_onset,devicename,calc_data.0.0,calc_data.0.1,calc_data.0.2,calc_data.0.3,calc_data.0.4,calc_data.0.5,calc_data.1.0,calc_data.1.1,calc_data.1.2,calc_data.1.3,calc_data.1.4,calc_data.1.5\r\n118,2014-05-20 21:03:59.333,4067,,My Device,1400609039,0,37,0,0,1,1400609039,0,37,0,0,1";
+
+		$json =
+'{
+	"simple":"118",
+	"date":"2014-05-20 21:03:59.333",
+	"time":"4067",
+	"duration_onset":null,
+	"devicename":"My Device",
+	"calc_data":[
+		[
+			1400609039,
+			0,
+			37,
+			0,
+			0,
+			1
+		],
+		[
+			1400609039,
+			0,
+			37,
+			0,
+			0,
+			1
+		]
+	]
+}';
+		$jsonParser = Formatter::make($json, Formatter::JSON);
+
+		$this->assertEquals($expected, $jsonParser->toCsv());
+	}
+
+}
diff --git a/tests/unit/Parsers/ArrayParserTest.php b/tests/unit/Parsers/ArrayParserTest.php
new file mode 100644
index 0000000..8c85db9
--- /dev/null
+++ b/tests/unit/Parsers/ArrayParserTest.php
@@ -0,0 +1,53 @@
+<?php namespace SoapBox\Formatter\Test\Parsers;
+
+use stdClass;
+use SoapBox\Formatter\Test\TestCase;
+use SoapBox\Formatter\Parsers\Parser;
+use SoapBox\Formatter\Parsers\ArrayParser;
+
+class ArrayParserTest extends TestCase {
+
+	public function testArrayParserIsInstanceOfParserInterface() {
+		$parser = new ArrayParser(new \stdClass);
+		$this->assertTrue($parser instanceof Parser);
+	}
+
+	public function testConstructorAcceptsSerializedArray() {
+		$expected = [0, 1, 2];
+		$parser = new ArrayParser(serialize($expected));
+		$this->assertEquals($expected, $parser->toArray());
+	}
+
+	public function testConstructorAcceptsObject() {
+		$expected = ['foo' => 'bar'];
+		$input = new stdClass;
+		$input->foo = 'bar';
+		$parser = new ArrayParser($input);
+		$this->assertEquals($expected, $parser->toArray());
+	}
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+	public function testArrayParserThrowsExceptionWithInvalidInputOfEmptyString() {
+		$parser = new ArrayParser('');
+	}
+
+	public function testtoArrayReturnsArray() {
+		$parser = new ArrayParser(serialize([0, 1, 2]));
+		$this->assertTrue(is_array($parser->toArray()));
+	}
+
+	public function testtoJsonReturnsJsonRepresentationOfArray() {
+		$expected = '[0,1,2]';
+		$parser = new ArrayParser([0, 1, 2]);
+		$this->assertEquals($expected, $parser->toJson());
+	}
+
+	public function testtoJsonReturnsJsonRepresentationOfNamedArray() {
+		$expected = '{"foo":"bar"}';
+		$parser = new ArrayParser(['foo' => 'bar']);
+		$this->assertEquals($expected, $parser->toJson());
+	}
+
+}
diff --git a/tests/unit/Parsers/CsvParserTest.php b/tests/unit/Parsers/CsvParserTest.php
new file mode 100644
index 0000000..39547c0
--- /dev/null
+++ b/tests/unit/Parsers/CsvParserTest.php
@@ -0,0 +1,36 @@
+<?php namespace SoapBox\Formatter\Test\Parsers;
+
+use SoapBox\Formatter\Test\TestCase;
+use SoapBox\Formatter\Parsers\Parser;
+use SoapBox\Formatter\Parsers\CsvParser;
+
+class CsvParserTest extends TestCase {
+
+	private $simpleCsv = 'foo,boo
+bar,far';
+
+	public function testCsvParserIsInstanceOfParserInterface() {
+		$parser = new CsvParser('');
+		$this->assertTrue($parser instanceof Parser);
+	}
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+	public function testConstructorThrowsInvalidExecptionWhenArrayDataIsProvided() {
+		$parser = new CsvParser([0, 1, 3]);
+	}
+
+	public function testtoArrayReturnsCsvArrayRepresentation() {
+		$expected = [['foo' => 'bar', 'boo' => 'far']];
+		$parser = new CsvParser($this->simpleCsv);
+		$this->assertEquals($expected, $parser->toArray());
+	}
+
+	public function testtoJsonReturnsJsonRepresentationOfNamedArray() {
+		$expected = '[{"foo":"bar","boo":"far"}]';
+		$parser = new CsvParser($this->simpleCsv);
+		$this->assertEquals($expected, $parser->toJson());
+	}
+
+}
diff --git a/tests/unit/Parsers/JsonParserTest.php b/tests/unit/Parsers/JsonParserTest.php
new file mode 100644
index 0000000..9bca418
--- /dev/null
+++ b/tests/unit/Parsers/JsonParserTest.php
@@ -0,0 +1,31 @@
+<?php namespace SoapBox\Formatter\Test\Parsers;
+
+use SoapBox\Formatter\Test\TestCase;
+use SoapBox\Formatter\Parsers\Parser;
+use SoapBox\Formatter\Parsers\JsonParser;
+
+class JsonParserTest extends TestCase {
+
+	public function testJsonParserIsInstanceOfParserInterface() {
+		$parser = new JsonParser('');
+		$this->assertTrue($parser instanceof Parser);
+	}
+
+	public function testtoArrayReturnsArrayRepresentationOfJsonObject() {
+		$expected = ['foo' => 'bar'];
+		$parser = new JsonParser('{"foo": "bar"}');
+		$this->assertEquals($expected, $parser->toArray());
+	}
+
+	public function testtoJsonReturnsArrayRepresentationOfArray() {
+		$expected = '[0,1,2]';
+		$parser = new JsonParser($expected);
+		$this->assertEquals($expected, $parser->toJson());
+	}
+
+	public function testtoJsonReturnsJsonRepresentationOfNamedArray() {
+		$expected = '{"foo":"bar"}';
+		$parser = new JsonParser($expected);
+		$this->assertEquals($expected, $parser->toJson());
+	}
+}
diff --git a/tests/unit/Parsers/XmlParserTest.php b/tests/unit/Parsers/XmlParserTest.php
new file mode 100644
index 0000000..614be06
--- /dev/null
+++ b/tests/unit/Parsers/XmlParserTest.php
@@ -0,0 +1,25 @@
+<?php namespace SoapBox\Formatter\Test\Parsers;
+
+use SoapBox\Formatter\Test\TestCase;
+use SoapBox\Formatter\Parsers\Parser;
+use SoapBox\Formatter\Parsers\XmlParser;
+
+class XmlParserTest extends TestCase {
+
+	public function testXmlParserIsInstanceOfParserInterface() {
+		$parser = new XmlParser('');
+		$this->assertTrue($parser instanceof Parser);
+	}
+
+	public function testtoArrayReturnsArrayRepresenationOfXmlObject() {
+		$expected = ['foo' => 'bar'];
+		$parser = new XmlParser('<xml><foo>bar</foo></xml>');
+		$this->assertEquals($expected, $parser->toArray());
+	}
+
+	public function testtoJsonReturnsJsonRepresentationOfXmlObject() {
+		$expected = '{"foo":"bar"}';
+		$parser = new XmlParser('<xml><foo>bar</foo></xml>');
+		$this->assertEquals($expected, $parser->toJson());
+	}
+}
diff --git a/tests/unit/Parsers/YamlParserTest.php b/tests/unit/Parsers/YamlParserTest.php
new file mode 100644
index 0000000..bf0edac
--- /dev/null
+++ b/tests/unit/Parsers/YamlParserTest.php
@@ -0,0 +1,22 @@
+<?php namespace SoapBox\Formatter\Test\Parsers;
+
+use SoapBox\Formatter\Test\TestCase;
+use SoapBox\Formatter\Parsers\Parser;
+use SoapBox\Formatter\Parsers\YamlParser;
+use SoapBox\Formatter\Parsers\XmlParser;
+
+class YamlParserTest extends TestCase {
+
+	public function testYamlParserIsInstanceOfParserInterface() {
+		$parser = new YamlParser('');
+		$this->assertTrue($parser instanceof Parser);
+	}
+
+	public function testtoArrayReturnsArrayRepresenationOfYamlObject() {
+		$expected = ['foo' => 'bar'];
+		$parser = new XmlParser('<xml><foo>bar</foo></xml>');
+		$x = new YamlParser($parser->toYaml());
+		$this->assertEquals($expected, $x->toArray());
+	}
+
+}