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}/Compiler.php

@@ -3,26 +3,21 @@
 /*
  * 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\Exception\InvalidArgumentException;
-use Mustache\Exception\SyntaxException;
-
 /**
  * Mustache Compiler class.
  *
  * This class is responsible for turning a Mustache token parse tree into normal PHP source code.
  */
-class Compiler
+class Mustache_Compiler
 {
     private $pragmas;
-    private $defaultPragmas = [];
+    private $defaultPragmas = array();
     private $sections;
     private $blocks;
     private $source;
@@ -32,16 +27,11 @@ class Compiler
     private $charset;
     private $strictCallables;
 
-    // Optional Mustache specs
-    private $lambdas = true;
-
     /**
      * Compile a Mustache token parse tree into PHP source code.
      *
-     * @throws InvalidArgumentException if the FILTERS pragma is set but lambdas are not enabled
-     *
      * @param string $source          Mustache Template source code
-     * @param array  $tree            Parse tree of Mustache tokens
+     * @param string $tree            Parse tree of Mustache tokens
      * @param string $name            Mustache Template class name
      * @param bool   $customEscape    (default: false)
      * @param string $charset         (default: 'UTF-8')
@@ -53,8 +43,8 @@ class Compiler
     public function compile($source, array $tree, $name, $customEscape = false, $charset = 'UTF-8', $strictCallables = false, $entityFlags = ENT_COMPAT)
     {
         $this->pragmas         = $this->defaultPragmas;
-        $this->sections        = [];
-        $this->blocks          = [];
+        $this->sections        = array();
+        $this->blocks          = array();
         $this->source          = $source;
         $this->indentNextLine  = true;
         $this->customEscape    = $customEscape;
@@ -62,40 +52,20 @@ class Compiler
         $this->charset         = $charset;
         $this->strictCallables = $strictCallables;
 
-        $code = $this->writeCode($tree, $name);
-
-        if (isset($this->pragmas[Engine::PRAGMA_FILTERS]) && !$this->lambdas) {
-            throw new InvalidArgumentException('The FILTERS pragma requires lambda support');
-        }
-
-        return $code;
-    }
-
-    /**
-     * Disable optional Mustache specs.
-     *
-     * @internal Users should set options in Mustache\Engine, not here :)
-     *
-     * @param bool[] $options
-     */
-    public function setOptions(array $options)
-    {
-        if (isset($options['lambdas'])) {
-            $this->lambdas = $options['lambdas'] !== false;
-        }
+        return $this->writeCode($tree, $name);
     }
 
     /**
      * 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 :)
+     * @internal Users should set global pragmas in Mustache_Engine, not here :)
      *
      * @param string[] $pragmas
      */
     public function setPragmas(array $pragmas)
     {
-        $this->pragmas = [];
+        $this->pragmas = array();
         foreach ($pragmas as $pragma) {
             $this->pragmas[$pragma] = true;
         }
@@ -105,7 +75,7 @@ class Compiler
     /**
      * Helper function for walking the Mustache token parse tree.
      *
-     * @throws SyntaxException upon encountering unknown token types
+     * @throws Mustache_Exception_SyntaxException upon encountering unknown token types
      *
      * @param array $tree  Parse tree of Mustache tokens
      * @param int   $level (default: 0)
@@ -117,96 +87,96 @@ class Compiler
         $code = '';
         $level++;
         foreach ($tree as $node) {
-            switch ($node[Tokenizer::TYPE]) {
-                case Tokenizer::T_PRAGMA:
-                    $this->pragmas[$node[Tokenizer::NAME]] = true;
+            switch ($node[Mustache_Tokenizer::TYPE]) {
+                case Mustache_Tokenizer::T_PRAGMA:
+                    $this->pragmas[$node[Mustache_Tokenizer::NAME]] = true;
                     break;
 
-                case Tokenizer::T_SECTION:
+                case Mustache_Tokenizer::T_SECTION:
                     $code .= $this->section(
-                        $node[Tokenizer::NODES],
-                        $node[Tokenizer::NAME],
-                        isset($node[Tokenizer::FILTERS]) ? $node[Tokenizer::FILTERS] : [],
-                        $node[Tokenizer::INDEX],
-                        $node[Tokenizer::END],
-                        $node[Tokenizer::OTAG],
-                        $node[Tokenizer::CTAG],
+                        $node[Mustache_Tokenizer::NODES],
+                        $node[Mustache_Tokenizer::NAME],
+                        isset($node[Mustache_Tokenizer::FILTERS]) ? $node[Mustache_Tokenizer::FILTERS] : array(),
+                        $node[Mustache_Tokenizer::INDEX],
+                        $node[Mustache_Tokenizer::END],
+                        $node[Mustache_Tokenizer::OTAG],
+                        $node[Mustache_Tokenizer::CTAG],
                         $level
                     );
                     break;
 
-                case Tokenizer::T_INVERTED:
+                case Mustache_Tokenizer::T_INVERTED:
                     $code .= $this->invertedSection(
-                        $node[Tokenizer::NODES],
-                        $node[Tokenizer::NAME],
-                        isset($node[Tokenizer::FILTERS]) ? $node[Tokenizer::FILTERS] : [],
+                        $node[Mustache_Tokenizer::NODES],
+                        $node[Mustache_Tokenizer::NAME],
+                        isset($node[Mustache_Tokenizer::FILTERS]) ? $node[Mustache_Tokenizer::FILTERS] : array(),
                         $level
                     );
                     break;
 
-                case Tokenizer::T_PARTIAL:
+                case Mustache_Tokenizer::T_PARTIAL:
                     $code .= $this->partial(
-                        $node[Tokenizer::NAME],
-                        isset($node[Tokenizer::DYNAMIC]) ? $node[Tokenizer::DYNAMIC] : false,
-                        isset($node[Tokenizer::INDENT]) ? $node[Tokenizer::INDENT] : '',
+                        $node[Mustache_Tokenizer::NAME],
+                        isset($node[Mustache_Tokenizer::DYNAMIC]) ? $node[Mustache_Tokenizer::DYNAMIC] : false,
+                        isset($node[Mustache_Tokenizer::INDENT]) ? $node[Mustache_Tokenizer::INDENT] : '',
                         $level
                     );
                     break;
 
-                case Tokenizer::T_PARENT:
+                case Mustache_Tokenizer::T_PARENT:
                     $code .= $this->parent(
-                        $node[Tokenizer::NAME],
-                        isset($node[Tokenizer::DYNAMIC]) ? $node[Tokenizer::DYNAMIC] : false,
-                        isset($node[Tokenizer::INDENT]) ? $node[Tokenizer::INDENT] : '',
-                        $node[Tokenizer::NODES],
+                        $node[Mustache_Tokenizer::NAME],
+                        isset($node[Mustache_Tokenizer::DYNAMIC]) ? $node[Mustache_Tokenizer::DYNAMIC] : false,
+                        isset($node[Mustache_Tokenizer::INDENT]) ? $node[Mustache_Tokenizer::INDENT] : '',
+                        $node[Mustache_Tokenizer::NODES],
                         $level
                     );
                     break;
 
-                case Tokenizer::T_BLOCK_ARG:
+                case Mustache_Tokenizer::T_BLOCK_ARG:
                     $code .= $this->blockArg(
-                        $node[Tokenizer::NODES],
-                        $node[Tokenizer::NAME],
-                        $node[Tokenizer::INDEX],
-                        $node[Tokenizer::END],
-                        $node[Tokenizer::OTAG],
-                        $node[Tokenizer::CTAG],
+                        $node[Mustache_Tokenizer::NODES],
+                        $node[Mustache_Tokenizer::NAME],
+                        $node[Mustache_Tokenizer::INDEX],
+                        $node[Mustache_Tokenizer::END],
+                        $node[Mustache_Tokenizer::OTAG],
+                        $node[Mustache_Tokenizer::CTAG],
                         $level
                     );
                     break;
 
-                case Tokenizer::T_BLOCK_VAR:
+                case Mustache_Tokenizer::T_BLOCK_VAR:
                     $code .= $this->blockVar(
-                        $node[Tokenizer::NODES],
-                        $node[Tokenizer::NAME],
-                        $node[Tokenizer::INDEX],
-                        $node[Tokenizer::END],
-                        $node[Tokenizer::OTAG],
-                        $node[Tokenizer::CTAG],
+                        $node[Mustache_Tokenizer::NODES],
+                        $node[Mustache_Tokenizer::NAME],
+                        $node[Mustache_Tokenizer::INDEX],
+                        $node[Mustache_Tokenizer::END],
+                        $node[Mustache_Tokenizer::OTAG],
+                        $node[Mustache_Tokenizer::CTAG],
                         $level
                     );
                     break;
 
-                case Tokenizer::T_COMMENT:
+                case Mustache_Tokenizer::T_COMMENT:
                     break;
 
-                case Tokenizer::T_ESCAPED:
-                case Tokenizer::T_UNESCAPED:
-                case Tokenizer::T_UNESCAPED_2:
+                case Mustache_Tokenizer::T_ESCAPED:
+                case Mustache_Tokenizer::T_UNESCAPED:
+                case Mustache_Tokenizer::T_UNESCAPED_2:
                     $code .= $this->variable(
-                        $node[Tokenizer::NAME],
-                        isset($node[Tokenizer::FILTERS]) ? $node[Tokenizer::FILTERS] : [],
-                        $node[Tokenizer::TYPE] === Tokenizer::T_ESCAPED,
+                        $node[Mustache_Tokenizer::NAME],
+                        isset($node[Mustache_Tokenizer::FILTERS]) ? $node[Mustache_Tokenizer::FILTERS] : array(),
+                        $node[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_ESCAPED,
                         $level
                     );
                     break;
 
-                case Tokenizer::T_TEXT:
-                    $code .= $this->text($node[Tokenizer::VALUE], $level);
+                case Mustache_Tokenizer::T_TEXT:
+                    $code .= $this->text($node[Mustache_Tokenizer::VALUE], $level);
                     break;
 
                 default:
-                    throw new SyntaxException(sprintf('Unknown token type: %s', $node[Tokenizer::TYPE]), $node);
+                    throw new Mustache_Exception_SyntaxException(sprintf('Unknown token type: %s', $node[Mustache_Tokenizer::TYPE]), $node);
             }
         }
 
@@ -215,13 +185,13 @@ class Compiler
 
     const KLASS = '<?php
 
-        class %s extends \\Mustache\\Template
+        class %s extends Mustache_Template
         {
-            private $lambdaHelper;%s%s
+            private $lambdaHelper;%s
 
-            public function renderInternal(\\Mustache\\Context $context, $indent = \'\')
+            public function renderInternal(Mustache_Context $context, $indent = \'\')
             {
-                $this->lambdaHelper = new \\Mustache\\LambdaHelper($this->mustache, $context);
+                $this->lambdaHelper = new Mustache_LambdaHelper($this->mustache, $context);
                 $buffer = \'\';
         %s
 
@@ -233,9 +203,9 @@ class Compiler
 
     const KLASS_NO_LAMBDAS = '<?php
 
-        class %s extends \\Mustache\\Template
-        {%s%s
-            public function renderInternal(\\Mustache\\Context $context, $indent = \'\')
+        class %s extends Mustache_Template
+        {%s
+            public function renderInternal(Mustache_Context $context, $indent = \'\')
             {
                 $buffer = \'\';
         %s
@@ -246,8 +216,6 @@ class Compiler
 
     const STRICT_CALLABLE = 'protected $strictCallables = true;';
 
-    const NO_LAMBDAS = 'protected $lambdas = false;';
-
     /**
      * Generate Mustache Template class PHP source.
      *
@@ -256,7 +224,7 @@ class Compiler
      *
      * @return string Generated PHP source code
      */
-    private function writeCode(array $tree, $name)
+    private function writeCode($tree, $name)
     {
         $code     = $this->walk($tree);
         $sections = implode("\n", $this->sections);
@@ -264,9 +232,8 @@ class Compiler
         $klass    = empty($this->sections) && empty($this->blocks) ? self::KLASS_NO_LAMBDAS : self::KLASS;
 
         $callable = $this->strictCallables ? $this->prepare(self::STRICT_CALLABLE) : '';
-        $lambda   = $this->lambdas ? '' : $this->prepare(self::NO_LAMBDAS);
 
-        return sprintf($this->prepare($klass, 0, false, true), $name, $callable, $lambda, $code, $sections, $blocks);
+        return sprintf($this->prepare($klass, 0, false, true), $name, $callable, $code, $sections, $blocks);
     }
 
     const BLOCK_VAR = '
@@ -291,7 +258,7 @@ class Compiler
      *
      * @return string Generated PHP source code
      */
-    private function blockVar(array $nodes, $id, $start, $end, $otag, $ctag, $level)
+    private function blockVar($nodes, $id, $start, $end, $otag, $ctag, $level)
     {
         $id = var_export($id, true);
 
@@ -303,7 +270,7 @@ class Compiler
         return sprintf($this->prepare(self::BLOCK_VAR, $level), $id, $else);
     }
 
-    const BLOCK_ARG = '%s => [$this, \'block%s\'],';
+    const BLOCK_ARG = '%s => array($this, \'block%s\'),';
 
     /**
      * Generate Mustache Template inheritance block argument PHP source.
@@ -342,7 +309,7 @@ class Compiler
      *
      * @return string key of new block function
      */
-    private function block(array $nodes)
+    private function block($nodes)
     {
         $code = $this->walk($nodes, 0);
         $key = ucfirst(md5($code));
@@ -360,7 +327,7 @@ class Compiler
     ';
 
     const SECTION = '
-        private function section%s(\\Mustache\\Context $context, $indent, $value)
+        private function section%s(Mustache_Context $context, $indent, $value)
         {
             $buffer = \'\';
 
@@ -368,10 +335,6 @@ class Compiler
                 $source = %s;
                 $value = call_user_func($value, $source, %s);
 
-                if ($value instanceof \\Mustache\\RenderedString) {
-                    return $value->getValue();
-                }
-
                 if (is_string($value)) {
                     if (strpos($value, \'{{\') === false) {
                         return $value;
@@ -384,25 +347,7 @@ class Compiler
             }
 
             if (!empty($value)) {
-                $values = $this->isIterable($value) ? $value : [$value];
-                foreach ($values as $value) {
-                    $context->push($value);
-                    %s
-                    $context->pop();
-                }
-            }
-
-            return $buffer;
-        }
-    ';
-
-    const SECTION_NO_LAMBDAS = '
-        private function section%s(\\Mustache\\Context $context, $indent, $value)
-        {
-            $buffer = \'\';
-
-            if (!empty($value)) {
-                $values = $this->isIterable($value) ? $value : [$value];
+                $values = $this->isIterable($value) ? $value : array($value);
                 foreach ($values as $value) {
                     $context->push($value);
                     %s
@@ -428,7 +373,7 @@ class Compiler
      *
      * @return string Generated section PHP source code
      */
-    private function section(array $nodes, $id, $filters, $start, $end, $otag, $ctag, $level)
+    private function section($nodes, $id, $filters, $start, $end, $otag, $ctag, $level)
     {
         $source   = var_export(substr($this->source, $start, $end - $start), true);
         $callable = $this->getCallable();
@@ -445,11 +390,7 @@ class Compiler
         $key = ucfirst(md5($delims . "\n" . $source));
 
         if (!isset($this->sections[$key])) {
-            if ($this->lambdas) {
-                $this->sections[$key] = sprintf($this->prepare(self::SECTION), $key, $callable, $source, $helper, $delims, $this->walk($nodes, 2));
-            } else {
-                $this->sections[$key] = sprintf($this->prepare(self::SECTION_NO_LAMBDAS), $key, $this->walk($nodes, 2));
-            }
+            $this->sections[$key] = sprintf($this->prepare(self::SECTION), $key, $callable, $source, $helper, $delims, $this->walk($nodes, 2));
         }
 
         $method  = $this->getFindMethod($id);
@@ -477,7 +418,7 @@ class Compiler
      *
      * @return string Generated inverted section PHP source code
      */
-    private function invertedSection(array $nodes, $id, $filters, $level)
+    private function invertedSection($nodes, $id, $filters, $level)
     {
         $method  = $this->getFindMethod($id);
         $id      = var_export($id, true);
@@ -546,8 +487,8 @@ class Compiler
 
     const PARENT = '
         if ($parent = $this->mustache->loadPartial(%s)) {
-            $context->pushBlockContext([%s
-            ]);
+            $context->pushBlockContext(array(%s
+            ));
             $buffer .= $parent->renderInternal($context, $indent);
             $context->popBlockContext();
         }
@@ -572,7 +513,7 @@ class Compiler
      */
     private function parent($id, $dynamic, $indent, array $children, $level)
     {
-        $realChildren = array_filter($children, [self::class, 'onlyBlockArgs']);
+        $realChildren = array_filter($children, array(__CLASS__, 'onlyBlockArgs'));
         $partialName = $this->resolveDynamicName($id, $dynamic);
 
         if (empty($realChildren)) {
@@ -589,11 +530,13 @@ class Compiler
     /**
      * Helper method for filtering out non-block-arg tokens.
      *
+     * @param array $node
+     *
      * @return bool True if $node is a block arg token
      */
     private static function onlyBlockArgs(array $node)
     {
-        return $node[Tokenizer::TYPE] === Tokenizer::T_BLOCK_ARG;
+        return $node[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_BLOCK_ARG;
     }
 
     const VARIABLE = '
@@ -625,7 +568,7 @@ class Compiler
     const FILTER = '
         $filter = $context->%s(%s%s);
         if (!(%s)) {
-            throw new \\Mustache\\Exception\\UnknownFilterException(%s);
+            throw new Mustache_Exception_UnknownFilterException(%s);
         }
         $value = call_user_func($filter, %s);%s
     ';
@@ -639,7 +582,7 @@ class Compiler
      *
      * @param string[] $filters Array of filters
      * @param int      $level
-     * @param bool     $first   (default: false)
+     * @param bool     $first (default: false)
      *
      * @return string Generated filter PHP source
      */
@@ -727,9 +670,9 @@ class Compiler
      *
      * The return value will be one of `find`, `findDot`, `findAnchoredDot` or `last`.
      *
-     * @see \Mustache\Context::find
-     * @see \Mustache\Context::findDot
-     * @see \Mustache\Context::last
+     * @see Mustache_Context::find
+     * @see Mustache_Context::findDot
+     * @see Mustache_Context::last
      *
      * @param string $id Variable name
      *
@@ -741,7 +684,7 @@ class Compiler
             return 'last';
         }
 
-        if (isset($this->pragmas[Engine::PRAGMA_ANCHORED_DOT]) && $this->pragmas[Engine::PRAGMA_ANCHORED_DOT]) {
+        if (isset($this->pragmas[Mustache_Engine::PRAGMA_ANCHORED_DOT]) && $this->pragmas[Mustache_Engine::PRAGMA_ANCHORED_DOT]) {
             if (substr($id, 0, 1) === '.') {
                 return 'findAnchoredDot';
             }

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

@@ -3,23 +3,19 @@
 /*
  * 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\Exception\InvalidArgumentException;
-
 /**
  * Mustache Template rendering Context.
  */
-class Context
+class Mustache_Context
 {
-    private $stack      = [];
-    private $blockStack = [];
+    private $stack      = array();
+    private $blockStack = array();
 
     private $buggyPropertyShadowing = false;
 
@@ -27,12 +23,12 @@ class Context
      * Mustache rendering Context constructor.
      *
      * @param mixed $context                Default rendering context (default: null)
-     * @param bool  $buggyPropertyShadowing See Engine::getBuggyPropertyShadowing (default: false)
+     * @param bool  $buggyPropertyShadowing See Mustache_Engine::useBuggyPropertyShadowing (default: false)
      */
     public function __construct($context = null, $buggyPropertyShadowing = false)
     {
         if ($context !== null) {
-            $this->stack = [$context];
+            $this->stack = array($context);
         }
 
         $this->buggyPropertyShadowing = $buggyPropertyShadowing;
@@ -115,12 +111,12 @@ class Context
      * the initial chunk of the dotted name, each subsequent chunk is searched for only within the value of the previous
      * result. For example, given the following context stack:
      *
-     *     $data = [
+     *     $data = array(
      *         'name' => 'Fred',
-     *         'child' => [
+     *         'child' => array(
      *             'name' => 'Bob'
-     *         ],
-     *     ];
+     *         ),
+     *     );
      *
      * ... and the Mustache following template:
      *
@@ -154,7 +150,7 @@ class Context
                 return $value;
             }
 
-            $value = $this->findVariableInStack($chunk, [$value]);
+            $value = $this->findVariableInStack($chunk, array($value));
         }
 
         return $value;
@@ -167,9 +163,9 @@ class Context
      * stack for the first value, rather than searching the whole context stack
      * and starting from there.
      *
-     * @see Mustache\Context::findDot
+     * @see Mustache_Context::findDot
      *
-     * @throws InvalidArgumentException if given an invalid anchored dot $id
+     * @throws Mustache_Exception_InvalidArgumentException if given an invalid anchored dot $id
      *
      * @param string $id Dotted variable selector
      *
@@ -180,7 +176,7 @@ class Context
         $chunks = explode('.', $id);
         $first  = array_shift($chunks);
         if ($first !== '') {
-            throw new InvalidArgumentException(sprintf('Unexpected id for findAnchoredDot: %s', $id));
+            throw new Mustache_Exception_InvalidArgumentException(sprintf('Unexpected id for findAnchoredDot: %s', $id));
         }
 
         $value  = $this->last();
@@ -190,7 +186,7 @@ class Context
                 return $value;
             }
 
-            $value = $this->findVariableInStack($chunk, [$value]);
+            $value = $this->findVariableInStack($chunk, array($value));
         }
 
         return $value;
@@ -217,7 +213,7 @@ class Context
     /**
      * Helper function to find a variable in the Context stack.
      *
-     * @see Mustache\Context::find
+     * @see Mustache_Context::find
      *
      * @param string $id    Variable name
      * @param array  $stack Context stack
@@ -231,7 +227,7 @@ class Context
 
             switch (gettype($frame)) {
                 case 'object':
-                    if (!($frame instanceof \Closure)) {
+                    if (!($frame instanceof Closure)) {
                         // Note that is_callable() *will not work here*
                         // See https://github.com/bobthecow/mustache.php/wiki/Magic-Methods
                         if (method_exists($frame, $id)) {
@@ -246,7 +242,7 @@ class Context
                         // Mustache.php <= 2.14.2
                         // See https://github.com/bobthecow/mustache.php/pull/410
                         if ($this->buggyPropertyShadowing) {
-                            if ($frame instanceof \ArrayAccess && isset($frame[$id])) {
+                            if ($frame instanceof ArrayAccess && isset($frame[$id])) {
                                 return $frame[$id];
                             }
                         } else {
@@ -257,7 +253,7 @@ class Context
                                 }
                             }
 
-                            if ($frame instanceof \ArrayAccess && $frame->offsetExists($id)) {
+                            if ($frame instanceof ArrayAccess && $frame->offsetExists($id)) {
                                 return $frame[$id];
                             }
                         }