Merge branch 'release/0.5.0'

.gitmodules

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

Mustache.php

@@ -14,9 +14,6 @@
  */
 class Mustache {
 
-	public $_otag = '{{';
-	public $_ctag = '}}';
-
 	/**
 	 * Should this Mustache throw exceptions when it finds unexpected tags?
 	 *
@@ -85,6 +82,15 @@ class Mustache {
 	 */
 	const PRAGMA_UNESCAPED    = 'UNESCAPED';
 
+	/**
+	 * Constants used for section and tag RegEx
+	 */
+	const SECTION_TYPES = '\^#\/';
+	const TAG_TYPES = '#\^\/=!<>\\{&';
+
+	public $_otag = '{{';
+	public $_ctag = '}}';
+
 	protected $_tagRegEx;
 
 	protected $_template = '';
@@ -191,7 +197,7 @@ class Mustache {
 	 * @return string Rendered Mustache template.
 	 */
 	protected function _renderTemplate($template) {
-		$template = $this->_renderSection($template);
+		$template = $this->_renderSections($template);
 		return $this->_renderTags($template);
 	}
 
@@ -202,18 +208,9 @@ class Mustache {
 	 * @param string $template
 	 * @return string
 	 */
-	protected function _renderSection($template) {
-		$otag  = preg_quote($this->_otag, '/');
-		$ctag  = preg_quote($this->_ctag, '/');
-		$regex = '/' . $otag . '(\\^|\\#)\\s*(.+?)\\s*' . $ctag . '\\s*([\\s\\S]+?)' . $otag . '\\/\\s*\\2\\s*' . $ctag . '\\s*/ms';
-
-		$matches = array();
-		while (preg_match($regex, $template, $matches, PREG_OFFSET_CAPTURE)) {
-			$section  = $matches[0][0];
-			$offset   = $matches[0][1];
-			$type     = $matches[1][0];
-			$tag_name = trim($matches[2][0]);
-			$content  = $matches[3][0];
+	protected function _renderSections($template) {
+		while ($section_data = $this->_findSection($template)) {
+			list($section, $offset, $type, $tag_name, $content) = $section_data;
 
 			$replace = '';
 			$val = $this->_getVariable($tag_name);
@@ -267,6 +264,102 @@ class Mustache {
 		return $template;
 	}
 
+	/**
+	 * Prepare a section RegEx string for the given opening/closing tags.
+	 *
+	 * @access protected
+	 * @param string $otag
+	 * @param string $ctag
+	 * @return string
+	 */
+	protected function _prepareSectionRegEx($otag, $ctag) {
+		return sprintf(
+			'/(?:(?<=\\n)[ \\t]*)?%s(?<type>[%s])(?<tag_name>.+?)%s\\n?/s',
+			preg_quote($otag, '/'),
+			self::SECTION_TYPES,
+			preg_quote($ctag, '/')
+		);
+	}
+
+	/**
+	 * Extract a section from $template.
+	 *
+	 * This is a helper function to find sections needed by _renderSections.
+	 *
+	 * @access protected
+	 * @param string $template
+	 * @return array $section, $offset, $type, $tag_name and $content
+	 */
+	protected function _findSection($template) {
+		$regEx = $this->_prepareSectionRegEx($this->_otag, $this->_ctag);
+
+		$section_start = null;
+		$section_type  = null;
+		$content_start = null;
+
+		$search_offset = 0;
+
+		$section_stack = array();
+		$matches = array();
+		while (preg_match($regEx, $template, $matches, PREG_OFFSET_CAPTURE, $search_offset)) {
+
+			$match    = $matches[0][0];
+			$offset   = $matches[0][1];
+			$type     = $matches['type'][0];
+			$tag_name = trim($matches['tag_name'][0]);
+
+			$search_offset = $offset + strlen($match);
+
+			switch ($type) {
+				case '^':
+				case '#':
+					if (empty($section_stack)) {
+						$section_start = $offset;
+						$section_type  = $type;
+						$content_start = $search_offset;
+					}
+					array_push($section_stack, $tag_name);
+					break;
+				case '/':
+					if (empty($section_stack) || ($tag_name !== array_pop($section_stack))) {
+						if ($this->_throwsException(MustacheException::UNEXPECTED_CLOSE_SECTION)) {
+							throw new MustacheException('Unexpected close section: ' . $tag_name, MustacheException::UNEXPECTED_CLOSE_SECTION);
+						}
+					}
+
+					if (empty($section_stack)) {
+						$section = substr($template, $section_start, $search_offset - $section_start);
+						$content = substr($template, $content_start, $offset - $content_start);
+
+						return array($section, $section_start, $section_type, $tag_name, $content);
+					}
+					break;
+			}
+		}
+
+		if (!empty($section_stack)) {
+			if ($this->_throwsException(MustacheException::UNCLOSED_SECTION)) {
+				throw new MustacheException('Unclosed section: ' . $section_stack[0], MustacheException::UNCLOSED_SECTION);
+			}
+		}
+	}
+
+	/**
+	 * Prepare a pragma RegEx for the given opening/closing tags.
+	 *
+	 * @access protected
+	 * @param string $otag
+	 * @param string $ctag
+	 * @return string
+	 */
+	protected function _preparePragmaRegEx($otag, $ctag) {
+		return sprintf(
+			'/%s%%\\s*(?<pragma_name>[\\w_-]+)(?<options_string>(?: [\\w]+=[\\w]+)*)\\s*%s\\n?/s',
+			preg_quote($otag, '/'),
+			preg_quote($ctag, '/')
+		);
+	}
+
 	/**
 	 * Initialize pragmas and remove all pragma tags.
 	 *
@@ -282,10 +375,8 @@ class Mustache {
 			return $template;
 		}
 
-		$otag = preg_quote($this->_otag, '/');
-		$ctag = preg_quote($this->_ctag, '/');
-		$regex = '/' . $otag . '%\\s*([\\w_-]+)((?: [\\w]+=[\\w]+)*)\\s*' . $ctag . '\\n?/s';
-		return preg_replace_callback($regex, array($this, '_renderPragma'), $template);
+		$regEx = $this->_preparePragmaRegEx($this->_otag, $this->_ctag);
+		return preg_replace_callback($regEx, array($this, '_renderPragma'), $template);
 	}
 
 	/**
@@ -298,8 +389,8 @@ class Mustache {
 	 */
 	protected function _renderPragma($matches) {
 		$pragma         = $matches[0];
-		$pragma_name    = $matches[1];
-		$options_string = $matches[2];
+		$pragma_name    = $matches['pragma_name'];
+		$options_string = $matches['options_string'];
 
 		if (!in_array($pragma_name, $this->_pragmasImplemented)) {
 			throw new MustacheException('Unknown pragma: ' . $pragma_name, MustacheException::UNKNOWN_PRAGMA);
@@ -308,7 +399,7 @@ class Mustache {
 		$options = array();
 		foreach (explode(' ', trim($options_string)) as $o) {
 			if ($p = trim($o)) {
-				$p = explode('=', trim($p));
+				$p = explode('=', $p);
 				$options[$p[0]] = $p[1];
 			}
 		}
@@ -353,7 +444,6 @@ class Mustache {
 		return (is_array($this->_localPragmas[$pragma_name])) ? $this->_localPragmas[$pragma_name] : array();
 	}
 
-
 	/**
 	 * Check whether this Mustache instance throws a given exception.
 	 *
@@ -367,6 +457,23 @@ class Mustache {
 		return (isset($this->_throwsExceptions[$exception]) && $this->_throwsExceptions[$exception]);
 	}
 
+	/**
+	 * Prepare a tag RegEx for the given opening/closing tags.
+	 *
+	 * @access protected
+	 * @param string $otag
+	 * @param string $ctag
+	 * @return string
+	 */
+	protected function _prepareTagRegEx($otag, $ctag) {
+		return sprintf(
+			'/(?<whitespace>(?<=\\n)[ \\t]*)?%s(?<type>[%s]?)(?<tag_name>.+?)(?:\\2|})?%s(?:\\s*(?=\\n))?/s',
+			preg_quote($otag, '/'),
+			self::TAG_TYPES,
+			preg_quote($ctag, '/')
+		);
+	}
+
 	/**
 	 * Loop through and render individual Mustache tags.
 	 *
@@ -382,22 +489,31 @@ class Mustache {
 		$otag_orig = $this->_otag;
 		$ctag_orig = $this->_ctag;
 
-		$otag = preg_quote($this->_otag, '/');
-		$ctag = preg_quote($this->_ctag, '/');
-
-		$this->_tagRegEx = '/' . $otag . "([#\^\/=!<>\\{&])?(.+?)\\1?" . $ctag . "+/s";
+		$this->_tagRegEx = $this->_prepareTagRegEx($this->_otag, $this->_ctag);
 
 		$html = '';
 		$matches = array();
 		while (preg_match($this->_tagRegEx, $template, $matches, PREG_OFFSET_CAPTURE)) {
 			$tag      = $matches[0][0];
 			$offset   = $matches[0][1];
-			$modifier = $matches[1][0];
-			$tag_name = trim($matches[2][0]);
+			$modifier = $matches['type'][0];
+			$tag_name = trim($matches['tag_name'][0]);
+
+			if (isset($matches['whitespace']) && $matches['whitespace'][1] > -1) {
+				$whitespace = $matches['whitespace'][0];
+			} else {
+				$whitespace = null;
+			}
 
 			$html .= substr($template, 0, $offset);
-			$html .= $this->_renderTag($modifier, $tag_name);
-			$template = substr($template, $offset + strlen($tag));
+
+			$next_offset = $offset + strlen($tag);
+			if ((substr($html, -1) == "\n") && (substr($template, $next_offset, 1) == "\n")) {
+				$next_offset++;
+			}
+			$template = substr($template, $next_offset);
+
+			$html .= $this->_renderTag($modifier, $tag_name, $whitespace);
 		}
 
 		$this->_otag = $otag_orig;
@@ -418,23 +534,8 @@ class Mustache {
 	 * @throws MustacheException Unmatched section tag encountered.
 	 * @return string
 	 */
-	protected function _renderTag($modifier, $tag_name) {
+	protected function _renderTag($modifier, $tag_name, $whitespace) {
 		switch ($modifier) {
-			case '#':
-			case '^':
-				if ($this->_throwsException(MustacheException::UNCLOSED_SECTION)) {
-					throw new MustacheException('Unclosed section: ' . $tag_name, MustacheException::UNCLOSED_SECTION);
-				} else {
-					return '';
-				}
-				break;
-			case '/':
-				if ($this->_throwsException(MustacheException::UNEXPECTED_CLOSE_SECTION)) {
-					throw new MustacheException('Unexpected close section: ' . $tag_name, MustacheException::UNEXPECTED_CLOSE_SECTION);
-				} else {
-					return '';
-				}
-				break;
 			case '=':
 				return $this->_changeDelimiter($tag_name);
 				break;
@@ -443,9 +544,13 @@ class Mustache {
 				break;
 			case '>':
 			case '<':
-				return $this->_renderPartial($tag_name);
+				return $this->_renderPartial($tag_name, $whitespace);
 				break;
 			case '{':
+				// strip the trailing } ...
+				if ($tag_name[(strlen($tag_name) - 1)] == '}') {
+					$tag_name = substr($tag_name, 0, -1);
+				}
 			case '&':
 				if ($this->_hasPragma(self::PRAGMA_UNESCAPED)) {
 					return $this->_renderEscaped($tag_name);
@@ -453,6 +558,12 @@ class Mustache {
 					return $this->_renderUnescaped($tag_name);
 				}
 				break;
+			case '#':
+			case '^':
+			case '/':
+				// remove any leftovers from _renderSections
+				return '';
+				break;
 		}
 
 		if ($this->_hasPragma(self::PRAGMA_UNESCAPED)) {
@@ -502,9 +613,10 @@ class Mustache {
 	 * @param string $tag_name
 	 * @return string
 	 */
-	protected function _renderPartial($tag_name) {
+	protected function _renderPartial($tag_name, $whitespace = '') {
 		$view = clone($this);
-		return $view->render($this->_getPartial($tag_name));
+
+		return $whitespace . preg_replace('/\n(?!$)/s', "\n" . $whitespace, $view->render($this->_getPartial($tag_name)));
 	}
 
 	/**
@@ -516,13 +628,12 @@ class Mustache {
 	 * @return string
 	 */
 	protected function _changeDelimiter($tag_name) {
-		$tags = explode(' ', $tag_name);
-		$this->_otag = $tags[0];
-		$this->_ctag = $tags[1];
+		list($otag, $ctag) = explode(' ', $tag_name);
+		$this->_otag = $otag;
+		$this->_ctag = $ctag;
+
+		$this->_tagRegEx = $this->_prepareTagRegEx($this->_otag, $this->_ctag);
 
-		$otag  = preg_quote($this->_otag, '/');
-		$ctag  = preg_quote($this->_ctag, '/');
-		$this->_tagRegEx = '/' . $otag . "([#\^\/=!<>\\{&])?(.+?)\\1?" . $ctag . "+/s";
 		return '';
 	}
 
@@ -542,7 +653,6 @@ class Mustache {
 		$this->_context = $new;
 	}
 
-
 	/**
 	 * Remove the latest context from the stack.
 	 *
@@ -575,7 +685,7 @@ class Mustache {
 	 * @return string
 	 */
 	protected function _getVariable($tag_name) {
-		if ($this->_hasPragma(self::PRAGMA_DOT_NOTATION) && $tag_name != '.') {
+		if ($tag_name != '.' && strpos($tag_name, '.') !== false && $this->_hasPragma(self::PRAGMA_DOT_NOTATION)) {
 			$chunks = explode('.', $tag_name);
 			$first = array_shift($chunks);
 

README.markdown

@@ -81,9 +81,8 @@ And render it:
 Known Issues
 ------------
 
- * Sections don't respect delimiter changes -- `delimiters` example currently fails with an
+ * Things get weird when you change delimiters inside a section -- `delimiters` example currently fails with an
    "unclosed section" exception.
- * Mustache isn't always very good at whitespace.
 
 
 See Also

examples/complex/complex.mustache

@@ -1,16 +1,16 @@
 <h1>{{header}}</h1>
 {{#notEmpty}}
-  <ul>
-  {{#item}}
-    {{#current}}
-      <li><strong>{{name}}</strong></li>
-    {{/current}}
-    {{^current}}
-      <li><a href="{{url}}">{{name}}</a></li>
-    {{/current}}
-  {{/item}}
-  </ul>
+<ul>
+{{#item}}
+{{#current}}
+    <li><strong>{{name}}</strong></li>
+{{/current}}
+{{^current}}
+    <li><a href="{{url}}">{{name}}</a></li>
+{{/current}}
+{{/item}}
+</ul>
 {{/notEmpty}}
 {{#isEmpty}}
-  <p>The list is empty.</p>
+<p>The list is empty.</p>
 {{/isEmpty}}

examples/complex/complex.txt

@@ -1,6 +1,6 @@
 <h1>Colors</h1>
 <ul>
-  <li><strong>red</strong></li>
+    <li><strong>red</strong></li>
     <li><a href="#Green">green</a></li>
     <li><a href="#Blue">blue</a></li>
-    </ul>
+</ul>

examples/double_section/double_section.mustache

@@ -1,7 +1,7 @@
 {{#t}}
-  * first
+* first
 {{/t}}
 * {{two}}
 {{#t}}
-  * third
+* third
 {{/t}}

examples/grand_parent_context/grand_parent_context.mustache

@@ -1,10 +1,7 @@
 {{grand_parent_id}}
 {{#parent_contexts}}
-{{grand_parent_id}}
-{{parent_id}}
-{{#child_contexts}}
-{{grand_parent_id}}
-{{parent_id}}
-{{child_id}}
-{{/child_contexts}}
+  {{parent_id}} ({{grand_parent_id}})
+  {{#child_contexts}}
+    {{child_id}} ({{parent_id}} << {{grand_parent_id}})
+  {{/child_contexts}}
 {{/parent_contexts}}

examples/grand_parent_context/grand_parent_context.txt

@@ -1,17 +1,7 @@
 grand_parent1
-grand_parent1
-parent1
-grand_parent1
-parent1
-parent1-child1
-grand_parent1
-parent1
-parent1-child2
-grand_parent1
-parent2
-grand_parent1
-parent2
-parent2-child1
-grand_parent1
-parent2
-parent2-child2
+  parent1 (grand_parent1)
+    parent1-child1 (parent1 << grand_parent1)
+    parent1-child2 (parent1 << grand_parent1)
+  parent2 (grand_parent1)
+    parent2-child1 (parent2 << grand_parent1)
+    parent2-child2 (parent2 << grand_parent1)

examples/inverted_double_section/inverted_double_section.mustache

@@ -1,7 +1,7 @@
 {{^t}}
-  * first
+* first
 {{/t}}
 * {{two}}
 {{^t}}
-  * third
+* third
 {{/t}}

examples/sections_nested/SectionsNested.php

@@ -0,0 +1,33 @@
+<?php
+
+class SectionsNested extends Mustache {
+	public $name = 'Little Mac';
+
+	public function enemies() {
+		return array(
+			array(
+				'name' => 'Von Kaiser',
+				'enemies' => array(
+					array('name' => 'Super Macho Man'),
+					array('name' => 'Piston Honda'),
+					array('name' => 'Mr. Sandman'),
+				)
+			),
+			array(
+				'name' => 'Mike Tyson',
+				'enemies' => array(
+					array('name' => 'Soda Popinski'),
+					array('name' => 'King Hippo'),
+					array('name' => 'Great Tiger'),
+					array('name' => 'Glass Joe'),
+				)
+			),
+			array(
+				'name' => 'Don Flamenco',
+				'enemies' => array(
+					array('name' => 'Bald Bull'),
+				)
+			),
+		);
+	}
+}

examples/sections_nested/sections_nested.mustache

@@ -0,0 +1,7 @@
+Enemies of {{ name }}:
+{{# enemies }}
+{{ name }} ... who also has enemies:
+{{# enemies }}
+--> {{ name }}
+{{/ enemies }}
+{{/ enemies }}

examples/sections_nested/sections_nested.txt

@@ -0,0 +1,12 @@
+Enemies of Little Mac:
+Von Kaiser ... who also has enemies:
+--> Super Macho Man
+--> Piston Honda
+--> Mr. Sandman
+Mike Tyson ... who also has enemies:
+--> Soda Popinski
+--> King Hippo
+--> Great Tiger
+--> Glass Joe
+Don Flamenco ... who also has enemies:
+--> Bald Bull

examples/sections_spaces/SectionsSpaces.php

@@ -1,14 +0,0 @@
-<?php
-
-class SectionsSpaces extends Mustache {
-	public $start = "It worked the first time.";
-
-	public function middle() {
-		return array(
-			array('item' => "And it worked the second time."),
-			array('item' => "As well as the third."),
-		);
-	}
-
-	public $final = "Then, surprisingly, it worked the final time.";
-}

examples/sections_spaces/sections_spaces.mustache

@@ -1,9 +0,0 @@
- * {{ start }}
-{{# middle }}
- * {{ item }}
-{{/ middle }}
- * {{ final }}
-
- * {{ start }}
-{{# middle }} * {{ item }}{{/ middle }}
- * {{ final }}

examples/sections_spaces/sections_spaces.txt

@@ -1,9 +0,0 @@
- * It worked the first time.
- * And it worked the second time.
- * As well as the third.
- * Then, surprisingly, it worked the final time.
-
- * It worked the first time.
- * And it worked the second time.
- * As well as the third.
- * Then, surprisingly, it worked the final time.

test/MustacheExceptionTest.php

@@ -15,6 +15,7 @@ class MustacheExceptionTest extends PHPUnit_Framework_TestCase {
 	}
 
 	/**
+	 * @group interpolation
 	 * @expectedException MustacheException
 	 */
 	public function testThrowsUnknownVariableException() {
@@ -22,6 +23,7 @@ class MustacheExceptionTest extends PHPUnit_Framework_TestCase {
 	}
 
 	/**
+	 * @group sections
 	 * @expectedException MustacheException
 	 */
 	public function testThrowsUnclosedSectionException() {
@@ -29,6 +31,15 @@ class MustacheExceptionTest extends PHPUnit_Framework_TestCase {
 	}
 
 	/**
+	 * @group sections
+	 * @expectedException MustacheException
+	 */
+	public function testThrowsUnclosedInvertedSectionException() {
+		$this->pickyMustache->render('{{^unclosed}}');
+	}
+
+	/**
+	 * @group sections
 	 * @expectedException MustacheException
 	 */
 	public function testThrowsUnexpectedCloseSectionException() {
@@ -36,6 +47,7 @@ class MustacheExceptionTest extends PHPUnit_Framework_TestCase {
 	}
 
 	/**
+	 * @group partials
 	 * @expectedException MustacheException
 	 */
 	public function testThrowsUnknownPartialException() {
@@ -43,25 +55,36 @@ class MustacheExceptionTest extends PHPUnit_Framework_TestCase {
 	}
 
 	/**
+	 * @group pragmas
 	 * @expectedException MustacheException
 	 */
 	public function testThrowsUnknownPragmaException() {
 		$this->pickyMustache->render('{{%SWEET-MUSTACHE-BRO}}');
 	}
 
+	/**
+	 * @group sections
+	 */
 	public function testDoesntThrowUnclosedSectionException() {
 		$this->assertEquals('', $this->slackerMustache->render('{{#unclosed}}'));
 	}
 
+	/**
+	 * @group sections
+	 */
 	public function testDoesntThrowUnexpectedCloseSectionException() {
 		$this->assertEquals('', $this->slackerMustache->render('{{/unopened}}'));
 	}
 
+	/**
+	 * @group partials
+	 */
 	public function testDoesntThrowUnknownPartialException() {
 		$this->assertEquals('', $this->slackerMustache->render('{{>impartial}}'));
 	}
 
 	/**
+	 * @group pragmas
 	 * @expectedException MustacheException
 	 */
 	public function testGetPragmaOptionsThrowsExceptionsIfItThinksYouHaveAPragmaButItTurnsOutYouDont() {

test/MustacheObjectSectionTest.php

@@ -2,6 +2,9 @@
 
 require_once '../Mustache.php';
 
+/**
+ * @group sections
+ */
 class MustacheObjectSectionTest extends PHPUnit_Framework_TestCase {
 	public function testBasicObject() {
 		$alpha = new Alpha();

test/MustachePragmaDotNotationTest.php

@@ -2,6 +2,9 @@
 
 require_once '../Mustache.php';
 
+/**
+ * @group pragmas
+ */
 class MustachePragmaDotNotationTest extends PHPUnit_Framework_TestCase {
 
 	public function testDotTraversal() {

test/MustachePragmaImplicitIteratorTest.php

@@ -2,13 +2,20 @@
 
 require_once '../Mustache.php';
 
+/**
+ * @group pragmas
+ */
 class MustachePragmaImplicitIteratorTest extends PHPUnit_Framework_TestCase {
 
 	public function testEnablePragma() {
 		$m = $this->getMock('Mustache', array('_renderPragma'), array('{{%IMPLICIT-ITERATOR}}'));
 		$m->expects($this->exactly(1))
 			->method('_renderPragma')
-			->with(array('{{%IMPLICIT-ITERATOR}}', 'IMPLICIT-ITERATOR', null));
+			->with(array(
+				0 => '{{%IMPLICIT-ITERATOR}}',
+				1 => 'IMPLICIT-ITERATOR', 'pragma_name' => 'IMPLICIT-ITERATOR',
+				2 => null, 'options_string' => null
+			));
 		$m->render();
 	}
 
@@ -47,4 +54,34 @@ class MustachePragmaImplicitIteratorTest extends PHPUnit_Framework_TestCase {
 		$this->assertEquals('foobarbaz', $m->render('{{%IMPLICIT-ITERATOR iterator=i}}{{%DOT-NOTATION}}{{#items}}{{i.name}}{{/items}}'));
 	}
 
+	/**
+	 * @dataProvider recursiveSectionData
+	 */
+	public function testRecursiveSections($template, $view, $result) {
+		$m = new Mustache();
+		$this->assertEquals($result, $m->render($template, $view));
+	}
+
+	public function recursiveSectionData() {
+		return array(
+			array(
+				'{{%IMPLICIT-ITERATOR}}{{#items}}{{#.}}{{.}}{{/.}}{{/items}}',
+				array('items' => array(array('a', 'b', 'c'), array('d', 'e', 'f'))),
+				'abcdef'
+			),
+			array(
+				'{{%IMPLICIT-ITERATOR}}{{#items}}{{#.}}{{#.}}{{.}}{{/.}}{{/.}}{{/items}}',
+				array('items' => array(array(array('a', 'b'), array('c')), array(array('d'), array('e', 'f')))),
+				'abcdef'
+			),
+			array(
+				'{{%IMPLICIT-ITERATOR}}{{#items}}{{#.}}{{#items}}{{.}}{{/items}}{{/.}}{{/items}}',
+				array('items' => array(
+					array('items' => array('a', 'b', 'c')),
+					array('items' => array('d', 'e', 'f')),
+				)),
+				'abcdef'
+			),
+		);
+	}
 }

test/MustachePragmaTest.php

@@ -2,6 +2,9 @@
 
 require_once '../Mustache.php';
 
+/**
+ * @group pragmas
+ */
 class MustachePragmaTest extends PHPUnit_Framework_TestCase {
 
 	public function testUnknownPragmaException() {

test/MustachePragmaUnescapedTest.php

@@ -2,6 +2,9 @@
 
 require_once '../Mustache.php';
 
+/**
+ * @group pragmas
+ */
 class MustachePragmaUnescapedTest extends PHPUnit_Framework_TestCase {
 
 	public function testPragmaUnescaped() {

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/MustacheTest.php

@@ -37,7 +37,6 @@ class MustacheTest extends PHPUnit_Framework_TestCase {
 
 	protected $knownIssues = array(
 		'Delimiters'     => "Known issue: sections don't respect delimiter changes",
-		'SectionsSpaces' => "Known issue: Mustache fails miserably at whitespace",
 	);
 
 	/**
@@ -132,8 +131,7 @@ class MustacheTest extends PHPUnit_Framework_TestCase {
 	/**
 	 * Test render() with data.
 	 *
-	 * @access public
-	 * @return void
+	 * @group interpolation
 	 */
 	public function testRenderWithData() {
 		$m = new Mustache('{{first_name}} {{last_name}}');
@@ -141,6 +139,9 @@ class MustacheTest extends PHPUnit_Framework_TestCase {
 		$this->assertEquals('Zappa, Frank', $m->render('{{last_name}}, {{first_name}}', array('first_name' => 'Frank', 'last_name' => 'Zappa')));
 	}
 
+	/**
+	 * @group partials
+	 */
 	public function testRenderWithPartials() {
 		$m = new Mustache('{{>stache}}', null, array('stache' => '{{first_name}} {{last_name}}'));
 		$this->assertEquals('Charlie Chaplin', $m->render(null, array('first_name' => 'Charlie', 'last_name' => 'Chaplin')));
@@ -150,8 +151,7 @@ class MustacheTest extends PHPUnit_Framework_TestCase {
 	/**
 	 * Mustache should allow newlines (and other whitespace) in comments and all other tags.
 	 *
-	 * @access public
-	 * @return void
+	 * @group comments
 	 */
 	public function testNewlinesInComments() {
 		$m = new Mustache("{{! comment \n \t still a comment... }}");
@@ -160,9 +160,6 @@ class MustacheTest extends PHPUnit_Framework_TestCase {
 
 	/**
 	 * Mustache should return the same thing when invoked multiple times.
-	 *
-	 * @access public
-	 * @return void
 	 */
 	public function testMultipleInvocations() {
 		$m = new Mustache('x');
@@ -176,8 +173,7 @@ class MustacheTest extends PHPUnit_Framework_TestCase {
 	/**
 	 * Mustache should return the same thing when invoked multiple times.
 	 *
-	 * @access public
-	 * @return void
+	 * @group interpolation
 	 */
 	public function testMultipleInvocationsWithTags() {
 		$m = new Mustache('{{one}} {{two}}', array('one' => 'foo', 'two' => 'bar'));
@@ -190,9 +186,6 @@ class MustacheTest extends PHPUnit_Framework_TestCase {
 
 	/**
 	 * Mustache should not use templates passed to the render() method for subsequent invocations.
-	 *
-	 * @access public
-	 * @return void
 	 */
 	public function testResetTemplateForMultipleInvocations() {
 		$m = new Mustache('Sirve.');
@@ -205,15 +198,14 @@ class MustacheTest extends PHPUnit_Framework_TestCase {
 	}
 
 	/**
-	 * testClone function.
+	 * Test the __clone() magic function.
 	 *
 	 * @group examples
 	 * @dataProvider getExamples
-	 * @access public
+	 *
 	 * @param string $class
 	 * @param string $template
 	 * @param string $output
-	 * @return void
 	 */
 	public function test__clone($class, $template, $output) {
 		if (isset($this->knownIssues[$class])) {
@@ -240,11 +232,10 @@ class MustacheTest extends PHPUnit_Framework_TestCase {
 	 *
 	 * @group examples
 	 * @dataProvider getExamples
-	 * @access public
+	 *
 	 * @param string $class
 	 * @param string $template
 	 * @param string $output
-	 * @return void
 	 */
 	public function testExamples($class, $template, $output) {
 		if (isset($this->knownIssues[$class])) {
@@ -266,7 +257,6 @@ class MustacheTest extends PHPUnit_Framework_TestCase {
 	 * This whole mess will be refined later to be more intuitive and less prescriptive, but it'll
 	 * do for now. Especially since it means we can have unit tests :)
 	 *
-	 * @access public
 	 * @return array
 	 */
 	public function getExamples() {
@@ -317,6 +307,9 @@ class MustacheTest extends PHPUnit_Framework_TestCase {
 		return $ret;
 	}
 
+	/**
+	 * @group delimiters
+	 */
 	public function testCrazyDelimiters() {
 		$m = new Mustache(null, array('result' => 'success'));
 		$this->assertEquals('success', $m->render('{{=[[ ]]=}}[[ result ]]'));
@@ -327,10 +320,50 @@ class MustacheTest extends PHPUnit_Framework_TestCase {
 		$this->assertEquals('success', $m->render('{{=// \\\\}}// result \\\\'));
 	}
 
+	/**
+	 * @group delimiters
+	 */
 	public function testResetDelimiters() {
 		$m = new Mustache(null, array('result' => 'success'));
 		$this->assertEquals('success', $m->render('{{=[[ ]]=}}[[ result ]]'));
 		$this->assertEquals('success', $m->render('{{=<< >>=}}<< result >>'));
 		$this->assertEquals('success', $m->render('{{=<% %>=}}<% result %>'));
 	}
+
+	/**
+	 * @group sections
+	 * @dataProvider poorlyNestedSections
+	 * @expectedException MustacheException
+	 */
+	public function testPoorlyNestedSections($template) {
+		$m = new Mustache($template);
+		$m->render();
+	}
+
+	public function poorlyNestedSections() {
+		return array(
+			array('{{#foo}}'),
+			array('{{#foo}}{{/bar}}'),
+			array('{{#foo}}{{#bar}}{{/foo}}'),
+			array('{{#foo}}{{#bar}}{{/foo}}{{/bar}}'),
+			array('{{#foo}}{{/bar}}{{/foo}}'),
+		);
+	}
+
+	/**
+	 * Ensure that Mustache doesn't double-render sections (allowing mustache injection).
+	 *
+	 * @group sections
+	 */
+	public function testMustacheInjection() {
+		$template = '{{#foo}}{{bar}}{{/foo}}';
+		$view = array(
+			'foo' => true,
+			'bar' => '{{win}}',
+			'win' => 'FAIL',
+		);
+
+		$m = new Mustache($template, $view);
+		$this->assertEquals('{{win}}', $m->render());
+	}
 }

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/phpunit.xml

@@ -3,4 +3,8 @@
 	<testsuite name="Mustache">
 		<directory>./</directory>
 	</testsuite>
+	<blacklist>
+		<directory suffix=".php">../examples</directory>
+		<directory suffix=".php">./</directory>
+	</blacklist>
 </phpunit>

test/spec

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