gulp-phug 1.3.3 → 1.3.5

package/support/vendor/phug/phug/src/Phug/Lexer/Lexer/Scanner/FilterScanner.php

@@ -7,16 +7,18 @@
 namespace Phug\Lexer\Scanner;
 
 use Phug\Lexer\Analyzer\LineAnalyzer;
+use Phug\Lexer\Scanner\Partial\TrailingOutdentHandlerTrait;
 use Phug\Lexer\ScannerInterface;
 use Phug\Lexer\State;
 use Phug\Lexer\Token\FilterToken;
 use Phug\Lexer\Token\IndentToken;
 use Phug\Lexer\Token\NewLineToken;
-use Phug\Lexer\Token\OutdentToken;
 use Phug\Lexer\Token\TextToken;
 
 class FilterScanner implements ScannerInterface
 {
+    use TrailingOutdentHandlerTrait;
+
     public function scan(State $state)
     {
         $reader = $state->getReader();
@@ -55,7 +57,7 @@ class FilterScanner implements ScannerInterface
             $token = $state->createToken(TextToken::class);
             if ($maxIndent > 0 && $maxIndent < INF) {
                 foreach ($lines as &$line) {
-                    $line = mb_substr($line, $maxIndent) ?: '';
+                    $line = mb_substr((string) $line, $maxIndent);
                 }
             }
             $token->setValue(implode("\n", $lines));
@@ -66,14 +68,8 @@ class FilterScanner implements ScannerInterface
             $token->getSourceLocation()->setOffsetLength(1); //Let it have at least 1 length for debugging
             yield $token;
 
-            if ($reader->hasLength()) {
-                yield $state->createToken(NewLineToken::class);
-
-                $state->setLevel($analyzer->getNewLevel())->indent($analyzer->getLevel() + 1);
-
-                while ($state->nextOutdent() !== false) {
-                    yield $state->createToken(OutdentToken::class);
-                }
+            foreach ($this->yieldTrailingOutdent($analyzer, $state) as $token) {
+                yield $token;
             }
         }
     }

package/support/vendor/phug/phug/src/Phug/Lexer/Lexer/Scanner/IndentationScanner.php

@@ -98,7 +98,7 @@ class IndentationScanner implements ScannerInterface
         $newLevel = $this->getIndentLevel($state, INF, function () use (&$indent) {
             $char = null;
 
-            if (mb_strlen($indent)) {
+            if ($indent !== null && mb_strlen($indent)) {
                 $char = mb_substr($indent, 0, 1);
                 $indent = mb_substr($indent, 1);
             }

package/support/vendor/phug/phug/src/Phug/Lexer/Lexer/Scanner/KeywordScanner.php

@@ -24,7 +24,7 @@ class KeywordScanner implements ScannerInterface
             )) {
                 $name = $reader->getMatch('name');
 
-                if (in_array($name, $keywords)) {
+                if (in_array($name, $keywords, true)) {
                     $value = $reader->getMatch('value');
                     if (mb_substr($value, 0, 1) === ' ') {
                         $value = mb_substr($value, 1);

package/support/vendor/phug/phug/src/Phug/Lexer/Lexer/Scanner/MultilineScanner.php

@@ -7,19 +7,21 @@
 namespace Phug\Lexer\Scanner;
 
 use Phug\Lexer\Analyzer\LineAnalyzer;
+use Phug\Lexer\Scanner\Partial\TrailingOutdentHandlerTrait;
 use Phug\Lexer\ScannerInterface;
 use Phug\Lexer\State;
 use Phug\Lexer\Token\IndentToken;
 use Phug\Lexer\Token\InterpolationEndToken;
 use Phug\Lexer\Token\InterpolationStartToken;
 use Phug\Lexer\Token\NewLineToken;
-use Phug\Lexer\Token\OutdentToken;
 use Phug\Lexer\Token\TagInterpolationEndToken;
 use Phug\Lexer\Token\TagInterpolationStartToken;
 use Phug\Lexer\Token\TextToken;
 
 class MultilineScanner implements ScannerInterface
 {
+    use TrailingOutdentHandlerTrait;
+
     protected function unEscapedToken(State $state, $buffer)
     {
         /** @var TextToken $token */
@@ -83,8 +85,6 @@ class MultilineScanner implements ScannerInterface
 
     private function yieldLines(State $state, array $lines, LineAnalyzer $analyzer)
     {
-        $reader = $state->getReader();
-
         yield $state->createToken(IndentToken::class);
 
         $maxIndent = $analyzer->getMaxIndent();
@@ -92,7 +92,7 @@ class MultilineScanner implements ScannerInterface
         if ($maxIndent > 0 && $maxIndent < INF) {
             foreach ($lines as &$line) {
                 if (count($line) && is_string($line[0])) {
-                    $line[0] = mb_substr($line[0], $maxIndent) ?: '';
+                    $line[0] = mb_substr((string) $line[0], $maxIndent);
                 }
             }
         }
@@ -101,14 +101,8 @@ class MultilineScanner implements ScannerInterface
             yield $token;
         }
 
-        if ($reader->hasLength()) {
-            yield $state->createToken(NewLineToken::class);
-
-            $state->setLevel($analyzer->getNewLevel())->indent($analyzer->getLevel() + 1);
-
-            while ($state->nextOutdent() !== false) {
-                yield $state->createToken(OutdentToken::class);
-            }
+        foreach ($this->yieldTrailingOutdent($analyzer, $state) as $token) {
+            yield $token;
         }
     }
 

package/support/vendor/phug/phug/src/Phug/Lexer/Lexer/Scanner/Partial/TrailingOutdentHandlerTrait.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Phug\Lexer\Scanner\Partial;
+
+use Phug\Lexer\Analyzer\LineAnalyzer;
+use Phug\Lexer\State;
+use Phug\Lexer\Token\NewLineToken;
+use Phug\Lexer\Token\OutdentToken;
+
+trait TrailingOutdentHandlerTrait
+{
+    private function yieldTrailingOutdent(LineAnalyzer $analyzer, State $state)
+    {
+        $reader = $state->getReader();
+
+        if ($reader->hasLength()) {
+            yield $state->createToken(NewLineToken::class);
+
+            $state->setLevel($analyzer->getNewLevel())->indent($analyzer->getLevel() + 1);
+
+            while ($state->nextOutdent() !== false) {
+                yield $state->createToken(OutdentToken::class);
+            }
+        }
+    }
+}

package/support/vendor/phug/phug/src/Phug/Lexer/Lexer/Scanner/TextScanner.php

@@ -19,7 +19,7 @@ class TextScanner implements ScannerInterface
 
     private function isTextStartToTrim(State $state, $text)
     {
-        return in_array(mb_substr($text, 0, 1), [' ', "\t"]) && !$state->isAfterInterpolation();
+        return in_array(mb_substr((string) $text, 0, 1), [' ', "\t"], true) && !$state->isAfterInterpolation();
     }
 
     private function leftTrimValueIfNotAfterInterpolation(State $state, TextToken $token)
@@ -27,7 +27,7 @@ class TextScanner implements ScannerInterface
         $text = $token->getValue();
 
         if ($this->isTextStartToTrim($state, $text)) {
-            $token->setValue(mb_substr($text, 1) ?: '');
+            $token->setValue(mb_substr((string) $text, 1));
         }
     }
 
@@ -87,7 +87,7 @@ class TextScanner implements ScannerInterface
             $text = mb_substr($text, 1);
         }
 
-        $text = preg_replace('/\\\\([#!]\\[|#\\{)/', '$1', $text);
+        $text = preg_replace('/\\\\([#!]\\[|#{)/', '$1', $text);
         $token->setValue($text);
 
         yield $state->endToken($token);

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

@@ -230,20 +230,20 @@ class State implements OptionInterface
      * use the `loopScan`-method
      *
      * @param array|string $scanners the scanners to run
+     * @param array        $options  options to be passed for the scanner
      *
      * @throws LexerException
      *
      * @return iterable the generator yielding all tokens found
      */
-    public function scan($scanners)
+    public function scan($scanners, array $options = [])
     {
         $scanners = $this->filterScanners($scanners);
 
-        foreach ($scanners as $key => $scanner) {
-
+        foreach ($scanners as $scanner) {
             /** @var ScannerInterface $scanner */
             $success = false;
-            foreach ($scanner->scan($this) as $token) {
+            foreach ($scanner->scan($this, $options) as $token) {
                 if (!($token instanceof TokenInterface)) {
                     $this->throwException(
                         'Scanner '.get_class($scanner).' generated a result that is not a '.TokenInterface::class
@@ -266,7 +266,7 @@ class State implements OptionInterface
      * If the second argument is true, it will throw an exception if none of the scanners
      * produced any valid tokens. The reading also stops when the end of the input as been reached.
      *
-     * @param $scanners
+     * @param      $scanners
      * @param bool $required
      *
      * @throws LexerException
@@ -329,7 +329,7 @@ class State implements OptionInterface
         return new $className(
             $this->createCurrentSourceLocation(),
             $this->level,
-            str_repeat($this->getIndentStyle(), $this->getIndentWidth())
+            str_repeat((string) $this->getIndentStyle(), (int) $this->getIndentWidth())
         );
     }
 
@@ -345,9 +345,9 @@ class State implements OptionInterface
      * in scanners as you can simply return it's value without having to check for it to be null.
      *
      *
-     * @param $className
-     * @param $pattern
-     * @param null $modifiers
+     * @param class-string $className
+     * @param string       $pattern
+     * @param string|null  $modifiers
      *
      * @return iterable
      */

package/support/vendor/phug/phug/src/Phug/Lexer/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/Parser/Parser/Event/NodeEvent.php

@@ -4,6 +4,7 @@ namespace Phug\Parser\Event;
 
 use Phug\Event;
 use Phug\Parser\NodeInterface;
+use Phug\ParserEvent;
 
 class NodeEvent extends Event
 {
@@ -12,8 +13,8 @@ class NodeEvent extends Event
     /**
      * NodeEvent constructor.
      *
-     * @param $name
-     * @param NodeInterface $node
+     * @param ParserEvent::* $name
+     * @param NodeInterface  $node
      */
     public function __construct($name, NodeInterface $node)
     {

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

@@ -3,11 +3,15 @@
 namespace Phug\Parser\Node;
 
 use Phug\Parser\Node;
+use Phug\Util\AttributesInterface;
+use Phug\Util\OrderableInterface;
 use Phug\Util\Partial\AttributeTrait;
 use Phug\Util\Partial\NameTrait;
+use Phug\Util\Partial\OrderTrait;
 
-class AssignmentNode extends Node
+class AssignmentNode extends Node implements AttributesInterface, OrderableInterface
 {
     use NameTrait;
     use AttributeTrait;
+    use OrderTrait;
 }

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

@@ -3,17 +3,20 @@
 namespace Phug\Parser\Node;
 
 use Phug\Parser\Node;
+use Phug\Util\OrderableInterface;
 use Phug\Util\Partial\CheckTrait;
 use Phug\Util\Partial\EscapeTrait;
 use Phug\Util\Partial\NameTrait;
+use Phug\Util\Partial\OrderTrait;
 use Phug\Util\Partial\ValueTrait;
 use Phug\Util\Partial\VariadicTrait;
 
-class AttributeNode extends Node
+class AttributeNode extends Node implements OrderableInterface
 {
     use NameTrait;
     use ValueTrait;
     use EscapeTrait;
     use CheckTrait;
     use VariadicTrait;
+    use OrderTrait;
 }

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

@@ -3,15 +3,19 @@
 namespace Phug\Parser\Node;
 
 use Phug\Parser\Node;
+use Phug\Util\AttributesInterface;
+use Phug\Util\AttributesOrderInterface;
 use Phug\Util\Partial\AssignmentTrait;
+use Phug\Util\Partial\AttributesOrderTrait;
 use Phug\Util\Partial\AttributeTrait;
 use Phug\Util\Partial\NameTrait;
 
-class ElementNode extends Node
+class ElementNode extends Node implements AttributesInterface, AttributesOrderInterface
 {
     use NameTrait;
     use AttributeTrait;
     use AssignmentTrait;
+    use AttributesOrderTrait;
 
     /**
      * @var bool

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

@@ -3,10 +3,11 @@
 namespace Phug\Parser\Node;
 
 use Phug\Parser\Node;
+use Phug\Util\AttributesInterface;
 use Phug\Util\Partial\AttributeTrait;
 use Phug\Util\Partial\NameTrait;
 
-class FilterNode extends Node
+class FilterNode extends Node implements AttributesInterface
 {
     use NameTrait;
     use AttributeTrait;

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

@@ -3,15 +3,19 @@
 namespace Phug\Parser\Node;
 
 use Phug\Parser\Node;
+use Phug\Util\AttributesInterface;
+use Phug\Util\AttributesOrderInterface;
 use Phug\Util\Partial\AssignmentTrait;
+use Phug\Util\Partial\AttributesOrderTrait;
 use Phug\Util\Partial\AttributeTrait;
 use Phug\Util\Partial\NameTrait;
 
-class MixinCallNode extends Node
+class MixinCallNode extends Node implements AttributesInterface, AttributesOrderInterface
 {
     use NameTrait;
     use AttributeTrait;
     use AssignmentTrait;
+    use AttributesOrderTrait;
 
     /**
      * @var bool

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

@@ -3,13 +3,17 @@
 namespace Phug\Parser\Node;
 
 use Phug\Parser\Node;
+use Phug\Util\AttributesInterface;
+use Phug\Util\AttributesOrderInterface;
 use Phug\Util\Partial\AssignmentTrait;
+use Phug\Util\Partial\AttributesOrderTrait;
 use Phug\Util\Partial\AttributeTrait;
 use Phug\Util\Partial\NameTrait;
 
-class MixinNode extends Node
+class MixinNode extends Node implements AttributesInterface, AttributesOrderInterface
 {
     use NameTrait;
     use AttributeTrait;
     use AssignmentTrait;
+    use AttributesOrderTrait;
 }

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