1 files changed, 386 insertions, 88 deletions
diff --git a/Mustache/Parser.php b/Mustache/Parser.php
index 39911d6b..e5523b24 100644
--- a/Mustache/Parser.php
+++ b/Mustache/Parser.php
@@ -1,88 +1,386 @@
-<?php
-
-/*
- * This file is part of Mustache.php.
- *
- * (c) 2012 Justin Hileman
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-/**
- * Mustache Parser class.
- *
- * This class is responsible for turning a set of Mustache tokens into a parse tree.
- */
-class Mustache_Parser
-{
-
-    /**
-     * Process an array of Mustache tokens and convert them into a parse tree.
-     *
-     * @param array $tokens Set of Mustache tokens
-     *
-     * @return array Mustache token parse tree
-     */
-    public function parse(array $tokens = array())
-    {
-        return $this->buildTree(new ArrayIterator($tokens));
-    }
-
-    /**
-     * Helper method for recursively building a parse tree.
-     *
-     * @param ArrayIterator $tokens Stream of Mustache tokens
-     * @param array         $parent Parent token (default: null)
-     *
-     * @return array Mustache Token parse tree
-     *
-     * @throws LogicException when nesting errors or mismatched section tags are encountered.
-     */
-    private function buildTree(ArrayIterator $tokens, array $parent = null)
-    {
-        $nodes = array();
-
-        do {
-            $token = $tokens->current();
-            $tokens->next();
-
-            if ($token === null) {
-                continue;
-            } else {
-                switch ($token[Mustache_Tokenizer::TYPE]) {
-                    case Mustache_Tokenizer::T_SECTION:
-                    case Mustache_Tokenizer::T_INVERTED:
-                        $nodes[] = $this->buildTree($tokens, $token);
-                        break;
-
-                    case Mustache_Tokenizer::T_END_SECTION:
-                        if (!isset($parent)) {
-                            throw new LogicException('Unexpected closing tag: /'. $token[Mustache_Tokenizer::NAME]);
-                        }
-
-                        if ($token[Mustache_Tokenizer::NAME] !== $parent[Mustache_Tokenizer::NAME]) {
-                            throw new LogicException('Nesting error: ' . $parent[Mustache_Tokenizer::NAME] . ' vs. ' . $token[Mustache_Tokenizer::NAME]);
-                        }
-
-                        $parent[Mustache_Tokenizer::END]   = $token[Mustache_Tokenizer::INDEX];
-                        $parent[Mustache_Tokenizer::NODES] = $nodes;
-
-                        return $parent;
-                        break;
-
-                    default:
-                        $nodes[] = $token;
-                        break;
-                }
-            }
-
-        } while ($tokens->valid());
-
-        if (isset($parent)) {
-            throw new LogicException('Missing closing tag: ' . $parent[Mustache_Tokenizer::NAME]);
-        }
-
-        return $nodes;
-    }
-}
+<?php
+
+/*
+ * This file is part of Mustache.php.
+ *
+ * (c) 2010-2017 Justin Hileman
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+/**
+ * Mustache Parser class.
+ *
+ * This class is responsible for turning a set of Mustache tokens into a parse tree.
+ */
+class Mustache_Parser
+{
+    private $lineNum;
+    private $lineTokens;
+    private $pragmas;
+    private $defaultPragmas = array();
+
+    private $pragmaFilters;
+    private $pragmaBlocks;
+    private $pragmaDynamicNames;
+
+    /**
+     * Process an array of Mustache tokens and convert them into a parse tree.
+     *
+     * @param array $tokens Set of Mustache tokens
+     *
+     * @return array Mustache token parse tree
+     */
+    public function parse(array $tokens = array())
+    {
+        $this->lineNum    = -1;
+        $this->lineTokens = 0;
+        $this->pragmas    = $this->defaultPragmas;
+
+        $this->pragmaFilters      = isset($this->pragmas[Mustache_Engine::PRAGMA_FILTERS]);
+        $this->pragmaBlocks       = isset($this->pragmas[Mustache_Engine::PRAGMA_BLOCKS]);
+        $this->pragmaDynamicNames = isset($this->pragmas[Mustache_Engine::PRAGMA_DYNAMIC_NAMES]);
+
+        return $this->buildTree($tokens);
+    }
+
+    /**
+     * Enable pragmas across all templates, regardless of the presence of pragma
+     * tags in the individual templates.
+     *
+     * @internal Users should set global pragmas in Mustache_Engine, not here :)
+     *
+     * @param string[] $pragmas
+     */
+    public function setPragmas(array $pragmas)
+    {
+        $this->pragmas = array();
+        foreach ($pragmas as $pragma) {
+            $this->enablePragma($pragma);
+        }
+        $this->defaultPragmas = $this->pragmas;
+    }
+
+    /**
+     * Helper method for recursively building a parse tree.
+     *
+     * @throws Mustache_Exception_SyntaxException when nesting errors or mismatched section tags are encountered
+     *
+     * @param array &$tokens Set of Mustache tokens
+     * @param array $parent  Parent token (default: null)
+     *
+     * @return array Mustache Token parse tree
+     */
+    private function buildTree(array &$tokens, array $parent = null)
+    {
+        $nodes = array();
+
+        while (!empty($tokens)) {
+            $token = array_shift($tokens);
+
+            if ($token[Mustache_Tokenizer::LINE] === $this->lineNum) {
+                $this->lineTokens++;
+            } else {
+                $this->lineNum    = $token[Mustache_Tokenizer::LINE];
+                $this->lineTokens = 0;
+            }
+
+            if ($token[Mustache_Tokenizer::TYPE] !== Mustache_Tokenizer::T_COMMENT) {
+                if ($this->pragmaDynamicNames && isset($token[Mustache_Tokenizer::NAME])) {
+                    list($name, $isDynamic) = $this->getDynamicName($token);
+                    if ($isDynamic) {
+                        $token[Mustache_Tokenizer::NAME]    = $name;
+                        $token[Mustache_Tokenizer::DYNAMIC] = true;
+                    }
+                }
+
+                if ($this->pragmaFilters && isset($token[Mustache_Tokenizer::NAME])) {
+                    list($name, $filters) = $this->getNameAndFilters($token[Mustache_Tokenizer::NAME]);
+                    if (!empty($filters)) {
+                        $token[Mustache_Tokenizer::NAME]    = $name;
+                        $token[Mustache_Tokenizer::FILTERS] = $filters;
+                    }
+                }
+            }
+
+            switch ($token[Mustache_Tokenizer::TYPE]) {
+                case Mustache_Tokenizer::T_DELIM_CHANGE:
+                    $this->checkIfTokenIsAllowedInParent($parent, $token);
+                    $this->clearStandaloneLines($nodes, $tokens);
+                    break;
+
+                case Mustache_Tokenizer::T_SECTION:
+                case Mustache_Tokenizer::T_INVERTED:
+                    $this->checkIfTokenIsAllowedInParent($parent, $token);
+                    $this->clearStandaloneLines($nodes, $tokens);
+                    $nodes[] = $this->buildTree($tokens, $token);
+                    break;
+
+                case Mustache_Tokenizer::T_END_SECTION:
+                    if (!isset($parent)) {
+                        $msg = sprintf(
+                            'Unexpected closing tag: /%s on line %d',
+                            $token[Mustache_Tokenizer::NAME],
+                            $token[Mustache_Tokenizer::LINE]
+                        );
+                        throw new Mustache_Exception_SyntaxException($msg, $token);
+                    }
+
+                    $sameName = $token[Mustache_Tokenizer::NAME] !== $parent[Mustache_Tokenizer::NAME];
+                    $tokenDynamic = isset($token[Mustache_Tokenizer::DYNAMIC]) && $token[Mustache_Tokenizer::DYNAMIC];
+                    $parentDynamic = isset($parent[Mustache_Tokenizer::DYNAMIC]) && $parent[Mustache_Tokenizer::DYNAMIC];
+
+                    if ($sameName || ($tokenDynamic !== $parentDynamic)) {
+                        $msg = sprintf(
+                            'Nesting error: %s%s (on line %d) vs. %s%s (on line %d)',
+                            $parentDynamic ? '*' : '',
+                            $parent[Mustache_Tokenizer::NAME],
+                            $parent[Mustache_Tokenizer::LINE],
+                            $tokenDynamic ? '*' : '',
+                            $token[Mustache_Tokenizer::NAME],
+                            $token[Mustache_Tokenizer::LINE]
+                        );
+                        throw new Mustache_Exception_SyntaxException($msg, $token);
+                    }
+
+                    $this->clearStandaloneLines($nodes, $tokens);
+                    $parent[Mustache_Tokenizer::END]   = $token[Mustache_Tokenizer::INDEX];
+                    $parent[Mustache_Tokenizer::NODES] = $nodes;
+
+                    return $parent;
+
+                case Mustache_Tokenizer::T_PARTIAL:
+                    $this->checkIfTokenIsAllowedInParent($parent, $token);
+                    //store the whitespace prefix for laters!
+                    if ($indent = $this->clearStandaloneLines($nodes, $tokens)) {
+                        $token[Mustache_Tokenizer::INDENT] = $indent[Mustache_Tokenizer::VALUE];
+                    }
+                    $nodes[] = $token;
+                    break;
+
+                case Mustache_Tokenizer::T_PARENT:
+                    $this->checkIfTokenIsAllowedInParent($parent, $token);
+                    $nodes[] = $this->buildTree($tokens, $token);
+                    break;
+
+                case Mustache_Tokenizer::T_BLOCK_VAR:
+                    if ($this->pragmaBlocks) {
+                        // BLOCKS pragma is enabled, let's do this!
+                        if (isset($parent) && $parent[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_PARENT) {
+                            $token[Mustache_Tokenizer::TYPE] = Mustache_Tokenizer::T_BLOCK_ARG;
+                        }
+                        $this->clearStandaloneLines($nodes, $tokens);
+                        $nodes[] = $this->buildTree($tokens, $token);
+                    } else {
+                        // pretend this was just a normal "escaped" token...
+                        $token[Mustache_Tokenizer::TYPE] = Mustache_Tokenizer::T_ESCAPED;
+                        // TODO: figure out how to figure out if there was a space after this dollar:
+                        $token[Mustache_Tokenizer::NAME] = '$' . $token[Mustache_Tokenizer::NAME];
+                        $nodes[] = $token;
+                    }
+                    break;
+
+                case Mustache_Tokenizer::T_PRAGMA:
+                    $this->enablePragma($token[Mustache_Tokenizer::NAME]);
+                    // no break
+
+                case Mustache_Tokenizer::T_COMMENT:
+                    $this->clearStandaloneLines($nodes, $tokens);
+                    $nodes[] = $token;
+                    break;
+
+                default:
+                    $nodes[] = $token;
+                    break;
+            }
+        }
+
+        if (isset($parent)) {
+            $msg = sprintf(
+                'Missing closing tag: %s opened on line %d',
+                $parent[Mustache_Tokenizer::NAME],
+                $parent[Mustache_Tokenizer::LINE]
+            );
+            throw new Mustache_Exception_SyntaxException($msg, $parent);
+        }
+
+        return $nodes;
+    }
+
+    /**
+     * Clear standalone line tokens.
+     *
+     * Returns a whitespace token for indenting partials, if applicable.
+     *
+     * @param array $nodes  Parsed nodes
+     * @param array $tokens Tokens to be parsed
+     *
+     * @return array|null Resulting indent token, if any
+     */
+    private function clearStandaloneLines(array &$nodes, array &$tokens)
+    {
+        if ($this->lineTokens > 1) {
+            // this is the third or later node on this line, so it can't be standalone
+            return null;
+        }
+
+        $prev = null;
+        if ($this->lineTokens === 1) {
+            // this is the second node on this line, so it can't be standalone
+            // unless the previous node is whitespace.
+            if ($prev = end($nodes)) {
+                if (!$this->tokenIsWhitespace($prev)) {
+                    return null;
+                }
+            }
+        }
+
+        if ($next = reset($tokens)) {
+            // If we're on a new line, bail.
+            if ($next[Mustache_Tokenizer::LINE] !== $this->lineNum) {
+                return null;
+            }
+
+            // If the next token isn't whitespace, bail.
+            if (!$this->tokenIsWhitespace($next)) {
+                return null;
+            }
+
+            if (count($tokens) !== 1) {
+                // Unless it's the last token in the template, the next token
+                // must end in newline for this to be standalone.
+                if (substr($next[Mustache_Tokenizer::VALUE], -1) !== "\n") {
+                    return null;
+                }
+            }
+
+            // Discard the whitespace suffix
+            array_shift($tokens);
+        }
+
+        if ($prev) {
+            // Return the whitespace prefix, if any
+            return array_pop($nodes);
+        }
+		  return null;
+    }
+
+    /**
+     * Check whether token is a whitespace token.
+     *
+     * True if token type is T_TEXT and value is all whitespace characters.
+     *
+     * @param array $token
+     *
+     * @return bool True if token is a whitespace token
+     */
+    private function tokenIsWhitespace(array $token)
+    {
+        if ($token[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_TEXT) {
+            return preg_match('/^\s*$/', $token[Mustache_Tokenizer::VALUE]);
+        }
+
+        return false;
+    }
+
+    /**
+     * Check whether a token is allowed inside a parent tag.
+     *
+     * @throws Mustache_Exception_SyntaxException if an invalid token is found inside a parent tag
+     *
+     * @param array|null $parent
+     * @param array      $token
+     */
+    private function checkIfTokenIsAllowedInParent($parent, array $token)
+    {
+        if (isset($parent) && $parent[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_PARENT) {
+            throw new Mustache_Exception_SyntaxException('Illegal content in < parent tag', $token);
+        }
+    }
+
+    /**
+     * Parse dynamic names.
+     *
+     * @throws Mustache_Exception_SyntaxException when a tag does not allow *
+     * @throws Mustache_Exception_SyntaxException on multiple *s, or dots or filters with *
+     */
+    private function getDynamicName(array $token)
+    {
+        $name = $token[Mustache_Tokenizer::NAME];
+        $isDynamic = false;
+
+        if (preg_match('/^\s*\*\s*/', $name)) {
+            $this->ensureTagAllowsDynamicNames($token);
+            $name = preg_replace('/^\s*\*\s*/', '', $name);
+            $isDynamic = true;
+        }
+
+        return array($name, $isDynamic);
+    }
+
+    /**
+     * Check whether the given token supports dynamic tag names.
+     *
+     * @throws Mustache_Exception_SyntaxException when a tag does not allow *
+     *
+     * @param array $token
+     */
+    private function ensureTagAllowsDynamicNames(array $token)
+    {
+        switch ($token[Mustache_Tokenizer::TYPE]) {
+            case Mustache_Tokenizer::T_PARTIAL:
+            case Mustache_Tokenizer::T_PARENT:
+            case Mustache_Tokenizer::T_END_SECTION:
+                return;
+        }
+
+        $msg = sprintf(
+            'Invalid dynamic name: %s in %s tag',
+            $token[Mustache_Tokenizer::NAME],
+            Mustache_Tokenizer::getTagName($token[Mustache_Tokenizer::TYPE])
+        );
+
+        throw new Mustache_Exception_SyntaxException($msg, $token);
+    }
+
+
+    /**
+     * Split a tag name into name and filters.
+     *
+     * @param string $name
+     *
+     * @return array [Tag name, Array of filters]
+     */
+    private function getNameAndFilters($name)
+    {
+        $filters = array_map('trim', explode('|', $name));
+        $name    = array_shift($filters);
+
+        return array($name, $filters);
+    }
+
+    /**
+     * Enable a pragma.
+     *
+     * @param string $name
+     */
+    private function enablePragma($name)
+    {
+        $this->pragmas[$name] = true;
+
+        switch ($name) {
+            case Mustache_Engine::PRAGMA_BLOCKS:
+                $this->pragmaBlocks = true;
+                break;
+
+            case Mustache_Engine::PRAGMA_FILTERS:
+                $this->pragmaFilters = true;
+                break;
+
+            case Mustache_Engine::PRAGMA_DYNAMIC_NAMES:
+                $this->pragmaDynamicNames = true;
+                break;
+        }
+    }
+}