wp-studio 1.8.1 → 1.8.2

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

@@ -3,16 +3,28 @@
 /*
  * This file is part of Mustache.php.
  *
- * (c) 2010-2017 Justin Hileman
+ * (c) 2010-2025 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 http://defunkt.github.com/mustache}
+ * {@link https://mustache.github.io}
  *
  * 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.
@@ -21,30 +33,35 @@
  *
  * @author Justin Hileman {@link http://justinhileman.com}
  */
-class Mustache_Engine
+class Engine
 {
-    const VERSION        = '2.14.2';
-    const SPEC_VERSION   = '1.2.2';
+    const VERSION      = '3.0.0';
+    const SPEC_VERSION = '1.4.3';
+
+    const PRAGMA_FILTERS       = 'FILTERS';
+    const PRAGMA_ANCHORED_DOT  = 'ANCHORED-DOT';
 
-    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';
 
     // Known pragmas
-    private static $knownPragmas = array(
-        self::PRAGMA_FILTERS      => true,
-        self::PRAGMA_BLOCKS       => true,
-        self::PRAGMA_ANCHORED_DOT => true,
-    );
+    private static $knownPragmas = [
+        self::PRAGMA_FILTERS       => true,
+        self::PRAGMA_ANCHORED_DOT  => true,
+        self::PRAGMA_BLOCKS        => true,
+    ];
 
     // Template cache
-    private $templates = array();
+    private $templates = [];
 
     // Environment
     private $templateClassPrefix = '__Mustache_';
     private $cache;
     private $lambdaCache;
     private $cacheLambdaTemplates = false;
+    private $doubleRenderLambdas = false;
     private $loader;
     private $partialsLoader;
     private $helpers;
@@ -52,9 +69,15 @@ class Mustache_Engine
     private $entityFlags = ENT_COMPAT;
     private $charset = 'UTF-8';
     private $logger;
-    private $strictCallables = false;
-    private $pragmas = array();
+    private $strictCallables = true;
+    private $pragmas = [];
     private $delimiters;
+    private $buggyPropertyShadowing = false;
+
+    // Optional Mustache specs
+    private $dynamicNames = true;
+    private $inheritance = true;
+    private $lambdas = true;
 
     // Services
     private $tokenizer;
@@ -66,13 +89,13 @@ class Mustache_Engine
      *
      * Passing an $options array allows overriding certain Mustache options during instantiation:
      *
-     *     $options = array(
+     *     $options = [
      *         // 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' => dirname(__FILE__).'/tmp/cache/mustache',
+     *         'cache' => __DIR__.'/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.
@@ -91,21 +114,21 @@ class Mustache_Engine
      *         'delimiters' => '<% %>',
      *
      *         // A Mustache template loader instance. Uses a StringLoader if not specified.
-     *         'loader' => new Mustache_Loader_FilesystemLoader(dirname(__FILE__).'/views'),
+     *         'loader' => new \Mustache\Loader\FilesystemLoader(__DIR__.'/views'),
      *
      *         // A Mustache loader instance for partials.
-     *         'partials_loader' => new Mustache_Loader_FilesystemLoader(dirname(__FILE__).'/views/partials'),
+     *         'partials_loader' => new \Mustache\Loader\FilesystemLoader(__DIR__.'/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' => array('foo' => file_get_contents(dirname(__FILE__).'/views/partials/foo.mustache')),
+     *         'partials' => ['foo' => file_get_contents(__DIR__.'/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' => array('i18n' => function ($text) {
+     *         'helpers' => ['i18n' => function ($text) {
      *             // do something translatey here...
-     *         }),
+     *         }],
      *
      *         // An 'escape' callback, responsible for escaping double-mustache variables.
      *         'escape' => function ($value) {
@@ -121,29 +144,83 @@ class Mustache_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'),
+     *         '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],
+     *
+     *
+     *         // BACKWARDS COMPATIBILITY:
      *
-     *         // Only treat Closure instances and invokable classes as callable. If true, values like
-     *         // `array('ClassName', 'methodName')` and `array($classInstance, 'methodName')`, which are traditionally
+     *         // Only treat \Closure instances and invokable classes as callable. If true, values like
+     *         // `['ClassName', 'methodName']` and `[$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.
-     *         // This currently defaults to false, but will default to true in v3.0.
+     *         //
+     *         // Defaults to true, but can be set to false to preserve Mustache.php v2.x behavior.
+     *         //
+     *         // THIS IS NOT RECOMMENDED.
      *         'strict_callables' => true,
      *
-     *         // Enable pragmas across all templates, regardless of the presence of pragma tags in the individual
-     *         // templates.
-     *         'pragmas' => [Mustache_Engine::PRAGMA_FILTERS],
-     *     );
+     *         // 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,
      *
-     * @throws Mustache_Exception_InvalidArgumentException If `escape` option is not callable
+     *         // 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,
+     *     ];
      *
-     * @param array $options (default: array())
+     * @throws InvalidArgumentException If `escape` option is not callable
+     * @throws InvalidArgumentException If `lambdas` is disabled but the `FILTERS` pragma is enabled
      */
-    public function __construct(array $options = array())
+    public function __construct(array $options = [])
     {
         if (isset($options['template_class_prefix'])) {
             if ((string) $options['template_class_prefix'] === '') {
-                throw new Mustache_Exception_InvalidArgumentException('Mustache Constructor "template_class_prefix" must not be empty');
+                throw new InvalidArgumentException('Mustache Constructor "template_class_prefix" must not be empty');
             }
 
             $this->templateClassPrefix = $options['template_class_prefix'];
@@ -154,7 +231,7 @@ class Mustache_Engine
 
             if (is_string($cache)) {
                 $mode  = isset($options['cache_file_mode']) ? $options['cache_file_mode'] : null;
-                $cache = new Mustache_Cache_FilesystemCache($cache, $mode);
+                $cache = new FilesystemCache($cache, $mode);
             }
 
             $this->setCache($cache);
@@ -182,7 +259,7 @@ class Mustache_Engine
 
         if (isset($options['escape'])) {
             if (!is_callable($options['escape'])) {
-                throw new Mustache_Exception_InvalidArgumentException('Mustache Constructor "escape" option must be callable');
+                throw new InvalidArgumentException('Mustache Constructor "escape" option must be callable');
             }
 
             $this->escape = $options['escape'];
@@ -200,22 +277,50 @@ class Mustache_Engine
             $this->setLogger($options['logger']);
         }
 
-        if (isset($options['strict_callables'])) {
-            $this->strictCallables = $options['strict_callables'];
-        }
-
         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['lambdas'])) {
+            $this->lambdas = $options['lambdas'] !== false;
+        }
+
         if (isset($options['pragmas'])) {
             foreach ($options['pragmas'] as $pragma) {
                 if (!isset(self::$knownPragmas[$pragma])) {
-                    throw new Mustache_Exception_InvalidArgumentException(sprintf('Unknown pragma: "%s".', $pragma));
+                    throw new 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'];
+        }
     }
 
     /**
@@ -223,15 +328,14 @@ class Mustache_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 = array())
+    public function render($template, $context = [])
     {
         return $this->loadTemplate($template)->render($context);
     }
@@ -247,7 +351,7 @@ class Mustache_Engine
     }
 
     /**
-     * Get the current Mustache entitity type to escape.
+     * Get the current Mustache entity type to escape.
      *
      * @return int
      */
@@ -266,6 +370,46 @@ class Mustache_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()
+    {
+        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.
      *
@@ -278,10 +422,8 @@ class Mustache_Engine
 
     /**
      * Set the Mustache template Loader instance.
-     *
-     * @param Mustache_Loader $loader
      */
-    public function setLoader(Mustache_Loader $loader)
+    public function setLoader(Loader $loader)
     {
         $this->loader = $loader;
     }
@@ -292,12 +434,12 @@ class Mustache_Engine
      * If no Loader instance has been explicitly specified, this method will instantiate and return
      * a StringLoader instance.
      *
-     * @return Mustache_Loader
+     * @return Loader
      */
     public function getLoader()
     {
         if (!isset($this->loader)) {
-            $this->loader = new Mustache_Loader_StringLoader();
+            $this->loader = new StringLoader();
         }
 
         return $this->loader;
@@ -305,10 +447,8 @@ class Mustache_Engine
 
     /**
      * Set the Mustache partials Loader instance.
-     *
-     * @param Mustache_Loader $partialsLoader
      */
-    public function setPartialsLoader(Mustache_Loader $partialsLoader)
+    public function setPartialsLoader(Loader $partialsLoader)
     {
         $this->partialsLoader = $partialsLoader;
     }
@@ -319,12 +459,12 @@ class Mustache_Engine
      * If no Loader instance has been explicitly specified, this method will instantiate and return
      * an ArrayLoader instance.
      *
-     * @return Mustache_Loader
+     * @return Loader
      */
     public function getPartialsLoader()
     {
         if (!isset($this->partialsLoader)) {
-            $this->partialsLoader = new Mustache_Loader_ArrayLoader();
+            $this->partialsLoader = new ArrayLoader();
         }
 
         return $this->partialsLoader;
@@ -333,18 +473,16 @@ class Mustache_Engine
     /**
      * Set partials for the current partials Loader instance.
      *
-     * @throws Mustache_Exception_RuntimeException If the current Loader instance is immutable
-     *
-     * @param array $partials (default: array())
+     * @throws RuntimeException If the current Loader instance is immutable
      */
-    public function setPartials(array $partials = array())
+    public function setPartials(array $partials = [])
     {
         if (!isset($this->partialsLoader)) {
-            $this->partialsLoader = new Mustache_Loader_ArrayLoader();
+            $this->partialsLoader = new ArrayLoader();
         }
 
-        if (!$this->partialsLoader instanceof Mustache_Loader_MutableLoader) {
-            throw new Mustache_Exception_RuntimeException('Unable to set partials on an immutable Mustache Loader instance');
+        if (!$this->partialsLoader instanceof MutableLoader) {
+            throw new RuntimeException('Unable to set partials on an immutable Mustache Loader instance');
         }
 
         $this->partialsLoader->setTemplates($partials);
@@ -357,14 +495,14 @@ class Mustache_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 Mustache_Exception_InvalidArgumentException if $helpers is not an array or Traversable
+     * @throws 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 Mustache_Exception_InvalidArgumentException('setHelpers expects an array of helpers');
+        if (!is_array($helpers) && !$helpers instanceof \Traversable) {
+            throw new InvalidArgumentException('setHelpers expects an array of helpers');
         }
 
         $this->getHelpers()->clear();
@@ -377,14 +515,14 @@ class Mustache_Engine
     /**
      * Get the current set of Mustache helpers.
      *
-     * @see Mustache_Engine::setHelpers
+     * @see Mustache\Engine::setHelpers
      *
-     * @return Mustache_HelperCollection
+     * @return HelperCollection
      */
     public function getHelpers()
     {
         if (!isset($this->helpers)) {
-            $this->helpers = new Mustache_HelperCollection();
+            $this->helpers = new HelperCollection();
         }
 
         return $this->helpers;
@@ -393,7 +531,7 @@ class Mustache_Engine
     /**
      * Add a new Mustache helper.
      *
-     * @see Mustache_Engine::setHelpers
+     * @see Mustache\Engine::setHelpers
      *
      * @param string $name
      * @param mixed  $helper
@@ -406,7 +544,7 @@ class Mustache_Engine
     /**
      * Get a Mustache helper by name.
      *
-     * @see Mustache_Engine::setHelpers
+     * @see Mustache\Engine::setHelpers
      *
      * @param string $name
      *
@@ -420,7 +558,7 @@ class Mustache_Engine
     /**
      * Check whether this Mustache instance has a helper.
      *
-     * @see Mustache_Engine::setHelpers
+     * @see Mustache\Engine::setHelpers
      *
      * @param string $name
      *
@@ -434,7 +572,7 @@ class Mustache_Engine
     /**
      * Remove a helper by name.
      *
-     * @see Mustache_Engine::setHelpers
+     * @see Mustache\Engine::setHelpers
      *
      * @param string $name
      */
@@ -446,14 +584,15 @@ class Mustache_Engine
     /**
      * Set the Mustache Logger instance.
      *
-     * @throws Mustache_Exception_InvalidArgumentException If logger is not an instance of Mustache_Logger or Psr\Log\LoggerInterface
+     * @throws InvalidArgumentException If logger is not an instance of Mustache\Logger or Psr\Log\LoggerInterface
      *
-     * @param Mustache_Logger|Psr\Log\LoggerInterface $logger
+     * @param Logger|LoggerInterface $logger
      */
     public function setLogger($logger = null)
     {
-        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.');
+        // 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 ($this->getCache()->getLogger() === null) {
@@ -466,7 +605,7 @@ class Mustache_Engine
     /**
      * Get the current Mustache Logger instance.
      *
-     * @return Mustache_Logger|Psr\Log\LoggerInterface
+     * @return Logger|LoggerInterface
      */
     public function getLogger()
     {
@@ -475,10 +614,8 @@ class Mustache_Engine
 
     /**
      * Set the Mustache Tokenizer instance.
-     *
-     * @param Mustache_Tokenizer $tokenizer
      */
-    public function setTokenizer(Mustache_Tokenizer $tokenizer)
+    public function setTokenizer(Tokenizer $tokenizer)
     {
         $this->tokenizer = $tokenizer;
     }
@@ -488,12 +625,12 @@ class Mustache_Engine
      *
      * If no Tokenizer instance has been explicitly specified, this method will instantiate and return a new one.
      *
-     * @return Mustache_Tokenizer
+     * @return Tokenizer
      */
     public function getTokenizer()
     {
         if (!isset($this->tokenizer)) {
-            $this->tokenizer = new Mustache_Tokenizer();
+            $this->tokenizer = new Tokenizer();
         }
 
         return $this->tokenizer;
@@ -501,10 +638,8 @@ class Mustache_Engine
 
     /**
      * Set the Mustache Parser instance.
-     *
-     * @param Mustache_Parser $parser
      */
-    public function setParser(Mustache_Parser $parser)
+    public function setParser(Parser $parser)
     {
         $this->parser = $parser;
     }
@@ -514,12 +649,12 @@ class Mustache_Engine
      *
      * If no Parser instance has been explicitly specified, this method will instantiate and return a new one.
      *
-     * @return Mustache_Parser
+     * @return Parser
      */
     public function getParser()
     {
         if (!isset($this->parser)) {
-            $this->parser = new Mustache_Parser();
+            $this->parser = new Parser();
         }
 
         return $this->parser;
@@ -527,10 +662,8 @@ class Mustache_Engine
 
     /**
      * Set the Mustache Compiler instance.
-     *
-     * @param Mustache_Compiler $compiler
      */
-    public function setCompiler(Mustache_Compiler $compiler)
+    public function setCompiler(Compiler $compiler)
     {
         $this->compiler = $compiler;
     }
@@ -540,12 +673,12 @@ class Mustache_Engine
      *
      * If no Compiler instance has been explicitly specified, this method will instantiate and return a new one.
      *
-     * @return Mustache_Compiler
+     * @return Compiler
      */
     public function getCompiler()
     {
         if (!isset($this->compiler)) {
-            $this->compiler = new Mustache_Compiler();
+            $this->compiler = new Compiler();
         }
 
         return $this->compiler;
@@ -553,10 +686,8 @@ class Mustache_Engine
 
     /**
      * Set the Mustache Cache instance.
-     *
-     * @param Mustache_Cache $cache
      */
-    public function setCache(Mustache_Cache $cache)
+    public function setCache(Cache $cache)
     {
         if (isset($this->logger) && $cache->getLogger() === null) {
             $cache->setLogger($this->getLogger());
@@ -570,12 +701,12 @@ class Mustache_Engine
      *
      * If no Cache instance has been explicitly specified, this method will instantiate and return a new one.
      *
-     * @return Mustache_Cache
+     * @return Cache
      */
     public function getCache()
     {
         if (!isset($this->cache)) {
-            $this->setCache(new Mustache_Cache_NoopCache());
+            $this->setCache(new NoopCache());
         }
 
         return $this->cache;
@@ -586,9 +717,9 @@ class Mustache_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 Mustache_Cache
+     * @return Cache
      */
     protected function getLambdaCache()
     {
@@ -597,7 +728,7 @@ class Mustache_Engine
         }
 
         if (!isset($this->lambdaCache)) {
-            $this->lambdaCache = new Mustache_Cache_NoopCache();
+            $this->lambdaCache = new NoopCache();
         }
 
         return $this->lambdaCache;
@@ -609,7 +740,7 @@ class Mustache_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|Mustache_Source $source
+     * @param string|Source $source
      *
      * @return string Mustache Template class name
      */
@@ -623,22 +754,23 @@ class Mustache_Engine
         // 'default' escapes.
         //
         // Keep this list in alphabetical order :)
-        $chunks = array(
+        $chunks = [
             'charset'         => $this->charset,
-            'delimiters'      => $this->delimiters ? $this->delimiters : '{{ }}',
+            'delimiters'      => $this->delimiters ?: '{{ }}',
             'entityFlags'     => $this->entityFlags,
             'escape'          => isset($this->escape) ? 'custom' : 'default',
-            'key'             => ($source instanceof Mustache_Source) ? $source->getKey() : 'source',
+            'key'             => ($source instanceof Source) ? $source->getKey() : 'source',
+            'options'         => $this->getOptions(),
             '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 Mustache_Source) {
+        if (!$source instanceof Source) {
             $key .= "\n" . $source;
         }
 
@@ -650,7 +782,7 @@ class Mustache_Engine
      *
      * @param string $name
      *
-     * @return Mustache_Template
+     * @return Template
      */
     public function loadTemplate($name)
     {
@@ -665,26 +797,26 @@ class Mustache_Engine
      *
      * @param string $name
      *
-     * @return Mustache_Template
+     * @return Template
      */
     public function loadPartial($name)
     {
         try {
             if (isset($this->partialsLoader)) {
                 $loader = $this->partialsLoader;
-            } elseif (isset($this->loader) && !$this->loader instanceof Mustache_Loader_StringLoader) {
+            } elseif (isset($this->loader) && !$this->loader instanceof StringLoader) {
                 $loader = $this->loader;
             } else {
-                throw new Mustache_Exception_UnknownTemplateException($name);
+                throw new UnknownTemplateException($name);
             }
 
             return $this->loadSource($loader->load($name));
-        } catch (Mustache_Exception_UnknownTemplateException $e) {
+        } catch (UnknownTemplateException $e) {
             // If the named partial cannot be found, log then return null.
             $this->log(
-                Mustache_Logger::WARNING,
+                Logger::WARNING,
                 'Partial not found: "{name}"',
-                array('name' => $e->getTemplateName())
+                ['name' => $e->getTemplateName()]
             );
         }
     }
@@ -698,7 +830,7 @@ class Mustache_Engine
      * @param string $source
      * @param string $delims (default: null)
      *
-     * @return Mustache_Template
+     * @return Template
      */
     public function loadLambda($source, $delims = null)
     {
@@ -712,24 +844,24 @@ class Mustache_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|Mustache_Source $source
-     * @param Mustache_Cache         $cache  (default: null)
+     * @param string|Source $source
+     * @param Cache         $cache  (default: null)
      *
-     * @return Mustache_Template
+     * @return Template
      */
-    private function loadSource($source, Mustache_Cache $cache = null)
+    private function loadSource($source, $cache = null)
     {
         $className = $this->getTemplateClassName($source);
 
         if (!isset($this->templates[$className])) {
-            if ($cache === null) {
+            if ($cache === null || !$cache instanceof Cache) {
                 $cache = $this->getCache();
             }
 
@@ -741,9 +873,9 @@ class Mustache_Engine
             }
 
             $this->log(
-                Mustache_Logger::DEBUG,
+                Logger::DEBUG,
                 'Instantiating template: "{className}"',
-                array('className' => $className)
+                ['className' => $className]
             );
 
             $this->templates[$className] = new $className($this);
@@ -755,7 +887,7 @@ class Mustache_Engine
     /**
      * Helper method to tokenize a Mustache template.
      *
-     * @see Mustache_Tokenizer::scan
+     * @see Mustache\Tokenizer::scan
      *
      * @param string $source
      *
@@ -769,7 +901,7 @@ class Mustache_Engine
     /**
      * Helper method to parse a Mustache template.
      *
-     * @see Mustache_Parser::parse
+     * @see Mustache\Parser::parse
      *
      * @param string $source
      *
@@ -778,6 +910,7 @@ class Mustache_Engine
     private function parse($source)
     {
         $parser = $this->getParser();
+        $parser->setOptions($this->getOptions());
         $parser->setPragmas($this->getPragmas());
 
         return $parser->parse($this->tokenize($source));
@@ -786,9 +919,9 @@ class Mustache_Engine
     /**
      * Helper method to compile a Mustache template.
      *
-     * @see Mustache_Compiler::compile
+     * @see Mustache\Compiler::compile
      *
-     * @param string|Mustache_Source $source
+     * @param string|Source $source
      *
      * @return string generated Mustache template class code
      */
@@ -797,17 +930,18 @@ class Mustache_Engine
         $name = $this->getTemplateClassName($source);
 
         $this->log(
-            Mustache_Logger::INFO,
+            Logger::INFO,
             'Compiling template to "{className}" class',
-            array('className' => $name)
+            ['className' => $name]
         );
 
-        if ($source instanceof Mustache_Source) {
+        if ($source instanceof 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);
@@ -820,7 +954,7 @@ class Mustache_Engine
      * @param string $message The log message
      * @param array  $context The log context
      */
-    private function log($level, $message, array $context = array())
+    private function log($level, $message, array $context = [])
     {
         if (isset($this->logger)) {
             $this->logger->log($level, $message, $context);