gulp-phug 1.3.4 → 2.0.0

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

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

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

@@ -3,43 +3,17 @@
 namespace Phug\Parser\TokenHandler;
 
 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;
-use Phug\Parser\TokenHandlerInterface;
+use Phug\Parser\TokenHandler\Partial\StaticAttributeTrait;
 
-class IdTokenHandler implements TokenHandlerInterface
+class IdTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof IdToken)) {
-            throw new \RuntimeException(
-                'You can only pass id tokens to this token handler'
-            );
-        }
-
-        if (!$state->getCurrentNode()) {
-            $state->setCurrentNode($state->createNode(ElementNode::class, $token));
-        }
+    use StaticAttributeTrait;
 
-        if (!$state->currentNodeIs([ElementNode::class, MixinCallNode::class])) {
-            $state->throwException(
-                'IDs can only be used on elements and mixin calls',
-                0,
-                $token
-            );
-        }
+    const TOKEN_TYPE = IdToken::class;
 
-        /** @var AttributeNode $attr */
-        $attr = $state->createNode(AttributeNode::class, $token);
-        $attr->setName('id');
-        $attr->setValue(var_export($token->getName(), true));
-        $attr->unescape()->uncheck();
-
-        /** @var ElementNode|MixinCallNode $current */
-        $current = $state->getCurrentNode();
-        $current->getAttributes()->attach($attr);
+    public function handleIdToken(IdToken $token, State $state)
+    {
+        $this->attachStaticAttribute('id', $token, $state);
     }
 }

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

@@ -3,35 +3,18 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\ImportToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\CommentNode;
 use Phug\Parser\Node\ImportNode;
 use Phug\Parser\Node\MixinNode;
 use Phug\Parser\NodeInterface;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class ImportTokenHandler implements TokenHandlerInterface
+class ImportTokenHandler extends AbstractTokenHandler
 {
-    protected function isEmptyDocument(NodeInterface $document)
-    {
-        foreach ($document->getChildren() as $child) {
-            if (!($child instanceof MixinNode || ($child instanceof CommentNode && !$child->isVisible()))) {
-                return false;
-            }
-        }
-
-        return true;
-    }
+    const TOKEN_TYPE = ImportToken::class;
 
-    public function handleToken(TokenInterface $token, State $state)
+    public function handleImportToken(ImportToken $token, State $state)
     {
-        if (!($token instanceof ImportToken)) {
-            throw new \RuntimeException(
-                'You can only pass import tokens to this token handler'
-            );
-        }
-
         if ($token->getName() === 'extend' && !$this->isEmptyDocument($state->getDocumentNode())) {
             $state->throwException(
                 'extends should be the very first statement in a document',
@@ -46,4 +29,15 @@ class ImportTokenHandler implements TokenHandlerInterface
         $node->setPath($token->getPath());
         $state->setCurrentNode($node);
     }
+
+    protected function isEmptyDocument(NodeInterface $document)
+    {
+        foreach ($document->getChildren() as $child) {
+            if (!($child instanceof MixinNode || ($child instanceof CommentNode && !$child->isVisible()))) {
+                return false;
+            }
+        }
+
+        return true;
+    }
 }

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

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

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

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

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

@@ -5,47 +5,22 @@ namespace Phug\Parser\TokenHandler;
 use Phug\Lexer\Token\ExpressionToken;
 use Phug\Lexer\Token\InterpolationEndToken;
 use Phug\Lexer\Token\InterpolationStartToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\CodeNode;
 use Phug\Parser\Node\ElementNode;
 use Phug\Parser\Node\ExpressionNode;
 use Phug\Parser\Node\TextNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class InterpolationStartTokenHandler implements TokenHandlerInterface
+class InterpolationStartTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof InterpolationStartToken)) {
-            throw new \RuntimeException(
-                'You can only pass interpolation start tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = InterpolationStartToken::class;
 
+    public function handleInterpolationStartToken(InterpolationStartToken $token, State $state)
+    {
         $node = $state->getCurrentNode();
 
         if (!$node && !($state->getPreviousToken() instanceof InterpolationEndToken)) {
-            /** @var ElementNode $element */
-            $element = $state->createNode(ElementNode::class, $token);
-            $state->setCurrentNode($element);
-
-            foreach ($state->lookUpNext([ExpressionToken::class]) as $expression) {
-                /** @var ExpressionNode $expressionNode */
-                $expressionNode = $state->createNode(ExpressionNode::class, $expression);
-                $expressionNode->check();
-                $expressionNode->unescape();
-                $expressionNode->setValue($expression->getValue());
-                $element->setName($expressionNode);
-            }
-
-            if (!$state->expect([InterpolationEndToken::class])) {
-                $state->throwException(
-                    'Interpolation not properly closed',
-                    0,
-                    $token
-                );
-            }
+            $this->handleExpressionTokens($token, $state);
 
             return;
         }
@@ -65,4 +40,28 @@ class InterpolationStartTokenHandler implements TokenHandlerInterface
 
         $state->store();
     }
+
+    private function handleExpressionTokens(InterpolationStartToken $token, State $state)
+    {
+        /** @var ElementNode $element */
+        $element = $state->createNode(ElementNode::class, $token);
+        $state->setCurrentNode($element);
+
+        foreach ($state->lookUpNext([ExpressionToken::class]) as $expression) {
+            /** @var ExpressionNode $expressionNode */
+            $expressionNode = $state->createNode(ExpressionNode::class, $expression);
+            $expressionNode->check();
+            $expressionNode->unescape();
+            $expressionNode->setValue($expression->getValue());
+            $element->setName($expressionNode);
+        }
+
+        if (!$state->expect([InterpolationEndToken::class])) {
+            $state->throwException(
+                'Interpolation not properly closed',
+                0,
+                $token
+            );
+        }
+    }
 }

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());