gulp-phug 1.3.4 → 2.0.0

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

@@ -0,0 +1,87 @@
+<?php
+
+namespace Phug\Parser\TokenHandler;
+
+use Phug\Lexer\TokenInterface;
+use Phug\Parser\Node\ElementNode;
+use Phug\Parser\Node\MixinCallNode;
+use Phug\Parser\State;
+use Phug\Parser\TokenHandlerInterface;
+
+abstract class AbstractTokenHandler implements TokenHandlerInterface
+{
+    const TOKEN_TYPE = TokenInterface::class;
+
+    public function handleToken(TokenInterface $token, State $state)
+    {
+        if (!is_a($token, static::TOKEN_TYPE)) {
+            $name = $this->getTypeName(static::TOKEN_TYPE);
+            $handler = $this->getClassLastPart(static::class);
+
+            throw new \RuntimeException(
+                "You can only pass $name tokens to $handler"
+            );
+        }
+
+        $method = 'handle'.$this->getClassLastPart(get_class($token));
+        $this->$method($token, $state);
+    }
+
+    protected function onlyOnElement(TokenInterface $token, State $state)
+    {
+        $this->createElementNodeIfMissing($token, $state);
+        $this->assertCurrentNodeIs($token, $state, [ElementNode::class, MixinCallNode::class]);
+    }
+
+    protected function createElementNodeIfMissing(TokenInterface $token, State $state)
+    {
+        if (!$state->getCurrentNode()) {
+            $state->setCurrentNode($state->createNode(ElementNode::class, $token));
+        }
+    }
+
+    protected function assertCurrentNodeIs(TokenInterface $token, State $state, array $nodeTypes)
+    {
+        if (!$state->currentNodeIs($nodeTypes)) {
+            $nodeTypes = array_values($nodeTypes);
+            $list = $this->getPluralTypeName(array_shift($nodeTypes));
+            $count = count($nodeTypes);
+
+            foreach ($nodeTypes as $i => $nodeType) {
+                $list .= ($i === $count - 1 ? ' and ' : ', ').$this->getPluralTypeName($nodeType);
+            }
+
+            $state->throwException(
+                ucfirst($this->getPluralTypeName(get_class($token))).' can only happen on '.$list,
+                0,
+                $token
+            );
+        }
+    }
+
+    private function getClassLastPart($class)
+    {
+        $parts = explode('\\', $class);
+
+        return end($parts);
+    }
+
+    private function getTypeName($class)
+    {
+        $name = preg_replace('/(Token|Node)$/', '', $this->getClassLastPart($class));
+        $name = preg_replace('/([a-z])([A-Z])/', '$1-$2', $name);
+
+        return strtolower($name);
+    }
+
+    private function getPluralTypeName($class)
+    {
+        $name = $this->getTypeName($class);
+
+        if ($name === 'class') {
+            return 'classes';
+        }
+
+        return $name.'s';
+    }
+}

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

@@ -4,34 +4,18 @@ namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\AssignmentToken;
 use Phug\Lexer\Token\AttributeStartToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\AssignmentNode;
 use Phug\Parser\Node\ElementNode;
 use Phug\Parser\Node\MixinCallNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class AssignmentTokenHandler implements TokenHandlerInterface
+class AssignmentTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof AssignmentToken)) {
-            throw new \RuntimeException(
-                'You can only pass Assignment tokens to this token handler'
-            );
-        }
-
-        if (!$state->getCurrentNode()) {
-            $state->setCurrentNode($state->createNode(ElementNode::class, $token));
-        }
+    const TOKEN_TYPE = AssignmentToken::class;
 
-        if (!$state->currentNodeIs([ElementNode::class, MixinCallNode::class])) {
-            $state->throwException(
-                'Assignments can only happen on elements and mixinCalls',
-                0,
-                $token
-            );
-        }
+    public function handleAssignmentToken(AssignmentToken $token, State $state)
+    {
+        $this->onlyOnElement($token, $state);
 
         /** @var AssignmentNode $node */
         $node = $state->createNode(AssignmentNode::class, $token);
@@ -39,6 +23,7 @@ class AssignmentTokenHandler implements TokenHandlerInterface
 
         /** @var ElementNode|MixinCallNode $current */
         $current = $state->getCurrentNode();
+        $node->setOrder($current->getNextAttributeIndex());
         $current->getAssignments()->attach($node);
 
         if ($state->expectNext([AttributeStartToken::class])) {

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

@@ -3,18 +3,13 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\AttributeEndToken;
-use Phug\Lexer\TokenInterface;
-use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class AttributeEndTokenHandler implements TokenHandlerInterface
+class AttributeEndTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
+    const TOKEN_TYPE = AttributeEndToken::class;
+
+    public function handleAttributeEndToken()
     {
-        if (!($token instanceof AttributeEndToken)) {
-            throw new \RuntimeException(
-                'You can only pass attribute end tokens to this token handler'
-            );
-        }
+        // noop
     }
 }

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

@@ -5,7 +5,6 @@ namespace Phug\Parser\TokenHandler;
 use Phug\Lexer\Token\AttributeEndToken;
 use Phug\Lexer\Token\AttributeStartToken;
 use Phug\Lexer\Token\AttributeToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\AssignmentNode;
 use Phug\Parser\Node\ElementNode;
 use Phug\Parser\Node\FilterNode;
@@ -14,35 +13,20 @@ use Phug\Parser\Node\MixinCallNode;
 use Phug\Parser\Node\MixinNode;
 use Phug\Parser\Node\VariableNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class AttributeStartTokenHandler implements TokenHandlerInterface
+class AttributeStartTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof AttributeStartToken)) {
-            throw new \RuntimeException(
-                'You can only pass attribute start tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = AttributeStartToken::class;
 
-        if (!$state->getCurrentNode()) {
-            $state->setCurrentNode($state->createNode(ElementNode::class, $token));
-        }
-
-        if (!$state->currentNodeIs([
+    public function handleAttributeStartToken(AttributeStartToken $token, State $state)
+    {
+        $this->createElementNodeIfMissing($token, $state);
+        $this->assertCurrentNodeIs($token, $state, [
             ElementNode::class, AssignmentNode::class,
             ImportNode::class, VariableNode::class,
             MixinNode::class, MixinCallNode::class,
             FilterNode::class,
-        ])) {
-            $state->throwException(
-                'Attributes can only be placed on element, assignment, '
-                .'import, variable, filter, mixin and mixinCall',
-                0,
-                $token
-            );
-        }
+        ]);
 
         foreach ($state->lookUpNext([AttributeToken::class]) as $subToken) {
             $state->handleToken($subToken);

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

@@ -3,27 +3,21 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\AttributeToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\AssignmentNode;
 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\Util\AttributesOrderInterface;
+use Phug\Util\OrderableInterface;
 
-class AttributeTokenHandler implements TokenHandlerInterface
+class AttributeTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof AttributeToken)) {
-            throw new \RuntimeException(
-                'You can only pass attribute tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = AttributeToken::class;
 
-        if (!$state->getCurrentNode()) {
-            $state->setCurrentNode($state->createNode(ElementNode::class, $token));
-        }
+    public function handleAttributeToken(AttributeToken $token, State $state)
+    {
+        $this->createElementNodeIfMissing($token, $state);
 
         /** @var AttributeNode $node */
         $node = $state->createNode(AttributeNode::class, $token);
@@ -38,16 +32,24 @@ class AttributeTokenHandler implements TokenHandlerInterface
         // Mixin calls and assignments take the first
         // expression set as the name as the value
         if (($value === '' || $value === null) &&
-            $state->currentNodeIs([MixinCallNode::class, AssignmentNode::class])
+            (
+                $state->currentNodeIs([AssignmentNode::class]) ||
+                ($state->currentNodeIs([MixinCallNode::class]) && !$state->getCurrentNode()->areArgumentsCompleted())
+            )
         ) {
-            if (!$state->currentNodeIs([MixinCallNode::class]) || !$state->getCurrentNode()->areArgumentsCompleted()) {
-                $node->setValue($name);
-                $node->setName(null);
-            }
+            $node->setValue($name);
+            $node->setName(null);
         }
 
-        /** @var ElementNode|MixinCallNode $current */
+        /** @var ElementNode|MixinCallNode|AssignmentNode $current */
         $current = $state->getCurrentNode();
+
+        if ($current instanceof AttributesOrderInterface) {
+            $node->setOrder($current->getNextAttributeIndex());
+        } elseif ($current instanceof OrderableInterface) {
+            $node->setOrder($current->getOrder());
+        }
+
         $current->getAttributes()->attach($node);
     }
 }

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

@@ -3,28 +3,16 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\AutoCloseToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\ElementNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class AutoCloseTokenHandler implements TokenHandlerInterface
+class AutoCloseTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof AutoCloseToken)) {
-            throw new \RuntimeException(
-                'You can only pass auto-close tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = AutoCloseToken::class;
 
-        if (!$state->currentNodeIs([ElementNode::class])) {
-            $state->throwException(
-                'Auto-close operators can only be used on elements',
-                0,
-                $token
-            );
-        }
+    public function handleAutoCloseToken(AutoCloseToken $token, State $state)
+    {
+        $this->assertCurrentNodeIs($token, $state, [ElementNode::class]);
 
         $state->getCurrentNode()->autoClose();
     }

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

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

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

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

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

@@ -3,44 +3,17 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\ClassToken;
-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 ClassTokenHandler implements TokenHandlerInterface
+class ClassTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof ClassToken)) {
-            throw new \RuntimeException(
-                'You can only pass class 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(
-                'Classes can only be used on elements and mixin calls',
-                0,
-                $token
-            );
-        }
+    const TOKEN_TYPE = ClassToken::class;
 
-        //We actually create a fake class attribute
-        /** @var AttributeNode $attr */
-        $attr = $state->createNode(AttributeNode::class, $token);
-        $attr->setName('class');
-        $attr->setValue(var_export($token->getName(), true));
-        $attr->unescape()->uncheck();
-
-        /** @var ElementNode|MixinCallNode $current */
-        $current = $state->getCurrentNode();
-        $current->getAttributes()->attach($attr);
+    public function handleClassToken(ClassToken $token, State $state)
+    {
+        $this->attachStaticAttribute('class', $token, $state);
     }
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\ExpansionToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\ElementNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class ExpansionTokenHandler implements TokenHandlerInterface
+class ExpansionTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof ExpansionToken)) {
-            throw new \RuntimeException(
-                'You can only pass expansion tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = ExpansionToken::class;
 
+    public function handleExpansionToken(ExpansionToken $token, State $state)
+    {
         if (!$state->getCurrentNode()) {
             $state->throwException(
                 'Expansion needs an element to work on',
@@ -26,7 +20,7 @@ class ExpansionTokenHandler implements TokenHandlerInterface
             );
         }
 
-        if ($node = $state->getInterpolationNode()) {
+        if ($state->getInterpolationNode()) {
             //Make sure to keep the expansion
             $newNode = $state->createNode(ElementNode::class, $token);
             $newNode->setOuterNode($state->getCurrentNode());

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

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

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

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