Merge branch 'dev' into feature/whitespace-overhaul

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "test/spec"]
+	path = test/spec
+	url = http://github.com/mustache/spec.git

test/MustacheSpecTest.php

@@ -0,0 +1,145 @@
+<?php
+
+require_once '../Mustache.php';
+require_once './lib/yaml/lib/sfYamlParser.php';
+
+/**
+ * A PHPUnit test case wrapping the Mustache Spec
+ *
+ * @group mustache-spec
+ */
+class MustacheSpecTest extends PHPUnit_Framework_TestCase {
+
+	/**
+	 * For some reason data providers can't mark tests skipped, so this test exists
+	 * simply to provide a 'skipped' test if the `spec` submodule isn't initialized.
+	 */
+	public function testSpecInitialized() {
+		$spec_dir = dirname(__FILE__) . '/spec/specs/';
+		if (!file_exists($spec_dir)) {
+			$this->markTestSkipped('Mustache spec submodule not initialized: run "git submodule update --init"');
+		}
+	}
+
+	/**
+	 * @group comments
+	 * @dataProvider loadCommentSpec
+	 */
+	public function testCommentSpec($template, $data, $partials, $expected, $desc) {
+		$m = new Mustache($template, $data, $partials);
+		$this->assertEquals($expected, $m->render(), $desc);
+	}
+
+	/**
+	 * @group delimiters
+	 * @dataProvider loadDelimitersSpec
+	 */
+	public function testDelimitersSpec($template, $data, $partials, $expected, $desc) {
+		$m = new Mustache($template, $data, $partials);
+		$this->assertEquals($expected, $m->render(), $desc);
+	}
+
+	/**
+	 * @group interpolation
+	 * @dataProvider loadInterpolationSpec
+	 */
+	public function testInterpolationSpec($template, $data, $partials, $expected, $desc) {
+		$m = new Mustache($template, $data, $partials);
+		$this->assertEquals($expected, $m->render(), $desc);
+	}
+
+	/**
+	 * @group inverted-sections
+	 * @dataProvider loadInvertedSpec
+	 */
+	public function testInvertedSpec($template, $data, $partials, $expected, $desc) {
+		$m = new Mustache($template, $data, $partials);
+		$this->assertEquals($expected, $m->render(), $desc);
+	}
+
+	/**
+	 * @group lambdas
+	 * @dataProvider loadLambdasSpec
+	 */
+	public function testLambdasSpec($template, $data, $partials, $expected, $desc) {
+		$this->markTestSkipped("Lambdas for PHP haven't made it into the spec yet, so we'll skip them to avoid a bajillion failed tests.");
+
+		if (!version_compare(PHP_VERSION, '5.3.0', '>=')) {
+			$this->markTestSkipped('Unable to test Lambdas spec with PHP < 5.3.');
+		}
+
+		$m = new Mustache($template, $data, $partials);
+		$this->assertEquals($expected, $m->render(), $desc);
+	}
+
+	/**
+	 * @group partials
+	 * @dataProvider loadPartialsSpec
+	 */
+	public function testPartialsSpec($template, $data, $partials, $expected, $desc) {
+		$m = new Mustache($template, $data, $partials);
+		$this->assertEquals($expected, $m->render(), $desc);
+	}
+
+	/**
+	 * @group sections
+	 * @dataProvider loadSectionsSpec
+	 */
+	public function testSectionsSpec($template, $data, $partials, $expected, $desc) {
+		$m = new Mustache($template, $data, $partials);
+		$this->assertEquals($expected, $m->render(), $desc);
+	}
+
+	public function loadCommentSpec() {
+		return $this->loadSpec('comments');
+	}
+
+	public function loadDelimitersSpec() {
+		return $this->loadSpec('delimiters');
+	}
+
+	public function loadInterpolationSpec() {
+		return $this->loadSpec('interpolation');
+	}
+
+	public function loadInvertedSpec() {
+		return $this->loadSpec('inverted');
+	}
+
+	public function loadLambdasSpec() {
+		return $this->loadSpec('lambdas');
+	}
+
+	public function loadPartialsSpec() {
+		return $this->loadSpec('partials');
+	}
+
+	public function loadSectionsSpec() {
+		return $this->loadSpec('sections');
+	}
+
+	/**
+	 * Data provider for the mustache spec test.
+	 *
+	 * Loads YAML files from the spec and converts them to PHPisms.
+	 *
+	 * @access public
+	 * @return array
+	 */
+	protected function loadSpec($name) {
+		$filename = dirname(__FILE__) . '/spec/specs/' . $name . '.yml';
+		if (!file_exists($filename)) {
+			return array();
+		}
+
+		$data = array();
+
+		$yaml = new sfYamlParser();
+
+		$spec = $yaml->parse(file_get_contents($filename));
+		foreach ($spec['tests'] as $test) {
+			$data[] = array($test['template'], $test['data'], isset($test['partials']) ? $test['partials'] : array(), $test['expected'], $test['desc']);
+		}
+		return $data;
+	}
+}

test/lib/yaml/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008-2009 Fabien Potencier
+
+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.

test/lib/yaml/README.markdown

@@ -0,0 +1,15 @@
+Symfony YAML: A PHP library that speaks YAML
+============================================
+
+Symfony YAML is a PHP library that parses YAML strings and converts them to
+PHP arrays. It can also converts PHP arrays to YAML strings. Its official
+website is at http://components.symfony-project.org/yaml/.
+
+The documentation is to be found in the `doc/` directory.
+
+Symfony YAML is licensed under the MIT license (see LICENSE file).
+
+The Symfony YAML library is developed and maintained by the
+[symfony](http://www.symfony-project.org/) project team. It has been extracted
+from symfony to be used as a standalone library. Symfony YAML is part of the
+[symfony components project](http://components.symfony-project.org/).

test/lib/yaml/doc/00-Introduction.markdown

@@ -0,0 +1,143 @@
+Introduction
+============
+
+This book is about *Symfony YAML*, a PHP library part of the Symfony
+Components project. Its official website is at
+http://components.symfony-project.org/yaml/.
+
+>**SIDEBAR**
+>About the Symfony Components
+>
+>[Symfony Components](http://components.symfony-project.org/) are
+>standalone PHP classes that can be easily used in any
+>PHP project. Most of the time, they have been developed as part of the
+>[Symfony framework](http://www.symfony-project.org/), and decoupled from the
+>main framework later on. You don't need to use the Symfony MVC framework to use
+>the components.
+
+What is it?
+-----------
+
+Symfony YAML is a PHP library that parses YAML strings and converts them to
+PHP arrays. It can also converts PHP arrays to YAML strings.
+
+[YAML](http://www.yaml.org/), YAML Ain't Markup Language, is a human friendly
+data serialization standard for all programming languages. YAML is a great
+format for your configuration files. YAML files are as expressive as XML files
+and as readable as INI files.
+
+### Easy to use
+
+There is only one archive to download, and you are ready to go. No
+configuration, No installation. Drop the files in a directory and start using
+it today in your projects.
+
+### Open-Source
+
+Released under the MIT license, you are free to do whatever you want, even in
+a commercial environment. You are also encouraged to contribute.
+
+
+### Used by popular Projects
+
+Symfony YAML was initially released as part of the symfony framework, one of
+the most popular PHP web framework. It is also embedded in other popular
+projects like PHPUnit or Doctrine.
+
+### Documented
+
+Symfony YAML is fully documented, with a dedicated online book, and of course
+a full API documentation.
+
+### Fast
+
+One of the goal of Symfony YAML is to find the right balance between speed and
+features. It supports just the needed feature to handle configuration files.
+
+### Unit tested
+
+The library is fully unit-tested. With more than 400 unit tests, the library
+is stable and is already used in large projects.
+
+### Real Parser
+
+It sports a real parser and is able to parse a large subset of the YAML
+specification, for all your configuration needs. It also means that the parser
+is pretty robust, easy to understand, and simple enough to extend.
+
+### Clear error messages
+
+Whenever you have a syntax problem with your YAML files, the library outputs a
+helpful message with the filename and the line number where the problem
+occurred. It eases the debugging a lot.
+
+### Dump support
+
+It is also able to dump PHP arrays to YAML with object support, and inline
+level configuration for pretty outputs.
+
+### Types Support
+
+It supports most of the YAML built-in types like dates, integers, octals,
+booleans, and much more...
+
+
+### Full merge key support
+
+Full support for references, aliases, and full merge key. Don't repeat
+yourself by referencing common configuration bits.
+
+### PHP Embedding
+
+YAML files are dynamic. By embedding PHP code inside a YAML file, you have
+even more power for your configuration files.
+
+Installation
+------------
+
+Symfony YAML can be installed by downloading the source code as a
+[tar](http://github.com/fabpot/yaml/tarball/master) archive or a
+[zip](http://github.com/fabpot/yaml/zipball/master) one.
+
+To stay up-to-date, you can also use the official Subversion
+[repository](http://svn.symfony-project.com/components/yaml/).
+
+If you are a Git user, there is an official
+[mirror](http://github.com/fabpot/yaml), which is updated every 10 minutes.
+
+If you prefer to install the component globally on your machine, you can use
+the symfony [PEAR](http://pear.symfony-project.com/) channel server.
+
+Support
+-------
+
+Support questions and enhancements can be discussed on the
+[mailing-list](http://groups.google.com/group/symfony-components).
+
+If you find a bug, you can create a ticket at the symfony
+[trac](http://trac.symfony-project.org/newticket) under the *YAML* component.
+
+License
+-------
+
+The Symfony YAML component is licensed under the *MIT license*:
+
+>Copyright (c) 2008-2009 Fabien Potencier
+>
+>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.

test/lib/yaml/doc/01-Usage.markdown

@@ -0,0 +1,110 @@
+Using Symfony YAML
+==================
+
+The Symfony YAML library is very simple and consists of two main classes: one
+to parse YAML strings (`sfYamlParser`), and the other to dump a PHP array to
+a YAML string (`sfYamlDumper`).
+
+On top of these two core classes, the main `sfYaml` class acts as a thin
+wrapper and simplifies common uses.
+
+Reading YAML Files
+------------------
+
+The `sfYamlParser::parse()` method parses a YAML string and converts it to a
+PHP array:
+
+    [php]
+    $yaml = new sfYamlParser();
+    $value = $yaml->parse(file_get_contents('/path/to/file.yaml'));
+
+If an error occurs during parsing, the parser throws an exception indicating
+the error type and the line in the original YAML string where the error
+occurred:
+
+    [php]
+    try
+    {
+      $value = $yaml->parse(file_get_contents('/path/to/file.yaml'));
+    }
+    catch (InvalidArgumentException $e)
+    {
+      // an error occurred during parsing
+      echo "Unable to parse the YAML string: ".$e->getMessage();
+    }
+
+>**TIP**
+>As the parser is reentrant, you can use the same parser object to load
+>different YAML strings.
+
+When loading a YAML file, it is sometimes better to use the `sfYaml::load()`
+wrapper method:
+
+    [php]
+    $loader = sfYaml::load('/path/to/file.yml');
+
+The `sfYaml::load()` static method takes a YAML string or a file containing
+YAML. Internally, it calls the `sfYamlParser::parse()` method, but with some
+added bonuses:
+
+  * It executes the YAML file as if it was a PHP file, so that you can embed
+    PHP commands in YAML files;
+
+  * When a file cannot be parsed, it automatically adds the file name to the
+    error message, simplifying debugging when your application is loading
+    several YAML files.
+
+Writing YAML Files
+------------------
+
+The `sfYamlDumper` dumps any PHP array to its YAML representation:
+
+    [php]
+    $array = array('foo' => 'bar', 'bar' => array('foo' => 'bar', 'bar' => 'baz'));
+
+    $dumper = new sfYamlDumper();
+    $yaml = $dumper->dump($array);
+    file_put_contents('/path/to/file.yaml', $yaml);
+
+>**NOTE**
+>Of course, the Symfony YAML dumper is not able to dump resources. Also,
+>even if the dumper is able to dump PHP objects, it is to be considered
+>an alpha feature.
+
+If you only need to dump one array, you can use the `sfYaml::dump()` static
+method shortcut:
+
+    [php]
+    $yaml = sfYaml::dump($array, $inline);
+
+The YAML format supports two kind of representation for arrays, the expanded
+one, and the inline one. By default, the dumper uses the inline
+representation:
+
+    [yml]
+    { foo: bar, bar: { foo: bar, bar: baz } }
+
+The second argument of the `dump()` method customizes the level at which the
+output switches from the expanded representation to the inline one:
+
+    [php]
+    echo $dumper->dump($array, 1);
+
+-
+
+    [yml]
+    foo: bar
+    bar: { foo: bar, bar: baz }
+
+-
+
+    [php]
+    echo $dumper->dump($array, 2);
+
+-
+
+    [yml]
+    foo: bar
+    bar:
+      foo: bar
+      bar: baz

test/lib/yaml/doc/02-YAML.markdown

@@ -0,0 +1,312 @@
+The YAML Format
+===============
+
+According to the official [YAML](http://yaml.org/) website, YAML is "a human
+friendly data serialization standard for all programming languages".
+
+Even if the YAML format can describe complex nested data structure, this
+chapter only describes the minimum set of features needed to use YAML as a
+configuration file format.
+
+YAML is a simple language that describes data. As PHP, it has a syntax for
+simple types like strings, booleans, floats, or integers. But unlike PHP, it
+makes a difference between arrays (sequences) and hashes (mappings).
+
+Scalars
+-------
+
+The syntax for scalars is similar to the PHP syntax.
+
+### Strings
+
+    [yml]
+    A string in YAML
+
+-
+
+    [yml]
+    'A singled-quoted string in YAML'
+
+>**TIP**
+>In a single quoted string, a single quote `'` must be doubled:
+>
+>     [yml]
+>     'A single quote '' in a single-quoted string'
+
+    [yml]
+    "A double-quoted string in YAML\n"
+
+Quoted styles are useful when a string starts or ends with one or more
+relevant spaces.
+
+>**TIP**
+>The double-quoted style provides a way to express arbitrary strings, by
+>using `\` escape sequences. It is very useful when you need to embed a
+>`\n` or a unicode character in a string.
+
+When a string contains line breaks, you can use the literal style, indicated
+by the pipe (`|`), to indicate that the string will span several lines. In
+literals, newlines are preserved:
+
+    [yml]
+    |
+      \/ /| |\/| |
+      / / | |  | |__
+
+Alternatively, strings can be written with the folded style, denoted by `>`,
+where each line break is replaced by a space:
+
+    [yml]
+    >
+      This is a very long sentence
+      that spans several lines in the YAML
+      but which will be rendered as a string
+      without carriage returns.
+
+>**NOTE**
+>Notice the two spaces before each line in the previous examples. They
+>won't appear in the resulting PHP strings.
+
+### Numbers
+
+    [yml]
+    # an integer
+    12
+
+-
+
+    [yml]
+    # an octal
+    014
+
+-
+
+    [yml]
+    # an hexadecimal
+    0xC
+
+-
+
+    [yml]
+    # a float
+    13.4
+
+-
+
+    [yml]
+    # an exponential number
+    1.2e+34
+
+-
+
+    [yml]
+    # infinity
+    .inf
+
+### Nulls
+
+Nulls in YAML can be expressed with `null` or `~`.
+
+### Booleans
+
+Booleans in YAML are expressed with `true` and `false`.
+
+>**NOTE**
+>The symfony YAML parser also recognize `on`, `off`, `yes`, and `no` but
+>it is strongly discouraged to use them as it has been removed from the
+>1.2 YAML specifications.
+
+### Dates
+
+YAML uses the ISO-8601 standard to express dates:
+
+    [yml]
+    2001-12-14t21:59:43.10-05:00
+
+-
+
+    [yml]
+    # simple date
+    2002-12-14
+
+Collections
+-----------
+
+A YAML file is rarely used to describe a simple scalar. Most of the time, it
+describes a collection. A collection can be a sequence or a mapping of
+elements. Both sequences and mappings are converted to PHP arrays.
+
+Sequences use a dash followed by a space (`- `):
+
+    [yml]
+    - PHP
+    - Perl
+    - Python
+
+The previous YAML file is equivalent to the following PHP code:
+
+    [php]
+    array('PHP', 'Perl', 'Python');
+
+Mappings use a colon followed by a space (`: `) to mark each key/value pair:
+
+    [yml]
+    PHP: 5.2
+    MySQL: 5.1
+    Apache: 2.2.20
+
+which is equivalent to this PHP code:
+
+    [php]
+    array('PHP' => 5.2, 'MySQL' => 5.1, 'Apache' => '2.2.20');
+
+>**NOTE**
+>In a mapping, a key can be any valid scalar.
+
+The number of spaces between the colon and the value does not matter:
+
+    [yml]
+    PHP:    5.2
+    MySQL:  5.1
+    Apache: 2.2.20
+
+YAML uses indentation with one or more spaces to describe nested collections:
+
+    [yml]
+    "symfony 1.0":
+      PHP:    5.0
+      Propel: 1.2
+    "symfony 1.2":
+      PHP:    5.2
+      Propel: 1.3
+
+The following YAML is equivalent to the following PHP code:
+
+    [php]
+    array(
+      'symfony 1.0' => array(
+        'PHP'    => 5.0,
+        'Propel' => 1.2,
+      ),
+      'symfony 1.2' => array(
+        'PHP'    => 5.2,
+        'Propel' => 1.3,
+      ),
+    );
+
+There is one important thing you need to remember when using indentation in a
+YAML file: *Indentation must be done with one or more spaces, but never with
+tabulations*.
+
+You can nest sequences and mappings as you like:
+
+    [yml]
+    'Chapter 1':
+      - Introduction
+      - Event Types
+    'Chapter 2':
+      - Introduction
+      - Helpers
+
+YAML can also use flow styles for collections, using explicit indicators
+rather than indentation to denote scope.
+
+A sequence can be written as a comma separated list within square brackets
+(`[]`):
+
+    [yml]
+    [PHP, Perl, Python]
+
+A mapping can be written as a comma separated list of key/values within curly
+braces (`{}`):
+
+    [yml]
+    { PHP: 5.2, MySQL: 5.1, Apache: 2.2.20 }
+
+You can mix and match styles to achieve a better readability:
+
+    [yml]
+    'Chapter 1': [Introduction, Event Types]
+    'Chapter 2': [Introduction, Helpers]
+
+-
+
+    [yml]
+    "symfony 1.0": { PHP: 5.0, Propel: 1.2 }
+    "symfony 1.2": { PHP: 5.2, Propel: 1.3 }
+
+Comments
+--------
+
+Comments can be added in YAML by prefixing them with a hash mark (`#`):
+
+    [yml]
+    # Comment on a line
+    "symfony 1.0": { PHP: 5.0, Propel: 1.2 } # Comment at the end of a line
+    "symfony 1.2": { PHP: 5.2, Propel: 1.3 }
+
+>**NOTE**
+>Comments are simply ignored by the YAML parser and do not need to be
+>indented according to the current level of nesting in a collection.
+
+Dynamic YAML files
+------------------
+
+In symfony, a YAML file can contain PHP code that is evaluated just before the
+parsing occurs:
+
+    [php]
+    1.0:
+      version: <?php echo file_get_contents('1.0/VERSION')."\n" ?>
+    1.1:
+      version: "<?php echo file_get_contents('1.1/VERSION') ?>"
+
+Be careful to not mess up with the indentation. Keep in mind the following
+simple tips when adding PHP code to a YAML file:
+
+ * The `<?php ?>` statements must always start the line or be embedded in a
+   value.
+
+ * If a `<?php ?>` statement ends a line, you need to explicitly output a new
+   line ("\n").
+
+<div class="pagebreak"></div>
+
+A Full Length Example
+---------------------
+
+The following example illustrates most YAML notations explained in this
+document:
+
+    [yml]
+    "symfony 1.0":
+      end_of_maintainance: 2010-01-01
+      is_stable:           true
+      release_manager:     "Grégoire Hubert"
+      description: >
+        This stable version is the right choice for projects
+        that need to be maintained for a long period of time.
+      latest_beta:         ~
+      latest_minor:        1.0.20
+      supported_orms:      [Propel]
+      archives:            { source: [zip, tgz], sandbox: [zip, tgz] }
+
+    "symfony 1.2":
+      end_of_maintainance: 2008-11-01
+      is_stable:           true
+      release_manager:     'Fabian Lange'
+      description: >
+        This stable version is the right choice
+        if you start a new project today.
+      latest_beta:         null
+      latest_minor:        1.2.5
+      supported_orms:
+        - Propel
+        - Doctrine
+      archives:
+        source:
+          - zip
+          - tgz
+        sandbox:
+          - zip
+          - tgz

test/lib/yaml/lib/sfYaml.php

@@ -0,0 +1,135 @@
+<?php
+
+/*
+ * This file is part of the symfony package.
+ * (c) 2004-2006 Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+/**
+ * sfYaml offers convenience methods to load and dump YAML.
+ *
+ * @package    symfony
+ * @subpackage yaml
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ * @version    SVN: $Id: sfYaml.class.php 8988 2008-05-15 20:24:26Z fabien $
+ */
+class sfYaml
+{
+  static protected
+    $spec = '1.2';
+
+  /**
+   * Sets the YAML specification version to use.
+   *
+   * @param string $version The YAML specification version
+   */
+  static public function setSpecVersion($version)
+  {
+    if (!in_array($version, array('1.1', '1.2')))
+    {
+      throw new InvalidArgumentException(sprintf('Version %s of the YAML specifications is not supported', $version));
+    }
+
+    self::$spec = $version;
+  }
+
+  /**
+   * Gets the YAML specification version to use.
+   *
+   * @return string The YAML specification version
+   */
+  static public function getSpecVersion()
+  {
+    return self::$spec;
+  }
+
+  /**
+   * Loads YAML into a PHP array.
+   *
+   * 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.
+   *
+   *  Usage:
+   *  <code>
+   *   $array = sfYaml::load('config.yml');
+   *   print_r($array);
+   *  </code>
+   *
+   * @param string $input Path of YAML file or string containing YAML
+   *
+   * @return array The YAML converted to a PHP array
+   *
+   * @throws InvalidArgumentException If the YAML is not valid
+   */
+  public static function load($input)
+  {
+    $file = '';
+
+    // if input is a file, process it
+    if (strpos($input, "\n") === false && is_file($input))
+    {
+      $file = $input;
+
+      ob_start();
+      $retval = include($input);
+      $content = ob_get_clean();
+
+      // if an array is returned by the config file assume it's in plain php form else in YAML
+      $input = is_array($retval) ? $retval : $content;
+    }
+
+    // if an array is returned by the config file assume it's in plain php form else in YAML
+    if (is_array($input))
+    {
+      return $input;
+    }
+
+    require_once dirname(__FILE__).'/sfYamlParser.php';
+
+    $yaml = new sfYamlParser();
+
+    try
+    {
+      $ret = $yaml->parse($input);
+    }
+    catch (Exception $e)
+    {
+      throw new InvalidArgumentException(sprintf('Unable to parse %s: %s', $file ? sprintf('file "%s"', $file) : 'string', $e->getMessage()));
+    }
+
+    return $ret;
+  }
+
+  /**
+   * Dumps a PHP array to a YAML string.
+   *
+   * The dump method, when supplied with an array, will do its best
+   * to convert the array into friendly YAML.
+   *
+   * @param array   $array PHP array
+   * @param integer $inline The level where you switch to inline YAML
+   *
+   * @return string A YAML string representing the original PHP array
+   */
+  public static function dump($array, $inline = 2)
+  {
+    require_once dirname(__FILE__).'/sfYamlDumper.php';
+
+    $yaml = new sfYamlDumper();
+
+    return $yaml->dump($array, $inline);
+  }
+}
+
+/**
+ * Wraps echo to automatically provide a newline.
+ *
+ * @param string $string The string to echo with new line
+ */
+function echoln($string)
+{
+  echo $string."\n";
+}

test/lib/yaml/lib/sfYamlDumper.php

@@ -0,0 +1,60 @@
+<?php
+
+/*
+ * This file is part of the symfony package.
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require_once(dirname(__FILE__).'/sfYamlInline.php');
+
+/**
+ * sfYamlDumper dumps PHP variables to YAML strings.
+ *
+ * @package    symfony
+ * @subpackage yaml
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ * @version    SVN: $Id: sfYamlDumper.class.php 10575 2008-08-01 13:08:42Z nicolas $
+ */
+class sfYamlDumper
+{
+  /**
+   * Dumps a PHP value to YAML.
+   *
+   * @param  mixed   $input  The PHP value
+   * @param  integer $inline The level where you switch to inline YAML
+   * @param  integer $indent The level o indentation indentation (used internally)
+   *
+   * @return string  The YAML representation of the PHP value
+   */
+  public function dump($input, $inline = 0, $indent = 0)
+  {
+    $output = '';
+    $prefix = $indent ? str_repeat(' ', $indent) : '';
+
+    if ($inline <= 0 || !is_array($input) || empty($input))
+    {
+      $output .= $prefix.sfYamlInline::dump($input);
+    }
+    else
+    {
+      $isAHash = array_keys($input) !== range(0, count($input) - 1);
+
+      foreach ($input as $key => $value)
+      {
+        $willBeInlined = $inline - 1 <= 0 || !is_array($value) || empty($value);
+
+        $output .= sprintf('%s%s%s%s',
+          $prefix,
+          $isAHash ? sfYamlInline::dump($key).':' : '-',
+          $willBeInlined ? ' ' : "\n",
+          $this->dump($value, $inline - 1, $willBeInlined ? 0 : $indent + 2)
+        ).($willBeInlined ? "\n" : '');
+      }
+    }
+
+    return $output;
+  }
+}

test/lib/yaml/lib/sfYamlInline.php

@@ -0,0 +1,442 @@
+<?php
+
+/*
+ * This file is part of the symfony package.
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require_once dirname(__FILE__).'/sfYaml.php';
+
+/**
+ * sfYamlInline implements a YAML parser/dumper for the YAML inline syntax.
+ *
+ * @package    symfony
+ * @subpackage yaml
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ * @version    SVN: $Id: sfYamlInline.class.php 16177 2009-03-11 08:32:48Z fabien $
+ */
+class sfYamlInline
+{
+  const REGEX_QUOTED_STRING = '(?:"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|\'([^\']*(?:\'\'[^\']*)*)\')';
+
+  /**
+   * Convert a YAML string to a PHP array.
+   *
+   * @param string $value A YAML string
+   *
+   * @return array A PHP array representing the YAML string
+   */
+  static public function load($value)
+  {
+    $value = trim($value);
+
+    if (0 == strlen($value))
+    {
+      return '';
+    }
+
+    if (function_exists('mb_internal_encoding') && ((int) ini_get('mbstring.func_overload')) & 2)
+    {
+      $mbEncoding = mb_internal_encoding();
+      mb_internal_encoding('ASCII');
+    }
+
+    switch ($value[0])
+    {
+      case '[':
+        $result = self::parseSequence($value);
+        break;
+      case '{':
+        $result = self::parseMapping($value);
+        break;
+      default:
+        $result = self::parseScalar($value);
+    }
+
+    if (isset($mbEncoding))
+    {
+      mb_internal_encoding($mbEncoding);
+    }
+
+    return $result;
+  }
+
+  /**
+   * Dumps a given PHP variable to a YAML string.
+   *
+   * @param mixed $value The PHP variable to convert
+   *
+   * @return string The YAML string representing the PHP array
+   */
+  static public function dump($value)
+  {
+    if ('1.1' === sfYaml::getSpecVersion())
+    {
+      $trueValues = array('true', 'on', '+', 'yes', 'y');
+      $falseValues = array('false', 'off', '-', 'no', 'n');
+    }
+    else
+    {
+      $trueValues = array('true');
+      $falseValues = array('false');
+    }
+
+    switch (true)
+    {
+      case is_resource($value):
+        throw new InvalidArgumentException('Unable to dump PHP resources in a YAML file.');
+      case is_object($value):
+        return '!!php/object:'.serialize($value);
+      case is_array($value):
+        return self::dumpArray($value);
+      case null === $value:
+        return 'null';
+      case true === $value:
+        return 'true';
+      case false === $value:
+        return 'false';
+      case ctype_digit($value):
+        return is_string($value) ? "'$value'" : (int) $value;
+      case is_numeric($value):
+        return is_infinite($value) ? str_ireplace('INF', '.Inf', strval($value)) : (is_string($value) ? "'$value'" : $value);
+      case false !== strpos($value, "\n") || false !== strpos($value, "\r"):
+        return sprintf('"%s"', str_replace(array('"', "\n", "\r"), array('\\"', '\n', '\r'), $value));
+      case preg_match('/[ \s \' " \: \{ \} \[ \] , & \* \# \?] | \A[ - ? | < > = ! % @ ` ]/x', $value):
+        return sprintf("'%s'", str_replace('\'', '\'\'', $value));
+      case '' == $value:
+        return "''";
+      case preg_match(self::getTimestampRegex(), $value):
+        return "'$value'";
+      case in_array(strtolower($value), $trueValues):
+        return "'$value'";
+      case in_array(strtolower($value), $falseValues):
+        return "'$value'";
+      case in_array(strtolower($value), array('null', '~')):
+        return "'$value'";
+      default:
+        return $value;
+    }
+  }
+
+  /**
+   * Dumps a PHP array to a YAML string.
+   *
+   * @param array $value The PHP array to dump
+   *
+   * @return string The YAML string representing the PHP array
+   */
+  static protected function dumpArray($value)
+  {
+    // array
+    $keys = array_keys($value);
+    if (
+      (1 == count($keys) && '0' == $keys[0])
+      ||
+      (count($keys) > 1 && array_reduce($keys, create_function('$v,$w', 'return (integer) $v + $w;'), 0) == count($keys) * (count($keys) - 1) / 2))
+    {
+      $output = array();
+      foreach ($value as $val)
+      {
+        $output[] = self::dump($val);
+      }
+
+      return sprintf('[%s]', implode(', ', $output));
+    }
+
+    // mapping
+    $output = array();
+    foreach ($value as $key => $val)
+    {
+      $output[] = sprintf('%s: %s', self::dump($key), self::dump($val));
+    }
+
+    return sprintf('{ %s }', implode(', ', $output));
+  }
+
+  /**
+   * Parses a scalar to a YAML string.
+   *
+   * @param scalar  $scalar
+   * @param string  $delimiters
+   * @param array   $stringDelimiter
+   * @param integer $i
+   * @param boolean $evaluate
+   *
+   * @return string A YAML string
+   */
+  static public function parseScalar($scalar, $delimiters = null, $stringDelimiters = array('"', "'"), &$i = 0, $evaluate = true)
+  {
+    if (in_array($scalar[$i], $stringDelimiters))
+    {
+      // quoted scalar
+      $output = self::parseQuotedScalar($scalar, $i);
+    }
+    else
+    {
+      // "normal" string
+      if (!$delimiters)
+      {
+        $output = substr($scalar, $i);
+        $i += strlen($output);
+
+        // remove comments
+        if (false !== $strpos = strpos($output, ' #'))
+        {
+          $output = rtrim(substr($output, 0, $strpos));
+        }
+      }
+      else if (preg_match('/^(.+?)('.implode('|', $delimiters).')/', substr($scalar, $i), $match))
+      {
+        $output = $match[1];
+        $i += strlen($output);
+      }
+      else
+      {
+        throw new InvalidArgumentException(sprintf('Malformed inline YAML string (%s).', $scalar));
+      }
+
+      $output = $evaluate ? self::evaluateScalar($output) : $output;
+    }
+
+    return $output;
+  }
+
+  /**
+   * Parses a quoted scalar to YAML.
+   *
+   * @param string  $scalar
+   * @param integer $i
+   *
+   * @return string A YAML string
+   */
+  static protected function parseQuotedScalar($scalar, &$i)
+  {
+    if (!preg_match('/'.self::REGEX_QUOTED_STRING.'/Au', substr($scalar, $i), $match))
+    {
+      throw new InvalidArgumentException(sprintf('Malformed inline YAML string (%s).', substr($scalar, $i)));
+    }
+
+    $output = substr($match[0], 1, strlen($match[0]) - 2);
+
+    if ('"' == $scalar[$i])
+    {
+      // evaluate the string
+      $output = str_replace(array('\\"', '\\n', '\\r'), array('"', "\n", "\r"), $output);
+    }
+    else
+    {
+      // unescape '
+      $output = str_replace('\'\'', '\'', $output);
+    }
+
+    $i += strlen($match[0]);
+
+    return $output;
+  }
+
+  /**
+   * Parses a sequence to a YAML string.
+   *
+   * @param string  $sequence
+   * @param integer $i
+   *
+   * @return string A YAML string
+   */
+  static protected function parseSequence($sequence, &$i = 0)
+  {
+    $output = array();
+    $len = strlen($sequence);
+    $i += 1;
+
+    // [foo, bar, ...]
+    while ($i < $len)
+    {
+      switch ($sequence[$i])
+      {
+        case '[':
+          // nested sequence
+          $output[] = self::parseSequence($sequence, $i);
+          break;
+        case '{':
+          // nested mapping
+          $output[] = self::parseMapping($sequence, $i);
+          break;
+        case ']':
+          return $output;
+        case ',':
+        case ' ':
+          break;
+        default:
+          $isQuoted = in_array($sequence[$i], array('"', "'"));
+          $value = self::parseScalar($sequence, array(',', ']'), array('"', "'"), $i);
+
+          if (!$isQuoted && false !== strpos($value, ': '))
+          {
+            // embedded mapping?
+            try
+            {
+              $value = self::parseMapping('{'.$value.'}');
+            }
+            catch (InvalidArgumentException $e)
+            {
+              // no, it's not
+            }
+          }
+
+          $output[] = $value;
+
+          --$i;
+      }
+
+      ++$i;
+    }
+
+    throw new InvalidArgumentException(sprintf('Malformed inline YAML string %s', $sequence));
+  }
+
+  /**
+   * Parses a mapping to a YAML string.
+   *
+   * @param string  $mapping
+   * @param integer $i
+   *
+   * @return string A YAML string
+   */
+  static protected function parseMapping($mapping, &$i = 0)
+  {
+    $output = array();
+    $len = strlen($mapping);
+    $i += 1;
+
+    // {foo: bar, bar:foo, ...}
+    while ($i < $len)
+    {
+      switch ($mapping[$i])
+      {
+        case ' ':
+        case ',':
+          ++$i;
+          continue 2;
+        case '}':
+          return $output;
+      }
+
+      // key
+      $key = self::parseScalar($mapping, array(':', ' '), array('"', "'"), $i, false);
+
+      // value
+      $done = false;
+      while ($i < $len)
+      {
+        switch ($mapping[$i])
+        {
+          case '[':
+            // nested sequence
+            $output[$key] = self::parseSequence($mapping, $i);
+            $done = true;
+            break;
+          case '{':
+            // nested mapping
+            $output[$key] = self::parseMapping($mapping, $i);
+            $done = true;
+            break;
+          case ':':
+          case ' ':
+            break;
+          default:
+            $output[$key] = self::parseScalar($mapping, array(',', '}'), array('"', "'"), $i);
+            $done = true;
+            --$i;
+        }
+
+        ++$i;
+
+        if ($done)
+        {
+          continue 2;
+        }
+      }
+    }
+
+    throw new InvalidArgumentException(sprintf('Malformed inline YAML string %s', $mapping));
+  }
+
+  /**
+   * Evaluates scalars and replaces magic values.
+   *
+   * @param string $scalar
+   *
+   * @return string A YAML string
+   */
+  static protected function evaluateScalar($scalar)
+  {
+    $scalar = trim($scalar);
+
+    if ('1.1' === sfYaml::getSpecVersion())
+    {
+      $trueValues = array('true', 'on', '+', 'yes', 'y');
+      $falseValues = array('false', 'off', '-', 'no', 'n');
+    }
+    else
+    {
+      $trueValues = array('true');
+      $falseValues = array('false');
+    }
+
+    switch (true)
+    {
+      case 'null' == strtolower($scalar):
+      case '' == $scalar:
+      case '~' == $scalar:
+        return null;
+      case 0 === strpos($scalar, '!str'):
+        return (string) substr($scalar, 5);
+      case 0 === strpos($scalar, '! '):
+        return intval(self::parseScalar(substr($scalar, 2)));
+      case 0 === strpos($scalar, '!!php/object:'):
+        return unserialize(substr($scalar, 13));
+      case ctype_digit($scalar):
+        $raw = $scalar;
+        $cast = intval($scalar);
+        return '0' == $scalar[0] ? octdec($scalar) : (((string) $raw == (string) $cast) ? $cast : $raw);
+      case in_array(strtolower($scalar), $trueValues):
+        return true;
+      case in_array(strtolower($scalar), $falseValues):
+        return false;
+      case is_numeric($scalar):
+        return '0x' == $scalar[0].$scalar[1] ? hexdec($scalar) : floatval($scalar);
+      case 0 == strcasecmp($scalar, '.inf'):
+      case 0 == strcasecmp($scalar, '.NaN'):
+        return -log(0);
+      case 0 == strcasecmp($scalar, '-.inf'):
+        return log(0);
+      case preg_match('/^(-|\+)?[0-9,]+(\.[0-9]+)?$/', $scalar):
+        return floatval(str_replace(',', '', $scalar));
+      case preg_match(self::getTimestampRegex(), $scalar):
+        return strtotime($scalar);
+      default:
+        return (string) $scalar;
+    }
+  }
+
+  static protected function getTimestampRegex()
+  {
+    return <<<EOF
+    ~^
+    (?P<year>[0-9][0-9][0-9][0-9])
+    -(?P<month>[0-9][0-9]?)
+    -(?P<day>[0-9][0-9]?)
+    (?:(?:[Tt]|[ \t]+)
+    (?P<hour>[0-9][0-9]?)
+    :(?P<minute>[0-9][0-9])
+    :(?P<second>[0-9][0-9])
+    (?:\.(?P<fraction>[0-9]*))?
+    (?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?)
+    (?::(?P<tz_minute>[0-9][0-9]))?))?)?
+    $~x
+EOF;
+  }
+}

test/lib/yaml/lib/sfYamlParser.php

@@ -0,0 +1,622 @@
+<?php
+
+/*
+ * This file is part of the symfony package.
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require_once(dirname(__FILE__).'/sfYamlInline.php');
+
+if (!defined('PREG_BAD_UTF8_OFFSET_ERROR'))
+{
+  define('PREG_BAD_UTF8_OFFSET_ERROR', 5);
+}
+
+/**
+ * sfYamlParser parses YAML strings to convert them to PHP arrays.
+ *
+ * @package    symfony
+ * @subpackage yaml
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ * @version    SVN: $Id: sfYamlParser.class.php 10832 2008-08-13 07:46:08Z fabien $
+ */
+class sfYamlParser
+{
+  protected
+    $offset        = 0,
+    $lines         = array(),
+    $currentLineNb = -1,
+    $currentLine   = '',
+    $refs          = array();
+
+  /**
+   * Constructor
+   *
+   * @param integer $offset The offset of YAML document (used for line numbers in error messages)
+   */
+  public function __construct($offset = 0)
+  {
+    $this->offset = $offset;
+  }
+
+  /**
+   * Parses a YAML string to a PHP value.
+   *
+   * @param  string $value A YAML string
+   *
+   * @return mixed  A PHP value
+   *
+   * @throws InvalidArgumentException If the YAML is not valid
+   */
+  public function parse($value)
+  {
+    $this->currentLineNb = -1;
+    $this->currentLine = '';
+    $this->lines = explode("\n", $this->cleanup($value));
+
+    if (function_exists('mb_internal_encoding') && ((int) ini_get('mbstring.func_overload')) & 2)
+    {
+      $mbEncoding = mb_internal_encoding();
+      mb_internal_encoding('UTF-8');
+    }
+
+    $data = array();
+    while ($this->moveToNextLine())
+    {
+      if ($this->isCurrentLineEmpty())
+      {
+        continue;
+      }
+
+      // tab?
+      if (preg_match('#^\t+#', $this->currentLine))
+      {
+        throw new InvalidArgumentException(sprintf('A YAML file cannot contain tabs as indentation at line %d (%s).', $this->getRealCurrentLineNb() + 1, $this->currentLine));
+      }
+
+      $isRef = $isInPlace = $isProcessed = false;
+      if (preg_match('#^\-((?P<leadspaces>\s+)(?P<value>.+?))?\s*$#u', $this->currentLine, $values))
+      {
+        if (isset($values['value']) && preg_match('#^&(?P<ref>[^ ]+) *(?P<value>.*)#u', $values['value'], $matches))
+        {
+          $isRef = $matches['ref'];
+          $values['value'] = $matches['value'];
+        }
+
+        // array
+        if (!isset($values['value']) || '' == trim($values['value'], ' ') || 0 === strpos(ltrim($values['value'], ' '), '#'))
+        {
+          $c = $this->getRealCurrentLineNb() + 1;
+          $parser = new sfYamlParser($c);
+          $parser->refs =& $this->refs;
+          $data[] = $parser->parse($this->getNextEmbedBlock());
+        }
+        else
+        {
+          if (isset($values['leadspaces'])
+            && ' ' == $values['leadspaces']
+            && preg_match('#^(?P<key>'.sfYamlInline::REGEX_QUOTED_STRING.'|[^ \'"\{].*?) *\:(\s+(?P<value>.+?))?\s*$#u', $values['value'], $matches))
+          {
+            // this is a compact notation element, add to next block and parse
+            $c = $this->getRealCurrentLineNb();
+            $parser = new sfYamlParser($c);
+            $parser->refs =& $this->refs;
+
+            $block = $values['value'];
+            if (!$this->isNextLineIndented())
+            {
+              $block .= "\n".$this->getNextEmbedBlock($this->getCurrentLineIndentation() + 2);
+            }
+
+            $data[] = $parser->parse($block);
+          }
+          else
+          {
+            $data[] = $this->parseValue($values['value']);
+          }
+        }
+      }
+      else if (preg_match('#^(?P<key>'.sfYamlInline::REGEX_QUOTED_STRING.'|[^ \'"].*?) *\:(\s+(?P<value>.+?))?\s*$#u', $this->currentLine, $values))
+      {
+        $key = sfYamlInline::parseScalar($values['key']);
+
+        if ('<<' === $key)
+        {
+          if (isset($values['value']) && '*' === substr($values['value'], 0, 1))
+          {
+            $isInPlace = substr($values['value'], 1);
+            if (!array_key_exists($isInPlace, $this->refs))
+            {
+              throw new InvalidArgumentException(sprintf('Reference "%s" does not exist at line %s (%s).', $isInPlace, $this->getRealCurrentLineNb() + 1, $this->currentLine));
+            }
+          }
+          else
+          {
+            if (isset($values['value']) && $values['value'] !== '')
+            {
+              $value = $values['value'];
+            }
+            else
+            {
+              $value = $this->getNextEmbedBlock();
+            }
+            $c = $this->getRealCurrentLineNb() + 1;
+            $parser = new sfYamlParser($c);
+            $parser->refs =& $this->refs;
+            $parsed = $parser->parse($value);
+
+            $merged = array();
+            if (!is_array($parsed))
+            {
+              throw new InvalidArgumentException(sprintf("YAML merge keys used with a scalar value instead of an array at line %s (%s)", $this->getRealCurrentLineNb() + 1, $this->currentLine));
+            }
+            else if (isset($parsed[0]))
+            {
+              // Numeric array, merge individual elements
+              foreach (array_reverse($parsed) as $parsedItem)
+              {
+                if (!is_array($parsedItem))
+                {
+                  throw new InvalidArgumentException(sprintf("Merge items must be arrays at line %s (%s).", $this->getRealCurrentLineNb() + 1, $parsedItem));
+                }
+                $merged = array_merge($parsedItem, $merged);
+              }
+            }
+            else
+            {
+              // Associative array, merge
+              $merged = array_merge($merge, $parsed);
+            }
+
+            $isProcessed = $merged;
+          }
+        }
+        else if (isset($values['value']) && preg_match('#^&(?P<ref>[^ ]+) *(?P<value>.*)#u', $values['value'], $matches))
+        {
+          $isRef = $matches['ref'];
+          $values['value'] = $matches['value'];
+        }
+
+        if ($isProcessed)
+        {
+          // Merge keys
+          $data = $isProcessed;
+        }
+        // hash
+        else if (!isset($values['value']) || '' == trim($values['value'], ' ') || 0 === strpos(ltrim($values['value'], ' '), '#'))
+        {
+          // if next line is less indented or equal, then it means that the current value is null
+          if ($this->isNextLineIndented())
+          {
+            $data[$key] = null;
+          }
+          else
+          {
+            $c = $this->getRealCurrentLineNb() + 1;
+            $parser = new sfYamlParser($c);
+            $parser->refs =& $this->refs;
+            $data[$key] = $parser->parse($this->getNextEmbedBlock());
+          }
+        }
+        else
+        {
+          if ($isInPlace)
+          {
+            $data = $this->refs[$isInPlace];
+          }
+          else
+          {
+            $data[$key] = $this->parseValue($values['value']);
+          }
+        }
+      }
+      else
+      {
+        // 1-liner followed by newline
+        if (2 == count($this->lines) && empty($this->lines[1]))
+        {
+          $value = sfYamlInline::load($this->lines[0]);
+          if (is_array($value))
+          {
+            $first = reset($value);
+            if ('*' === substr($first, 0, 1))
+            {
+              $data = array();
+              foreach ($value as $alias)
+              {
+                $data[] = $this->refs[substr($alias, 1)];
+              }
+              $value = $data;
+            }
+          }
+
+          if (isset($mbEncoding))
+          {
+            mb_internal_encoding($mbEncoding);
+          }
+
+          return $value;
+        }
+
+        switch (preg_last_error())
+        {
+          case PREG_INTERNAL_ERROR:
+            $error = 'Internal PCRE error on line';
+            break;
+          case PREG_BACKTRACK_LIMIT_ERROR:
+            $error = 'pcre.backtrack_limit reached on line';
+            break;
+          case PREG_RECURSION_LIMIT_ERROR:
+            $error = 'pcre.recursion_limit reached on line';
+            break;
+          case PREG_BAD_UTF8_ERROR:
+            $error = 'Malformed UTF-8 data on line';
+            break;
+          case PREG_BAD_UTF8_OFFSET_ERROR:
+            $error = 'Offset doesn\'t correspond to the begin of a valid UTF-8 code point on line';
+            break;
+          default:
+            $error = 'Unable to parse line';
+        }
+
+        throw new InvalidArgumentException(sprintf('%s %d (%s).', $error, $this->getRealCurrentLineNb() + 1, $this->currentLine));
+      }
+
+      if ($isRef)
+      {
+        $this->refs[$isRef] = end($data);
+      }
+    }
+
+    if (isset($mbEncoding))
+    {
+      mb_internal_encoding($mbEncoding);
+    }
+
+    return empty($data) ? null : $data;
+  }
+
+  /**
+   * Returns the current line number (takes the offset into account).
+   *
+   * @return integer The current line number
+   */
+  protected function getRealCurrentLineNb()
+  {
+    return $this->currentLineNb + $this->offset;
+  }
+
+  /**
+   * Returns the current line indentation.
+   *
+   * @return integer The current line indentation
+   */
+  protected function getCurrentLineIndentation()
+  {
+    return strlen($this->currentLine) - strlen(ltrim($this->currentLine, ' '));
+  }
+
+  /**
+   * Returns the next embed block of YAML.
+   *
+   * @param integer $indentation The indent level at which the block is to be read, or null for default
+   *
+   * @return string A YAML string
+   */
+  protected function getNextEmbedBlock($indentation = null)
+  {
+    $this->moveToNextLine();
+
+    if (null === $indentation)
+    {
+      $newIndent = $this->getCurrentLineIndentation();
+
+      if (!$this->isCurrentLineEmpty() && 0 == $newIndent)
+      {
+        throw new InvalidArgumentException(sprintf('Indentation problem at line %d (%s)', $this->getRealCurrentLineNb() + 1, $this->currentLine));
+      }
+    }
+    else
+    {
+      $newIndent = $indentation;
+    }
+
+    $data = array(substr($this->currentLine, $newIndent));
+
+    while ($this->moveToNextLine())
+    {
+      if ($this->isCurrentLineEmpty())
+      {
+        if ($this->isCurrentLineBlank())
+        {
+          $data[] = substr($this->currentLine, $newIndent);
+        }
+
+        continue;
+      }
+
+      $indent = $this->getCurrentLineIndentation();
+
+      if (preg_match('#^(?P<text> *)$#', $this->currentLine, $match))
+      {
+        // empty line
+        $data[] = $match['text'];
+      }
+      else if ($indent >= $newIndent)
+      {
+        $data[] = substr($this->currentLine, $newIndent);
+      }
+      else if (0 == $indent)
+      {
+        $this->moveToPreviousLine();
+
+        break;
+      }
+      else
+      {
+        throw new InvalidArgumentException(sprintf('Indentation problem at line %d (%s)', $this->getRealCurrentLineNb() + 1, $this->currentLine));
+      }
+    }
+
+    return implode("\n", $data);
+  }
+
+  /**
+   * Moves the parser to the next line.
+   */
+  protected function moveToNextLine()
+  {
+    if ($this->currentLineNb >= count($this->lines) - 1)
+    {
+      return false;
+    }
+
+    $this->currentLine = $this->lines[++$this->currentLineNb];
+
+    return true;
+  }
+
+  /**
+   * Moves the parser to the previous line.
+   */
+  protected function moveToPreviousLine()
+  {
+    $this->currentLine = $this->lines[--$this->currentLineNb];
+  }
+
+  /**
+   * Parses a YAML value.
+   *
+   * @param  string $value A YAML value
+   *
+   * @return mixed  A PHP value
+   */
+  protected function parseValue($value)
+  {
+    if ('*' === substr($value, 0, 1))
+    {
+      if (false !== $pos = strpos($value, '#'))
+      {
+        $value = substr($value, 1, $pos - 2);
+      }
+      else
+      {
+        $value = substr($value, 1);
+      }
+
+      if (!array_key_exists($value, $this->refs))
+      {
+        throw new InvalidArgumentException(sprintf('Reference "%s" does not exist (%s).', $value, $this->currentLine));
+      }
+      return $this->refs[$value];
+    }
+
+    if (preg_match('/^(?P<separator>\||>)(?P<modifiers>\+|\-|\d+|\+\d+|\-\d+|\d+\+|\d+\-)?(?P<comments> +#.*)?$/', $value, $matches))
+    {
+      $modifiers = isset($matches['modifiers']) ? $matches['modifiers'] : '';
+
+      return $this->parseFoldedScalar($matches['separator'], preg_replace('#\d+#', '', $modifiers), intval(abs($modifiers)));
+    }
+    else
+    {
+      return sfYamlInline::load($value);
+    }
+  }
+
+  /**
+   * Parses a folded scalar.
+   *
+   * @param  string  $separator   The separator that was used to begin this folded scalar (| or >)
+   * @param  string  $indicator   The indicator that was used to begin this folded scalar (+ or -)
+   * @param  integer $indentation The indentation that was used to begin this folded scalar
+   *
+   * @return string  The text value
+   */
+  protected function parseFoldedScalar($separator, $indicator = '', $indentation = 0)
+  {
+    $separator = '|' == $separator ? "\n" : ' ';
+    $text = '';
+
+    $notEOF = $this->moveToNextLine();
+
+    while ($notEOF && $this->isCurrentLineBlank())
+    {
+      $text .= "\n";
+
+      $notEOF = $this->moveToNextLine();
+    }
+
+    if (!$notEOF)
+    {
+      return '';
+    }
+
+    if (!preg_match('#^(?P<indent>'.($indentation ? str_repeat(' ', $indentation) : ' +').')(?P<text>.*)$#u', $this->currentLine, $matches))
+    {
+      $this->moveToPreviousLine();
+
+      return '';
+    }
+
+    $textIndent = $matches['indent'];
+    $previousIndent = 0;
+
+    $text .= $matches['text'].$separator;
+    while ($this->currentLineNb + 1 < count($this->lines))
+    {
+      $this->moveToNextLine();
+
+      if (preg_match('#^(?P<indent> {'.strlen($textIndent).',})(?P<text>.+)$#u', $this->currentLine, $matches))
+      {
+        if (' ' == $separator && $previousIndent != $matches['indent'])
+        {
+          $text = substr($text, 0, -1)."\n";
+        }
+        $previousIndent = $matches['indent'];
+
+        $text .= str_repeat(' ', $diff = strlen($matches['indent']) - strlen($textIndent)).$matches['text'].($diff ? "\n" : $separator);
+      }
+      else if (preg_match('#^(?P<text> *)$#', $this->currentLine, $matches))
+      {
+        $text .= preg_replace('#^ {1,'.strlen($textIndent).'}#', '', $matches['text'])."\n";
+      }
+      else
+      {
+        $this->moveToPreviousLine();
+
+        break;
+      }
+    }
+
+    if (' ' == $separator)
+    {
+      // replace last separator by a newline
+      $text = preg_replace('/ (\n*)$/', "\n$1", $text);
+    }
+
+    switch ($indicator)
+    {
+      case '':
+        $text = preg_replace('#\n+$#s', "\n", $text);
+        break;
+      case '+':
+        break;
+      case '-':
+        $text = preg_replace('#\n+$#s', '', $text);
+        break;
+    }
+
+    return $text;
+  }
+
+  /**
+   * Returns true if the next line is indented.
+   *
+   * @return Boolean Returns true if the next line is indented, false otherwise
+   */
+  protected function isNextLineIndented()
+  {
+    $currentIndentation = $this->getCurrentLineIndentation();
+    $notEOF = $this->moveToNextLine();
+
+    while ($notEOF && $this->isCurrentLineEmpty())
+    {
+      $notEOF = $this->moveToNextLine();
+    }
+
+    if (false === $notEOF)
+    {
+      return false;
+    }
+
+    $ret = false;
+    if ($this->getCurrentLineIndentation() <= $currentIndentation)
+    {
+      $ret = true;
+    }
+
+    $this->moveToPreviousLine();
+
+    return $ret;
+  }
+
+  /**
+   * Returns true if the current line is blank or if it is a comment line.
+   *
+   * @return Boolean Returns true if the current line is empty or if it is a comment line, false otherwise
+   */
+  protected function isCurrentLineEmpty()
+  {
+    return $this->isCurrentLineBlank() || $this->isCurrentLineComment();
+  }
+
+  /**
+   * Returns true if the current line is blank.
+   *
+   * @return Boolean Returns true if the current line is blank, false otherwise
+   */
+  protected function isCurrentLineBlank()
+  {
+    return '' == trim($this->currentLine, ' ');
+  }
+
+  /**
+   * Returns true if the current line is a comment line.
+   *
+   * @return Boolean Returns true if the current line is a comment line, false otherwise
+   */
+  protected function isCurrentLineComment()
+  {
+    //checking explicitly the first char of the trim is faster than loops or strpos
+    $ltrimmedLine = ltrim($this->currentLine, ' ');
+    return $ltrimmedLine[0] === '#';
+  }
+
+  /**
+   * Cleanups a YAML string to be parsed.
+   *
+   * @param  string $value The input YAML string
+   *
+   * @return string A cleaned up YAML string
+   */
+  protected function cleanup($value)
+  {
+    $value = str_replace(array("\r\n", "\r"), "\n", $value);
+
+    if (!preg_match("#\n$#", $value))
+    {
+      $value .= "\n";
+    }
+
+    // strip YAML header
+    $count = 0;
+    $value = preg_replace('#^\%YAML[: ][\d\.]+.*\n#su', '', $value, -1, $count);
+    $this->offset += $count;
+
+    // remove leading comments
+    $trimmedValue = preg_replace('#^(\#.*?\n)+#s', '', $value, -1, $count);
+    if ($count == 1)
+    {
+      // items have been removed, update the offset
+      $this->offset += substr_count($value, "\n") - substr_count($trimmedValue, "\n");
+      $value = $trimmedValue;
+    }
+
+    // remove start of the document marker (---)
+    $trimmedValue = preg_replace('#^\-\-\-.*?\n#s', '', $value, -1, $count);
+    if ($count == 1)
+    {
+      // items have been removed, update the offset
+      $this->offset += substr_count($value, "\n") - substr_count($trimmedValue, "\n");
+      $value = $trimmedValue;
+
+      // remove end of the document marker (...)
+      $value = preg_replace('#\.\.\.\s*$#s', '', $value);
+    }
+
+    return $value;
+  }
+}

test/lib/yaml/package.xml

@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<package packagerversion="1.4.1" version="2.0" xmlns="http://pear.php.net/dtd/package-2.0" xmlns:tasks="http://pear.php.net/dtd/tasks-1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://pear.php.net/dtd/tasks-1.0 http://pear.php.net/dtd/tasks-1.0.xsd http://pear.php.net/dtd/package-2.0 http://pear.php.net/dtd/package-2.0.xsd">
+ <name>YAML</name>
+ <channel>pear.symfony-project.com</channel>
+ <summary>The Symfony YAML Component.</summary>
+ <description>The Symfony YAML Component.</description>
+ <lead>
+  <name>Fabien Potencier</name>
+  <user>fabpot</user>
+  <email>fabien.potencier@symfony-project.org</email>
+  <active>yes</active>
+ </lead>
+ <date>2009-12-01</date>
+ <version>
+   <release>1.0.2</release>
+   <api>1.0.0</api>
+ </version>
+ <stability>
+  <release>stable</release>
+  <api>stable</api>
+ </stability>
+ <license uri="http://www.symfony-project.com/license">MIT license</license>
+ <notes>-</notes>
+ <contents>
+   <dir name="/">
+     <file name="README.markdown" role="doc" />
+     <file name="LICENSE" role="doc" />
+
+     <dir name="lib">
+       <file install-as="SymfonyComponents/YAML/sfYaml.php" name="sfYaml.php" role="php" />
+       <file install-as="SymfonyComponents/YAML/sfYamlDumper.php" name="sfYamlDumper.php" role="php" />
+       <file install-as="SymfonyComponents/YAML/sfYamlInline.php" name="sfYamlInline.php" role="php" />
+       <file install-as="SymfonyComponents/YAML/sfYamlParser.php" name="sfYamlParser.php" role="php" />
+     </dir>
+   </dir>
+ </contents>
+
+ <dependencies>
+  <required>
+   <php>
+    <min>5.2.4</min>
+   </php>
+   <pearinstaller>
+    <min>1.4.1</min>
+   </pearinstaller>
+  </required>
+ </dependencies>
+
+ <phprelease>
+ </phprelease>
+
+ <changelog>
+   <release>
+     <version>
+       <release>1.0.2</release>
+       <api>1.0.0</api>
+     </version>
+     <stability>
+       <release>stable</release>
+       <api>stable</api>
+     </stability>
+     <license uri="http://www.symfony-project.com/license">MIT license</license>
+     <date>2009-12-01</date>
+     <license>MIT</license>
+     <notes>
+       * fabien: fixed \ usage in quoted string
+     </notes>
+   </release>
+   <release>
+     <version>
+       <release>1.0.1</release>
+       <api>1.0.0</api>
+     </version>
+     <stability>
+       <release>stable</release>
+       <api>stable</api>
+     </stability>
+     <license uri="http://www.symfony-project.com/license">MIT license</license>
+     <date>2009-12-01</date>
+     <license>MIT</license>
+     <notes>
+       * fabien: fixed a possible loop in parsing a non-valid quoted string
+     </notes>
+   </release>
+   <release>
+     <version>
+       <release>1.0.0</release>
+       <api>1.0.0</api>
+     </version>
+     <stability>
+       <release>stable</release>
+       <api>stable</api>
+     </stability>
+     <license uri="http://www.symfony-project.com/license">MIT license</license>
+     <date>2009-11-30</date>
+     <license>MIT</license>
+     <notes>
+       * fabien: first stable release as a Symfony Component
+     </notes>
+   </release>
+ </changelog>
+</package>

test/spec

@@ -0,0 +1 @@
+Subproject commit 2d9859f72c8a80e1e528004a18721c97e8411fc9