gulp-phug 1.3.4 → 1.3.5

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/KeywordTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\KeywordToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\KeywordNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class KeywordTokenHandler implements TokenHandlerInterface
+class KeywordTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof KeywordToken)) {
-            throw new \RuntimeException(
-                'You can only pass keyword tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = KeywordToken::class;
 
+    public function handleKeywordToken(KeywordToken $token, State $state)
+    {
         /** @var KeywordNode $node */
         $node = $state->createNode(KeywordNode::class, $token);
         $node->setName($token->getName());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/MixinCallTokenHandler.php

@@ -3,22 +3,16 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\MixinCallToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\ExpressionNode;
 use Phug\Parser\Node\MixinCallNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class MixinCallTokenHandler implements TokenHandlerInterface
+class MixinCallTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof MixinCallToken)) {
-            throw new \RuntimeException(
-                'You can only pass mixin call tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = MixinCallToken::class;
 
+    public function handleMixinCallToken(MixinCallToken $token, State $state)
+    {
         /** @var MixinCallNode $node */
         $node = $state->createNode(MixinCallNode::class, $token);
         $name = $token->getName();

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/MixinTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\MixinToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\MixinNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class MixinTokenHandler implements TokenHandlerInterface
+class MixinTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof MixinToken)) {
-            throw new \RuntimeException(
-                'You can only pass mixin tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = MixinToken::class;
 
+    public function handleMixinToken(MixinToken $token, State $state)
+    {
         /** @var MixinNode $node */
         $node = $state->createNode(MixinNode::class, $token);
         $node->setName($token->getName());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/NewLineTokenHandler.php

@@ -3,20 +3,14 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\NewLineToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class NewLineTokenHandler implements TokenHandlerInterface
+class NewLineTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof NewLineToken)) {
-            throw new \RuntimeException(
-                'You can only pass newline tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = NewLineToken::class;
 
+    public function handleNewLineToken(NewLineToken $token, State $state)
+    {
         $state->store();
     }
 }

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/OutdentTokenHandler.php

@@ -3,20 +3,14 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\OutdentToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class OutdentTokenHandler implements TokenHandlerInterface
+class OutdentTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof OutdentToken)) {
-            throw new \RuntimeException(
-                'You can only pass outdent tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = OutdentToken::class;
 
+    public function handleOutdentToken(OutdentToken $token, State $state)
+    {
         $state->leave();
     }
 }

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/Partial/StaticAttributeTrait.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Phug\Parser\TokenHandler\Partial;
+
+use Phug\Lexer\Token\ClassToken;
+use Phug\Lexer\Token\IdToken;
+use Phug\Lexer\TokenInterface;
+use Phug\Parser\Node\AttributeNode;
+use Phug\Parser\Node\ElementNode;
+use Phug\Parser\Node\MixinCallNode;
+use Phug\Parser\State;
+
+trait StaticAttributeTrait
+{
+    /**
+     * @param string             $name
+     * @param IdToken|ClassToken $token
+     * @param State              $state
+     *
+     * @return void
+     */
+    private function attachStaticAttribute($name, TokenInterface $token, State $state)
+    {
+        $this->onlyOnElement($token, $state);
+
+        /** @var AttributeNode $attr */
+        $attr = $state->createNode(AttributeNode::class, $token);
+        $attr->setName($name);
+        $attr->setValue(var_export($token->getName(), true));
+        $attr->unescape()->uncheck();
+
+        /** @var ElementNode|MixinCallNode $current */
+        $current = $state->getCurrentNode();
+        $current->getAttributes()->attach($attr);
+    }
+}

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/TagInterpolationEndTokenHandler.php

@@ -3,20 +3,14 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\TagInterpolationEndToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class TagInterpolationEndTokenHandler implements TokenHandlerInterface
+class TagInterpolationEndTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof TagInterpolationEndToken)) {
-            throw new \RuntimeException(
-                'You can only pass tag interpolation end tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = TagInterpolationEndToken::class;
 
+    public function handleTagInterpolationEndToken(TagInterpolationEndToken $token, State $state)
+    {
         $state->popInterpolationNode();
         $node = $state->getCurrentNode();
         $nodes = $state->getInterpolationStack()->offsetGet($token);

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/TagInterpolationStartTokenHandler.php

@@ -3,24 +3,19 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\TagInterpolationStartToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\CodeNode;
 use Phug\Parser\Node\ExpressionNode;
 use Phug\Parser\Node\TextNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class TagInterpolationStartTokenHandler implements TokenHandlerInterface
+class TagInterpolationStartTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof TagInterpolationStartToken)) {
-            throw new \RuntimeException(
-                'You can only pass tag interpolation start tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = TagInterpolationStartToken::class;
 
+    public function handleTagInterpolationStartToken(TagInterpolationStartToken $token, State $state)
+    {
         $node = $state->getCurrentNode();
+
         if ($state->currentNodeIs([
             TextNode::class,
             CodeNode::class,
@@ -28,9 +23,11 @@ class TagInterpolationStartTokenHandler implements TokenHandlerInterface
         ])) {
             $node = $node->getParent();
         }
+
         if ($node) {
             $state->pushInterpolationNode($node);
         }
+
         $state->getInterpolationStack()->attach($token->getEnd(), (object) [
             'currentNode' => $node,
             'parentNode'  => $state->getParentNode(),

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/TagTokenHandler.php

@@ -3,32 +3,17 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\TagToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\ElementNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class TagTokenHandler implements TokenHandlerInterface
+class TagTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof TagToken)) {
-            throw new \RuntimeException(
-                'You can only pass tag tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = TagToken::class;
 
-        if (!$state->getCurrentNode()) {
-            $state->setCurrentNode($state->createNode(ElementNode::class, $token));
-        }
-
-        if (!$state->currentNodeIs([ElementNode::class])) {
-            $state->throwException(
-                'Tags can only be used on elements',
-                0,
-                $token
-            );
-        }
+    public function handleTagToken(TagToken $token, State $state)
+    {
+        $this->createElementNodeIfMissing($token, $state);
+        $this->assertCurrentNodeIs($token, $state, [ElementNode::class]);
 
         /** @var ElementNode $current */
         $current = $state->getCurrentNode();

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/TextTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\TextToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\TextNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class TextTokenHandler implements TokenHandlerInterface
+class TextTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof TextToken)) {
-            throw new \RuntimeException(
-                'You can only pass text tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = TextToken::class;
 
+    public function handleTextToken(TextToken $token, State $state)
+    {
         /** @var TextNode $node */
         $node = $state->createNode(TextNode::class, $token);
         $node->setValue($token->getValue());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/VariableTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\VariableToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\VariableNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class VariableTokenHandler implements TokenHandlerInterface
+class VariableTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof VariableToken)) {
-            throw new \RuntimeException(
-                'You can only pass variable tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = VariableToken::class;
 
+    public function handleVariableToken(VariableToken $token, State $state)
+    {
         /** @var VariableNode $node */
         $node = $state->createNode(VariableNode::class, $token);
         $node->setName($token->getName());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/WhenTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\WhenToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\WhenNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class WhenTokenHandler implements TokenHandlerInterface
+class WhenTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof WhenToken)) {
-            throw new \RuntimeException(
-                'You can only pass when tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = WhenToken::class;
 
+    public function handleWhenToken(WhenToken $token, State $state)
+    {
         /** @var WhenNode $node */
         $node = $state->createNode(WhenNode::class, $token);
         $node->setSubject($token->getSubject());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/WhileTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\WhileToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\WhileNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class WhileTokenHandler implements TokenHandlerInterface
+class WhileTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof WhileToken)) {
-            throw new \RuntimeException(
-                'You can only pass while tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = WhileToken::class;
 
+    public function handleWhileToken(WhileToken $token, State $state)
+    {
         /** @var WhileNode $node */
         $node = $state->createNode(WhileNode::class, $token);
         $node->setSubject($token->getSubject());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/YieldTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\YieldToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\YieldNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class YieldTokenHandler implements TokenHandlerInterface
+class YieldTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof YieldToken)) {
-            throw new \RuntimeException(
-                'You can only pass yield tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = YieldToken::class;
 
+    public function handleYieldToken(YieldToken $token, State $state)
+    {
         $state->setCurrentNode($state->createNode(YieldNode::class, $token));
     }
 }

package/support/vendor/phug/phug/src/Phug/Parser/Parser.php

@@ -330,8 +330,8 @@ class Parser implements ModuleContainerInterface
 
         foreach ($expandingNodes as $expandingNode) {
             $current = $expandingNode;
-            while ($outerNode = $expandingNode->getOuterNode()) {
 
+            while ($outerNode = $expandingNode->getOuterNode()) {
                 /** @var NodeInterface $expandedNode */
                 $expandedNode = $outerNode;
                 $current->setOuterNode(null);

package/support/vendor/phug/phug/src/Phug/Parser/composer.json

@@ -11,8 +11,7 @@
             "email": "torben@talesoft.codes"
         },
         {
-            "name": "KyleKatarn",
-            "email": "jade-php@selfbuild.fr",
+            "name": "kylekatarnls",
             "homepage": "http://github.com/kylekatarnls"
         }
     ],

package/support/vendor/phug/phug/src/Phug/Phug/Phug/Cli.php

@@ -94,7 +94,7 @@ class Cli
             return false;
         }
 
-        if (!in_array($method, iterator_to_array($this->getAvailableMethods($customMethods)))) {
+        if (!in_array($method, iterator_to_array($this->getAvailableMethods($customMethods)), true)) {
             echo "The method $action is not available as CLI command in the $facade facade.\n";
             $this->listAvailableMethods($customMethods);
 
@@ -152,21 +152,21 @@ class Cli
     {
         return preg_replace_callback('/[A-Z]/', function ($match) {
             return '-'.strtolower($match[0]);
-        }, $string);
+        }, (string) $string);
     }
 
     protected function convertToCamelCase($string)
     {
         return preg_replace_callback('/-([a-z])/', function ($match) {
             return strtoupper($match[1]);
-        }, $string);
+        }, (string) $string);
     }
 
     protected function execute($facade, $method, $arguments, $outputFile)
     {
         $callable = [$facade, $method];
         $arguments = array_map(function ($argument) {
-            return in_array(substr($argument, 0, 1), ['[', '{'])
+            return in_array(substr((string) $argument, 0, 1), ['[', '{'], true)
                 ? json_decode($argument, true)
                 : $argument;
         }, $arguments);
@@ -206,7 +206,7 @@ class Cli
 
     protected function getNamedArgumentByEqualOperator(array &$arguments, $index, $name)
     {
-        if (preg_match('/^'.preg_quote($name).'=(.*)$/', $arguments[$index], $match)) {
+        if (preg_match('/^'.preg_quote($name).'=(.*)$/', (string) $arguments[$index], $match)) {
             array_splice($arguments, $index, 1);
 
             return $match[1];

package/support/vendor/phug/phug/src/Phug/Phug/Phug/Partial/ExtensionsTrait.php

@@ -54,7 +54,7 @@ trait ExtensionsTrait
      */
     public static function hasExtension($extensionClassName)
     {
-        return in_array(static::normalizeExtensionClassName($extensionClassName), static::getExtensionIds());
+        return in_array(static::normalizeExtensionClassName($extensionClassName), static::getExtensionIds(), true);
     }
 
     /**

package/support/vendor/phug/phug/src/Phug/Phug/Phug/Partial/FacadeOptionsTrait.php

@@ -36,7 +36,7 @@ trait FacadeOptionsTrait
             'setOptionsRecursive',
             'setOptionsDefaults',
             'unsetOption',
-        ]);
+        ], true);
     }
 
     protected static function getFacadeOptions()

package/support/vendor/phug/phug/src/Phug/Phug/Phug/Phug.php

@@ -2,6 +2,7 @@
 
 namespace Phug;
 
+use InvalidArgumentException;
 use Phug\Partial\ExtensionsTrait;
 use Phug\Partial\FacadeOptionsTrait;
 
@@ -476,16 +477,24 @@ class Phug
      */
     public static function cacheDirectory($source, $destination = null, $options = null)
     {
-        if ($destination && !is_array($destination)) {
+        $options = $options ?: [];
+        $destination = $destination ?: [];
+
+        if (!is_array($destination)) {
             $destination = [
                 'cache_dir' => $destination,
             ];
         }
 
-        return static::getRenderer(array_merge(
-            $options ?: [],
-            $destination ?: []
-        ))->cacheDirectory($source);
+        if (!is_array($options)) {
+            throw new InvalidArgumentException(
+                'Expected $options to be an array, got: '.
+                (@var_export($options, true) ?: (is_object($options) ? get_class($options) : gettype($options)))
+            );
+        }
+
+        return static::getRenderer(array_merge($options, $destination))
+            ->cacheDirectory($source);
     }
 
     /**

package/support/vendor/phug/phug/src/Phug/Phug/composer.json

@@ -7,9 +7,12 @@
     "homepage": "http://phug-lang.com",
     "authors": [
         {
-            "name": "KyleKatarn",
-            "email": "jade-php@selfbuild.fr",
+            "name": "kylekatarnls",
             "homepage": "http://github.com/kylekatarnls"
+        },
+        {
+            "name": "Torben Koehn",
+            "email": "torben@talesoft.codes"
         }
     ],
     "support": {

package/support/vendor/phug/phug/src/Phug/Reader/Reader.php

@@ -313,9 +313,9 @@ class Reader
      *
      * Notice that ^ is automatically prepended to the pattern.
      *
-     * @param string $pattern         the regular expression without slashes or modifiers.
-     * @param string $modifiers       the modifiers for the regular expression.
-     * @param string $ignoredSuffixes characters that are scanned, but don't end up in the consume length.
+     * @param string      $pattern         the regular expression without slashes or modifiers.
+     * @param string|null $modifiers       the modifiers for the regular expression.
+     * @param string|null $ignoredSuffixes characters that are scanned, but don't end up in the consume length.
      *
      * @throws ReaderException
      *
@@ -323,7 +323,7 @@ class Reader
      */
     public function match($pattern, $modifiers = null, $ignoredSuffixes = null)
     {
-        $modifiers = $modifiers ?: '';
+        $modifiers = (string) $modifiers;
         $ignoredSuffixes = $ignoredSuffixes ?: "\n";
         $matches = null;
         $this->lastMatchResult = null;
@@ -572,7 +572,7 @@ class Reader
      */
     public function peekSpace()
     {
-        return ctype_space($this->peek());
+        return ctype_space((string) $this->peek());
     }
 
     /**
@@ -584,7 +584,7 @@ class Reader
      */
     public function peekDigit()
     {
-        return ctype_digit($this->peek());
+        return ctype_digit((string) $this->peek());
     }
 
     /**
@@ -596,7 +596,7 @@ class Reader
      */
     public function peekAlpha()
     {
-        return ctype_alpha($this->peek());
+        return ctype_alpha((string) $this->peek());
     }
 
     /**
@@ -608,7 +608,7 @@ class Reader
      */
     public function peekAlphaNumeric()
     {
-        return ctype_alnum($this->peek());
+        return ctype_alnum((string) $this->peek());
     }
 
     /**
@@ -658,7 +658,7 @@ class Reader
      */
     public function readUntilNewLine()
     {
-        return $this->readUntil([$this, 'peekNewLine']);
+        return (string) $this->readUntil([$this, 'peekNewLine']);
     }
 
     /**

package/support/vendor/phug/phug/src/Phug/Reader/composer.json

@@ -9,6 +9,10 @@
         {
             "name": "Torben Koehn",
             "email": "torben@talesoft.codes"
+        },
+        {
+            "name": "kylekatarnls",
+            "homepage": "http://github.com/kylekatarnls"
         }
     ],
     "support": {