wp-studio 1.7.8-beta2 → 1.7.8-beta4

package/dist/cli/wp-files/sqlite-command/vendor/{mustache/mustache/src → wp-cli/mustache/src/Mustache}/Engine.php

@@ -3,28 +3,16 @@
 /*
  * This file is part of Mustache.php.
  *
- * (c) 2010-2025 Justin Hileman
+ * (c) 2010-2017 Justin Hileman
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
 
-namespace Mustache;
-
-use Mustache\Cache\FilesystemCache;
-use Mustache\Cache\NoopCache;
-use Mustache\Exception\InvalidArgumentException;
-use Mustache\Exception\RuntimeException;
-use Mustache\Exception\UnknownTemplateException;
-use Mustache\Loader\ArrayLoader;
-use Mustache\Loader\MutableLoader;
-use Mustache\Loader\StringLoader;
-use Psr\Log\LoggerInterface;
-
 /**
  * A Mustache implementation in PHP.
  *
- * {@link https://mustache.github.io}
+ * {@link http://defunkt.github.com/mustache}
  *
  * Mustache is a framework-agnostic logic-less templating language. It enforces separation of view
  * logic from template files. In fact, it is not even possible to embed logic in the template.
@@ -33,35 +21,32 @@ use Psr\Log\LoggerInterface;
  *
  * @author Justin Hileman {@link http://justinhileman.com}
  */
-class Engine
+class Mustache_Engine
 {
-    const VERSION      = '3.0.0';
-    const SPEC_VERSION = '1.4.3';
+    const VERSION      = '2.14.2';
+    const SPEC_VERSION = '1.3.0';
 
     const PRAGMA_FILTERS       = 'FILTERS';
+    const PRAGMA_BLOCKS        = 'BLOCKS';
     const PRAGMA_ANCHORED_DOT  = 'ANCHORED-DOT';
-
-    /**
-     * @deprecated PRAGMA_BLOCKS is now part of the Mustache spec, and is enabled by default
-     */
-    const PRAGMA_BLOCKS = 'BLOCKS';
+    const PRAGMA_DYNAMIC_NAMES = 'DYNAMIC-NAMES';
 
     // Known pragmas
-    private static $knownPragmas = [
+    private static $knownPragmas = array(
         self::PRAGMA_FILTERS       => true,
-        self::PRAGMA_ANCHORED_DOT  => true,
         self::PRAGMA_BLOCKS        => true,
-    ];
+        self::PRAGMA_ANCHORED_DOT  => true,
+        self::PRAGMA_DYNAMIC_NAMES => true,
+    );
 
     // Template cache
-    private $templates = [];
+    private $templates = array();
 
     // Environment
     private $templateClassPrefix = '__Mustache_';
     private $cache;
     private $lambdaCache;
     private $cacheLambdaTemplates = false;
-    private $doubleRenderLambdas = false;
     private $loader;
     private $partialsLoader;
     private $helpers;
@@ -69,16 +54,11 @@ class Engine
     private $entityFlags = ENT_COMPAT;
     private $charset = 'UTF-8';
     private $logger;
-    private $strictCallables = true;
-    private $pragmas = [];
+    private $strictCallables = false;
+    private $pragmas = array();
     private $delimiters;
     private $buggyPropertyShadowing = false;
 
-    // Optional Mustache specs
-    private $dynamicNames = true;
-    private $inheritance = true;
-    private $lambdas = true;
-
     // Services
     private $tokenizer;
     private $parser;
@@ -89,13 +69,13 @@ class Engine
      *
      * Passing an $options array allows overriding certain Mustache options during instantiation:
      *
-     *     $options = [
+     *     $options = array(
      *         // The class prefix for compiled templates. Defaults to '__Mustache_'.
      *         'template_class_prefix' => '__MyTemplates_',
      *
      *         // A Mustache cache instance or a cache directory string for compiled templates.
      *         // Mustache will not cache templates unless this is set.
-     *         'cache' => __DIR__.'/tmp/cache/mustache',
+     *         'cache' => dirname(__FILE__).'/tmp/cache/mustache',
      *
      *         // Override default permissions for cache files. Defaults to using the system-defined umask. It is
      *         // *strongly* recommended that you configure your umask properly rather than overriding permissions here.
@@ -114,21 +94,21 @@ class Engine
      *         'delimiters' => '<% %>',
      *
      *         // A Mustache template loader instance. Uses a StringLoader if not specified.
-     *         'loader' => new \Mustache\Loader\FilesystemLoader(__DIR__.'/views'),
+     *         'loader' => new Mustache_Loader_FilesystemLoader(dirname(__FILE__).'/views'),
      *
      *         // A Mustache loader instance for partials.
-     *         'partials_loader' => new \Mustache\Loader\FilesystemLoader(__DIR__.'/views/partials'),
+     *         'partials_loader' => new Mustache_Loader_FilesystemLoader(dirname(__FILE__).'/views/partials'),
      *
      *         // An array of Mustache partials. Useful for quick-and-dirty string template loading, but not as
      *         // efficient or lazy as a Filesystem (or database) loader.
-     *         'partials' => ['foo' => file_get_contents(__DIR__.'/views/partials/foo.mustache')],
+     *         'partials' => array('foo' => file_get_contents(dirname(__FILE__).'/views/partials/foo.mustache')),
      *
      *         // An array of 'helpers'. Helpers can be global variables or objects, closures (e.g. for higher order
      *         // sections), or any other valid Mustache context value. They will be prepended to the context stack,
      *         // so they will be available in any template loaded by this Mustache instance.
-     *         'helpers' => ['i18n' => function ($text) {
+     *         'helpers' => array('i18n' => function ($text) {
      *             // do something translatey here...
-     *         }],
+     *         }),
      *
      *         // An 'escape' callback, responsible for escaping double-mustache variables.
      *         'escape' => function ($value) {
@@ -144,83 +124,29 @@ class Engine
      *         // A Mustache Logger instance. No logging will occur unless this is set. Using a PSR-3 compatible
      *         // logging library -- such as Monolog -- is highly recommended. A simple stream logger implementation is
      *         // available as well:
-     *         'logger' => new \Mustache\Logger\StreamLogger('php://stderr'),
-     *
-     *
-     *         // OPTIONAL MUSTACHE FEATURES:
-     *
-     *         // Enable dynamic names. By default, variables and sections like `{{*name}}` will be resolved dynamically.
-     *         //
-     *         // To disable dynamic name resolution, set this to false.
-     *         'dynamic_names' => true,
-     *
-     *         // Enable template inheritance. By default, templates can extend other templates using the `{{< name}}` and
-     *         // `{{$ block}}` tags.
-     *         //
-     *         // To disable inheritance, set this to false.
-     *         'inheritance' => true,
-     *
-     *         // Enable lambda sections and values. By default, "lambdas" are enabled; if a variable resolves to a
-     *         // callable value, that callable is called before interpolation. If a section name resolves to a callable
-     *         // value, it is treated as a "higher order section", and the section content is passed to the callable
-     *         // for processing prior to rendering.
-     *         //
-     *         // Note that the FILTERS pragma requires lambdas to function, so using FILTERS without lambdas enabled
-     *         // will throw an invalid argument exception.
-     *         //
-     *         // To disable lambdas and higher order sections entirely, set this to false.
-     *         'lambdas' => true,
-     *
-     *         // Enable pragmas across all templates, regardless of the presence of pragma tags in the individual
-     *         // templates.
-     *         'pragmas' => [\Mustache\Engine::PRAGMA_FILTERS],
-     *
+     *         'logger' => new Mustache_Logger_StreamLogger('php://stderr'),
      *
-     *         // BACKWARDS COMPATIBILITY:
-     *
-     *         // Only treat \Closure instances and invokable classes as callable. If true, values like
-     *         // `['ClassName', 'methodName']` and `[$classInstance, 'methodName']`, which are traditionally
+     *         // Only treat Closure instances and invokable classes as callable. If true, values like
+     *         // `array('ClassName', 'methodName')` and `array($classInstance, 'methodName')`, which are traditionally
      *         // "callable" in PHP, are not called to resolve variables for interpolation or section contexts. This
      *         // helps protect against arbitrary code execution when user input is passed directly into the template.
-     *         //
-     *         // Defaults to true, but can be set to false to preserve Mustache.php v2.x behavior.
-     *         //
-     *         // THIS IS NOT RECOMMENDED.
+     *         // This currently defaults to false, but will default to true in v3.0.
      *         'strict_callables' => true,
      *
-     *         // Enable buggy property shadowing. Per the Mustache spec, keys of a value higher in the context stack
-     *         // shadow similarly named keys lower in the stack. For example, in the template
-     *         // `{{# foo }}{{ bar }}{{/ foo }}` if the value for `foo` has a method, property, or key named `bar`, it
-     *         // will prevent looking lower in the context stack for a another value named `bar`.
-     *         //
-     *         // Setting the value of an array key to null prevents lookups higher in the context stack. The behavior
-     *         // should have been identical for object properties (and ArrayAccess) as well, but a bug in the context
-     *         // lookup logic meant that a property which exists but is set to null would not prevent further context
-     *         // lookup.
-     *         //
-     *         // This bug was fixed in Mustache.php v3.x, but the previous buggy behavior can be preserved by setting this
-     *         // option to true.
-     *         //
-     *         // THIS IS NOT RECOMMENDED.
-     *         'buggy_property_shadowing' => false,
+     *         // Enable pragmas across all templates, regardless of the presence of pragma tags in the individual
+     *         // templates.
+     *         'pragmas' => [Mustache_Engine::PRAGMA_FILTERS],
+     *     );
      *
-     *         // Double-render lambda return values. By default, the return value of higher order sections that are
-     *         // rendered via the lambda helper will *not* be re-rendered.
-     *         //
-     *         // To preserve the behavior of Mustache.php v2.x, set this to true.
-     *         //
-     *         // THIS IS NOT RECOMMENDED.
-     *        'double_render_lambdas' => false,
-     *     ];
+     * @throws Mustache_Exception_InvalidArgumentException If `escape` option is not callable
      *
-     * @throws InvalidArgumentException If `escape` option is not callable
-     * @throws InvalidArgumentException If `lambdas` is disabled but the `FILTERS` pragma is enabled
+     * @param array $options (default: array())
      */
-    public function __construct(array $options = [])
+    public function __construct(array $options = array())
     {
         if (isset($options['template_class_prefix'])) {
             if ((string) $options['template_class_prefix'] === '') {
-                throw new InvalidArgumentException('Mustache Constructor "template_class_prefix" must not be empty');
+                throw new Mustache_Exception_InvalidArgumentException('Mustache Constructor "template_class_prefix" must not be empty');
             }
 
             $this->templateClassPrefix = $options['template_class_prefix'];
@@ -231,7 +157,7 @@ class Engine
 
             if (is_string($cache)) {
                 $mode  = isset($options['cache_file_mode']) ? $options['cache_file_mode'] : null;
-                $cache = new FilesystemCache($cache, $mode);
+                $cache = new Mustache_Cache_FilesystemCache($cache, $mode);
             }
 
             $this->setCache($cache);
@@ -259,7 +185,7 @@ class Engine
 
         if (isset($options['escape'])) {
             if (!is_callable($options['escape'])) {
-                throw new InvalidArgumentException('Mustache Constructor "escape" option must be callable');
+                throw new Mustache_Exception_InvalidArgumentException('Mustache Constructor "escape" option must be callable');
             }
 
             $this->escape = $options['escape'];
@@ -277,50 +203,26 @@ class Engine
             $this->setLogger($options['logger']);
         }
 
-        if (isset($options['delimiters'])) {
-            $this->delimiters = $options['delimiters'];
-        }
-
-        // Optional Mustache features
-
-        if (isset($options['dynamic_names'])) {
-            $this->dynamicNames = $options['dynamic_names'] !== false;
-        }
-
-        if (isset($options['inheritance'])) {
-            $this->inheritance = $options['inheritance'] !== false;
+        if (isset($options['strict_callables'])) {
+            $this->strictCallables = $options['strict_callables'];
         }
 
-        if (isset($options['lambdas'])) {
-            $this->lambdas = $options['lambdas'] !== false;
+        if (isset($options['delimiters'])) {
+            $this->delimiters = $options['delimiters'];
         }
 
         if (isset($options['pragmas'])) {
             foreach ($options['pragmas'] as $pragma) {
                 if (!isset(self::$knownPragmas[$pragma])) {
-                    throw new InvalidArgumentException(sprintf('Unknown pragma: "%s"', $pragma));
+                    throw new Mustache_Exception_InvalidArgumentException(sprintf('Unknown pragma: "%s".', $pragma));
                 }
                 $this->pragmas[$pragma] = true;
             }
         }
 
-        if (!$this->lambdas && isset($this->pragmas[self::PRAGMA_FILTERS])) {
-            throw new InvalidArgumentException('The FILTERS pragma requires lambda support');
-        }
-
-        // Backwards compatibility
-
-        if (isset($options['strict_callables'])) {
-            $this->strictCallables = (bool) $options['strict_callables'];
-        }
-
         if (isset($options['buggy_property_shadowing'])) {
             $this->buggyPropertyShadowing = (bool) $options['buggy_property_shadowing'];
         }
-
-        if (isset($options['double_render_lambdas'])) {
-            $this->doubleRenderLambdas = (bool) $options['double_render_lambdas'];
-        }
     }
 
     /**
@@ -328,14 +230,15 @@ class Engine
      *
      * Equivalent to calling `$mustache->loadTemplate($template)->render($context);`
      *
-     * @see Mustache\Engine::loadTemplate
-     * @see Mustache\Template::render
+     * @see Mustache_Engine::loadTemplate
+     * @see Mustache_Template::render
      *
      * @param string $template
+     * @param mixed  $context  (default: array())
      *
      * @return string Rendered template
      */
-    public function render($template, $context = [])
+    public function render($template, $context = array())
     {
         return $this->loadTemplate($template)->render($context);
     }
@@ -351,7 +254,7 @@ class Engine
     }
 
     /**
-     * Get the current Mustache entity type to escape.
+     * Get the current Mustache entitity type to escape.
      *
      * @return int
      */
@@ -370,46 +273,16 @@ class Engine
         return $this->charset;
     }
 
-    /**
-     * Check whether to double-render higher-order sections.
-     *
-     * By default, the return value of higher order sections that are rendered
-     * via the lambda helper will *not* be re-rendered. To preserve the
-     * behavior of Mustache.php v2.x, set this to true.
-     *
-     * THIS IS NOT RECOMMENDED.
-     */
-    public function getDoubleRenderLambdas()
-    {
-        return $this->doubleRenderLambdas;
-    }
-
     /**
      * Check whether to use buggy property shadowing.
      *
-     * THIS IS NOT RECOMMENDED.
-     *
      * See https://github.com/bobthecow/mustache.php/pull/410
      */
-    public function getBuggyPropertyShadowing()
+    public function useBuggyPropertyShadowing()
     {
         return $this->buggyPropertyShadowing;
     }
 
-    /**
-     * Get currently enabled optional features.
-     *
-     * @return array
-     */
-    public function getOptions()
-    {
-        return [
-            'dynamic_names' => $this->dynamicNames,
-            'inheritance' => $this->inheritance,
-            'lambdas' => $this->lambdas,
-        ];
-    }
-
     /**
      * Get the current globally enabled pragmas.
      *
@@ -422,8 +295,10 @@ class Engine
 
     /**
      * Set the Mustache template Loader instance.
+     *
+     * @param Mustache_Loader $loader
      */
-    public function setLoader(Loader $loader)
+    public function setLoader(Mustache_Loader $loader)
     {
         $this->loader = $loader;
     }
@@ -434,12 +309,12 @@ class Engine
      * If no Loader instance has been explicitly specified, this method will instantiate and return
      * a StringLoader instance.
      *
-     * @return Loader
+     * @return Mustache_Loader
      */
     public function getLoader()
     {
         if (!isset($this->loader)) {
-            $this->loader = new StringLoader();
+            $this->loader = new Mustache_Loader_StringLoader();
         }
 
         return $this->loader;
@@ -447,8 +322,10 @@ class Engine
 
     /**
      * Set the Mustache partials Loader instance.
+     *
+     * @param Mustache_Loader $partialsLoader
      */
-    public function setPartialsLoader(Loader $partialsLoader)
+    public function setPartialsLoader(Mustache_Loader $partialsLoader)
     {
         $this->partialsLoader = $partialsLoader;
     }
@@ -459,12 +336,12 @@ class Engine
      * If no Loader instance has been explicitly specified, this method will instantiate and return
      * an ArrayLoader instance.
      *
-     * @return Loader
+     * @return Mustache_Loader
      */
     public function getPartialsLoader()
     {
         if (!isset($this->partialsLoader)) {
-            $this->partialsLoader = new ArrayLoader();
+            $this->partialsLoader = new Mustache_Loader_ArrayLoader();
         }
 
         return $this->partialsLoader;
@@ -473,16 +350,18 @@ class Engine
     /**
      * Set partials for the current partials Loader instance.
      *
-     * @throws RuntimeException If the current Loader instance is immutable
+     * @throws Mustache_Exception_RuntimeException If the current Loader instance is immutable
+     *
+     * @param array $partials (default: array())
      */
-    public function setPartials(array $partials = [])
+    public function setPartials(array $partials = array())
     {
         if (!isset($this->partialsLoader)) {
-            $this->partialsLoader = new ArrayLoader();
+            $this->partialsLoader = new Mustache_Loader_ArrayLoader();
         }
 
-        if (!$this->partialsLoader instanceof MutableLoader) {
-            throw new RuntimeException('Unable to set partials on an immutable Mustache Loader instance');
+        if (!$this->partialsLoader instanceof Mustache_Loader_MutableLoader) {
+            throw new Mustache_Exception_RuntimeException('Unable to set partials on an immutable Mustache Loader instance');
         }
 
         $this->partialsLoader->setTemplates($partials);
@@ -495,14 +374,14 @@ class Engine
      * any other valid Mustache context value. They will be prepended to the context stack, so they will be available in
      * any template loaded by this Mustache instance.
      *
-     * @throws InvalidArgumentException if $helpers is not an array or \Traversable
+     * @throws Mustache_Exception_InvalidArgumentException if $helpers is not an array or Traversable
      *
-     * @param array|\Traversable $helpers
+     * @param array|Traversable $helpers
      */
     public function setHelpers($helpers)
     {
-        if (!is_array($helpers) && !$helpers instanceof \Traversable) {
-            throw new InvalidArgumentException('setHelpers expects an array of helpers');
+        if (!is_array($helpers) && !$helpers instanceof Traversable) {
+            throw new Mustache_Exception_InvalidArgumentException('setHelpers expects an array of helpers');
         }
 
         $this->getHelpers()->clear();
@@ -515,14 +394,14 @@ class Engine
     /**
      * Get the current set of Mustache helpers.
      *
-     * @see Mustache\Engine::setHelpers
+     * @see Mustache_Engine::setHelpers
      *
-     * @return HelperCollection
+     * @return Mustache_HelperCollection
      */
     public function getHelpers()
     {
         if (!isset($this->helpers)) {
-            $this->helpers = new HelperCollection();
+            $this->helpers = new Mustache_HelperCollection();
         }
 
         return $this->helpers;
@@ -531,7 +410,7 @@ class Engine
     /**
      * Add a new Mustache helper.
      *
-     * @see Mustache\Engine::setHelpers
+     * @see Mustache_Engine::setHelpers
      *
      * @param string $name
      * @param mixed  $helper
@@ -544,7 +423,7 @@ class Engine
     /**
      * Get a Mustache helper by name.
      *
-     * @see Mustache\Engine::setHelpers
+     * @see Mustache_Engine::setHelpers
      *
      * @param string $name
      *
@@ -558,7 +437,7 @@ class Engine
     /**
      * Check whether this Mustache instance has a helper.
      *
-     * @see Mustache\Engine::setHelpers
+     * @see Mustache_Engine::setHelpers
      *
      * @param string $name
      *
@@ -572,7 +451,7 @@ class Engine
     /**
      * Remove a helper by name.
      *
-     * @see Mustache\Engine::setHelpers
+     * @see Mustache_Engine::setHelpers
      *
      * @param string $name
      */
@@ -584,15 +463,14 @@ class Engine
     /**
      * Set the Mustache Logger instance.
      *
-     * @throws InvalidArgumentException If logger is not an instance of Mustache\Logger or Psr\Log\LoggerInterface
+     * @throws Mustache_Exception_InvalidArgumentException If logger is not an instance of Mustache_Logger or Psr\Log\LoggerInterface
      *
-     * @param Logger|LoggerInterface $logger
+     * @param Mustache_Logger|Psr\Log\LoggerInterface $logger
      */
     public function setLogger($logger = null)
     {
-        // n.b. this uses `is_a` to prevent a dependency on Psr\Log
-        if ($logger !== null && !$logger instanceof Logger && !is_a($logger, 'Psr\\Log\\LoggerInterface')) {
-            throw new InvalidArgumentException('Expected an instance of Mustache\\Logger or Psr\\Log\\LoggerInterface.');
+        if ($logger !== null && !($logger instanceof Mustache_Logger || is_a($logger, 'Psr\\Log\\LoggerInterface'))) {
+            throw new Mustache_Exception_InvalidArgumentException('Expected an instance of Mustache_Logger or Psr\\Log\\LoggerInterface.');
         }
 
         if ($this->getCache()->getLogger() === null) {
@@ -605,7 +483,7 @@ class Engine
     /**
      * Get the current Mustache Logger instance.
      *
-     * @return Logger|LoggerInterface
+     * @return Mustache_Logger|Psr\Log\LoggerInterface
      */
     public function getLogger()
     {
@@ -614,8 +492,10 @@ class Engine
 
     /**
      * Set the Mustache Tokenizer instance.
+     *
+     * @param Mustache_Tokenizer $tokenizer
      */
-    public function setTokenizer(Tokenizer $tokenizer)
+    public function setTokenizer(Mustache_Tokenizer $tokenizer)
     {
         $this->tokenizer = $tokenizer;
     }
@@ -625,12 +505,12 @@ class Engine
      *
      * If no Tokenizer instance has been explicitly specified, this method will instantiate and return a new one.
      *
-     * @return Tokenizer
+     * @return Mustache_Tokenizer
      */
     public function getTokenizer()
     {
         if (!isset($this->tokenizer)) {
-            $this->tokenizer = new Tokenizer();
+            $this->tokenizer = new Mustache_Tokenizer();
         }
 
         return $this->tokenizer;
@@ -638,8 +518,10 @@ class Engine
 
     /**
      * Set the Mustache Parser instance.
+     *
+     * @param Mustache_Parser $parser
      */
-    public function setParser(Parser $parser)
+    public function setParser(Mustache_Parser $parser)
     {
         $this->parser = $parser;
     }
@@ -649,12 +531,12 @@ class Engine
      *
      * If no Parser instance has been explicitly specified, this method will instantiate and return a new one.
      *
-     * @return Parser
+     * @return Mustache_Parser
      */
     public function getParser()
     {
         if (!isset($this->parser)) {
-            $this->parser = new Parser();
+            $this->parser = new Mustache_Parser();
         }
 
         return $this->parser;
@@ -662,8 +544,10 @@ class Engine
 
     /**
      * Set the Mustache Compiler instance.
+     *
+     * @param Mustache_Compiler $compiler
      */
-    public function setCompiler(Compiler $compiler)
+    public function setCompiler(Mustache_Compiler $compiler)
     {
         $this->compiler = $compiler;
     }
@@ -673,12 +557,12 @@ class Engine
      *
      * If no Compiler instance has been explicitly specified, this method will instantiate and return a new one.
      *
-     * @return Compiler
+     * @return Mustache_Compiler
      */
     public function getCompiler()
     {
         if (!isset($this->compiler)) {
-            $this->compiler = new Compiler();
+            $this->compiler = new Mustache_Compiler();
         }
 
         return $this->compiler;
@@ -686,8 +570,10 @@ class Engine
 
     /**
      * Set the Mustache Cache instance.
+     *
+     * @param Mustache_Cache $cache
      */
-    public function setCache(Cache $cache)
+    public function setCache(Mustache_Cache $cache)
     {
         if (isset($this->logger) && $cache->getLogger() === null) {
             $cache->setLogger($this->getLogger());
@@ -701,12 +587,12 @@ class Engine
      *
      * If no Cache instance has been explicitly specified, this method will instantiate and return a new one.
      *
-     * @return Cache
+     * @return Mustache_Cache
      */
     public function getCache()
     {
         if (!isset($this->cache)) {
-            $this->setCache(new NoopCache());
+            $this->setCache(new Mustache_Cache_NoopCache());
         }
 
         return $this->cache;
@@ -717,9 +603,9 @@ class Engine
      *
      * If 'cache_lambda_templates' is enabled, this is the default cache instance. Otherwise, it is a NoopCache.
      *
-     * @see Mustache\Engine::getCache
+     * @see Mustache_Engine::getCache
      *
-     * @return Cache
+     * @return Mustache_Cache
      */
     protected function getLambdaCache()
     {
@@ -728,7 +614,7 @@ class Engine
         }
 
         if (!isset($this->lambdaCache)) {
-            $this->lambdaCache = new NoopCache();
+            $this->lambdaCache = new Mustache_Cache_NoopCache();
         }
 
         return $this->lambdaCache;
@@ -740,7 +626,7 @@ class Engine
      * This method must be updated any time options are added which make it so
      * the same template could be parsed and compiled multiple different ways.
      *
-     * @param string|Source $source
+     * @param string|Mustache_Source $source
      *
      * @return string Mustache Template class name
      */
@@ -754,23 +640,22 @@ class Engine
         // 'default' escapes.
         //
         // Keep this list in alphabetical order :)
-        $chunks = [
+        $chunks = array(
             'charset'         => $this->charset,
-            'delimiters'      => $this->delimiters ?: '{{ }}',
+            'delimiters'      => $this->delimiters ? $this->delimiters : '{{ }}',
             'entityFlags'     => $this->entityFlags,
             'escape'          => isset($this->escape) ? 'custom' : 'default',
-            'key'             => ($source instanceof Source) ? $source->getKey() : 'source',
-            'options'         => $this->getOptions(),
+            'key'             => ($source instanceof Mustache_Source) ? $source->getKey() : 'source',
             'pragmas'         => $this->getPragmas(),
             'strictCallables' => $this->strictCallables,
             'version'         => self::VERSION,
-        ];
+        );
 
         $key = json_encode($chunks);
 
         // Template Source instances have already provided their own source key. For strings, just include the whole
         // source string in the md5 hash.
-        if (!$source instanceof Source) {
+        if (!$source instanceof Mustache_Source) {
             $key .= "\n" . $source;
         }
 
@@ -782,7 +667,7 @@ class Engine
      *
      * @param string $name
      *
-     * @return Template
+     * @return Mustache_Template
      */
     public function loadTemplate($name)
     {
@@ -797,26 +682,26 @@ class Engine
      *
      * @param string $name
      *
-     * @return Template
+     * @return Mustache_Template
      */
     public function loadPartial($name)
     {
         try {
             if (isset($this->partialsLoader)) {
                 $loader = $this->partialsLoader;
-            } elseif (isset($this->loader) && !$this->loader instanceof StringLoader) {
+            } elseif (isset($this->loader) && !$this->loader instanceof Mustache_Loader_StringLoader) {
                 $loader = $this->loader;
             } else {
-                throw new UnknownTemplateException($name);
+                throw new Mustache_Exception_UnknownTemplateException($name);
             }
 
             return $this->loadSource($loader->load($name));
-        } catch (UnknownTemplateException $e) {
+        } catch (Mustache_Exception_UnknownTemplateException $e) {
             // If the named partial cannot be found, log then return null.
             $this->log(
-                Logger::WARNING,
+                Mustache_Logger::WARNING,
                 'Partial not found: "{name}"',
-                ['name' => $e->getTemplateName()]
+                array('name' => $e->getTemplateName())
             );
         }
     }
@@ -830,7 +715,7 @@ class Engine
      * @param string $source
      * @param string $delims (default: null)
      *
-     * @return Template
+     * @return Mustache_Template
      */
     public function loadLambda($source, $delims = null)
     {
@@ -844,24 +729,24 @@ class Engine
     /**
      * Instantiate and return a Mustache Template instance by source.
      *
-     * Optionally provide a Mustache\Cache instance. This is used internally by Mustache\Engine::loadLambda to respect
+     * Optionally provide a Mustache_Cache instance. This is used internally by Mustache_Engine::loadLambda to respect
      * the 'cache_lambda_templates' configuration option.
      *
-     * @see Mustache\Engine::loadTemplate
-     * @see Mustache\Engine::loadPartial
-     * @see Mustache\Engine::loadLambda
+     * @see Mustache_Engine::loadTemplate
+     * @see Mustache_Engine::loadPartial
+     * @see Mustache_Engine::loadLambda
      *
-     * @param string|Source $source
-     * @param Cache         $cache  (default: null)
+     * @param string|Mustache_Source $source
+     * @param Mustache_Cache         $cache  (default: null)
      *
-     * @return Template
+     * @return Mustache_Template
      */
     private function loadSource($source, $cache = null)
     {
         $className = $this->getTemplateClassName($source);
 
         if (!isset($this->templates[$className])) {
-            if ($cache === null || !$cache instanceof Cache) {
+            if ($cache === null || ! $cache instanceof Mustache_Cache) {
                 $cache = $this->getCache();
             }
 
@@ -873,9 +758,9 @@ class Engine
             }
 
             $this->log(
-                Logger::DEBUG,
+                Mustache_Logger::DEBUG,
                 'Instantiating template: "{className}"',
-                ['className' => $className]
+                array('className' => $className)
             );
 
             $this->templates[$className] = new $className($this);
@@ -887,7 +772,7 @@ class Engine
     /**
      * Helper method to tokenize a Mustache template.
      *
-     * @see Mustache\Tokenizer::scan
+     * @see Mustache_Tokenizer::scan
      *
      * @param string $source
      *
@@ -901,7 +786,7 @@ class Engine
     /**
      * Helper method to parse a Mustache template.
      *
-     * @see Mustache\Parser::parse
+     * @see Mustache_Parser::parse
      *
      * @param string $source
      *
@@ -910,7 +795,6 @@ class Engine
     private function parse($source)
     {
         $parser = $this->getParser();
-        $parser->setOptions($this->getOptions());
         $parser->setPragmas($this->getPragmas());
 
         return $parser->parse($this->tokenize($source));
@@ -919,9 +803,9 @@ class Engine
     /**
      * Helper method to compile a Mustache template.
      *
-     * @see Mustache\Compiler::compile
+     * @see Mustache_Compiler::compile
      *
-     * @param string|Source $source
+     * @param string|Mustache_Source $source
      *
      * @return string generated Mustache template class code
      */
@@ -930,18 +814,17 @@ class Engine
         $name = $this->getTemplateClassName($source);
 
         $this->log(
-            Logger::INFO,
+            Mustache_Logger::INFO,
             'Compiling template to "{className}" class',
-            ['className' => $name]
+            array('className' => $name)
         );
 
-        if ($source instanceof Source) {
+        if ($source instanceof Mustache_Source) {
             $source = $source->getSource();
         }
         $tree = $this->parse($source);
 
         $compiler = $this->getCompiler();
-        $compiler->setOptions($this->getOptions());
         $compiler->setPragmas($this->getPragmas());
 
         return $compiler->compile($source, $tree, $name, isset($this->escape), $this->charset, $this->strictCallables, $this->entityFlags);
@@ -954,7 +837,7 @@ class Engine
      * @param string $message The log message
      * @param array  $context The log context
      */
-    private function log($level, $message, array $context = [])
+    private function log($level, $message, array $context = array())
     {
         if (isset($this->logger)) {
             $this->logger->log($level, $message, $context);