gulp-phug 1.3.3 → 1.3.5

package/support/vendor/phug/phug/src/Phug/Formatter/Formatter/Element/MixinElement.php

@@ -3,10 +3,11 @@
 namespace Phug\Formatter\Element;
 
 use Phug\Formatter\AbstractElement;
+use Phug\Util\AttributesInterface;
 use Phug\Util\Partial\AttributeTrait;
 use Phug\Util\Partial\NameTrait;
 
-class MixinElement extends AbstractElement
+class MixinElement extends AbstractElement implements AttributesInterface
 {
     use AttributeTrait;
     use NameTrait;

package/support/vendor/phug/phug/src/Phug/Formatter/Formatter/Format/XmlFormat.php

@@ -2,8 +2,12 @@
 
 namespace Phug\Formatter\Format;
 
+use Closure;
+use Generator;
+use InvalidArgumentException;
 use Phug\Formatter;
 use Phug\Formatter\AbstractFormat;
+use Phug\Formatter\AssignmentContainerInterface;
 use Phug\Formatter\Element\AbstractValueElement;
 use Phug\Formatter\Element\AssignmentElement;
 use Phug\Formatter\Element\AttributeElement;
@@ -16,7 +20,9 @@ use Phug\Formatter\ElementInterface;
 use Phug\Formatter\MarkupInterface;
 use Phug\Formatter\Partial\AssignmentHelpersTrait;
 use Phug\FormatterException;
+use Phug\Util\AttributesInterface;
 use Phug\Util\Joiner;
+use Phug\Util\OrderedValue;
 use SplObjectStorage;
 
 class XmlFormat extends AbstractFormat
@@ -161,19 +167,23 @@ class XmlFormat extends AbstractFormat
         $value = $element->getValue();
         $name = $element->getName();
         $nonEmptyAttribute = ($name === 'class' || $name === 'id');
+
         if ($nonEmptyAttribute && (
             !$value ||
-            ($value instanceof TextElement && ($value->getValue() ?: '') === '') ||
-            (is_string($value) && in_array(trim($value), ['', '""', "''"]))
+            ($value instanceof TextElement && ((string) $value->getValue()) === '') ||
+            (is_string($value) && in_array(trim($value), ['', '""', "''"], true))
         )) {
             return '';
         }
+
         if ($value instanceof ExpressionElement) {
-            if ($nonEmptyAttribute && in_array(trim($value->getValue()), ['', '""', "''"])) {
+            if ($nonEmptyAttribute && in_array(trim($value->getValue()), ['', '""', "''"], true)) {
                 return '';
             }
+
             if (strtolower($value->getValue()) === 'true') {
                 $formattedValue = null;
+
                 if ($name instanceof ExpressionElement) {
                     $bufferVariable = $this->pattern('buffer_variable');
                     $name = $this->pattern(
@@ -187,6 +197,7 @@ class XmlFormat extends AbstractFormat
                     $value = new ExpressionElement($bufferVariable);
                     $formattedValue = $this->format($value);
                 }
+
                 $formattedName = $this->format($name);
                 $formattedValue = $formattedValue || $formattedValue === '0'
                     ? $formattedValue
@@ -198,7 +209,8 @@ class XmlFormat extends AbstractFormat
                     $formattedValue
                 );
             }
-            if (in_array(strtolower($value->getValue()), ['false', 'null', 'undefined'])) {
+
+            if (in_array(strtolower($value->getValue()), ['false', 'null', 'undefined'], true)) {
                 return '';
             }
         }
@@ -265,26 +277,172 @@ class XmlFormat extends AbstractFormat
 
         /* @var MarkupElement $markup */
         $markup = $element->getContainer();
+        $attributeOrder = $this->hasOption('attribute_precedence')
+            ? $this->getOption('attribute_precedence')
+            : 'assignment';
+
+        switch ($attributeOrder) {
+            case 'assignment':
+            case 'assignments':
+                $arguments = array_merge(
+                    $markup instanceof AttributesInterface
+                        ? $this->formatMarkupAttributes($markup)
+                        : [],
+                    $markup instanceof AssignmentContainerInterface
+                        ? $this->formatAttributeAssignments($markup)
+                        : []
+                );
+                break;
+
+            case 'attribute':
+            case 'attributes':
+                $arguments = array_merge(
+                    $markup instanceof AssignmentContainerInterface
+                        ? $this->formatAttributeAssignments($markup)
+                        : [],
+                    $markup instanceof AttributesInterface
+                        ? $this->formatMarkupAttributes($markup)
+                        : []
+                );
+                break;
+
+            case 'left':
+                $arguments = $this->getSortedAttributes($markup, static function (OrderedValue $a, OrderedValue $b) {
+                    return $b->getOrder() - $a->getOrder();
+                });
+                break;
+
+            case 'right':
+                $arguments = $this->getSortedAttributes($markup, static function (OrderedValue $a, OrderedValue $b) {
+                    return $a->getOrder() - $b->getOrder();
+                });
+                break;
 
+            default:
+                if (!is_callable($attributeOrder)) {
+                    throw new InvalidArgumentException(
+                        'Option attribute_precedence must be '.
+                        '"assignment" (default), "attribute", "left", "right" or a callable.'
+                    );
+                }
+
+                $arguments = array_map(static function ($argument) {
+                    return $argument instanceof OrderedValue ? $argument->getValue() : $argument;
+                }, $attributeOrder(
+                    $markup instanceof AssignmentContainerInterface
+                        ? $this->formatOrderedAttributeAssignments($markup)
+                        : [],
+                    $markup instanceof AttributesInterface
+                        ? $this->formatOrderedMarkupAttributes($markup)
+                        : []
+                ));
+        }
+
+        foreach ($markup->getAssignments() as $assignment) {
+            /* @var AssignmentElement $assignment */
+            $this->throwException(
+                'Unable to handle '.$assignment->getName().' assignment',
+                $assignment
+            );
+        }
+
+        if (count($arguments)) {
+            yield $this->attributesAssignmentsFromPairs($arguments);
+        }
+    }
+
+    /**
+     * @param AssignmentContainerInterface $markup
+     *
+     * @return array<string>
+     */
+    protected function formatAttributeAssignments(AssignmentContainerInterface $markup)
+    {
+        $arguments = [];
+
+        foreach ($this->yieldAssignmentAttributes($markup) as $attribute) {
+            $arguments[] = $this->formatInnerCodeValue($attribute);
+        }
+
+        return $arguments;
+    }
+
+    /**
+     * @param AssignmentContainerInterface $markup
+     *
+     * @return list<OrderedValue<string>>
+     */
+    protected function formatOrderedAttributeAssignments(AssignmentContainerInterface $markup)
+    {
         $arguments = [];
 
+        foreach ($this->yieldAssignmentOrderedAttributes($markup) as $attribute => $order) {
+            $arguments[] = new OrderedValue($this->formatInnerCodeValue($attribute), $order);
+        }
+
+        return $arguments;
+    }
+
+    /**
+     * @param AbstractValueElement|mixed $value
+     *
+     * @return string
+     */
+    protected function formatInnerCodeValue($value)
+    {
+        $checked = method_exists($value, 'isChecked') && $value->isChecked();
+
+        while (method_exists($value, 'getValue')) {
+            $value = $value->getValue();
+        }
+
+        return $this->formatCode($value, $checked);
+    }
+
+    /**
+     * @param AssignmentContainerInterface $markup
+     *
+     * @return Generator<AbstractValueElement>
+     */
+    protected function yieldAssignmentAttributes(AssignmentContainerInterface $markup)
+    {
         foreach ($markup->getAssignmentsByName('attributes') as $attributesAssignment) {
             /* @var AssignmentElement $attributesAssignment */
             foreach ($attributesAssignment->getAttributes() as $attribute) {
                 /* @var AbstractValueElement $attribute */
-                $value = $attribute;
-                $checked = method_exists($value, 'isChecked') && $value->isChecked();
+                yield $attribute;
+            }
 
-                while (method_exists($value, 'getValue')) {
-                    $value = $value->getValue();
-                }
+            $markup->removedAssignment($attributesAssignment);
+        }
+    }
 
-                $arguments[] = $this->formatCode($value, $checked);
+    /**
+     * @param AssignmentContainerInterface $markup
+     *
+     * @return Generator<AbstractValueElement, int|null>
+     */
+    protected function yieldAssignmentOrderedAttributes(AssignmentContainerInterface $markup)
+    {
+        foreach ($markup->getAssignmentsByName('attributes') as $attributesAssignment) {
+            /* @var AssignmentElement $attributesAssignment */
+            foreach ($attributesAssignment->getAttributes() as $attribute) {
+                /* @var AbstractValueElement $attribute */
+                yield $attribute => $attributesAssignment->getOrder();
             }
 
             $markup->removedAssignment($attributesAssignment);
         }
+    }
 
+    /**
+     * @param AttributesInterface $markup
+     *
+     * @return list<string>
+     */
+    protected function formatMarkupAttributes(AttributesInterface $markup)
+    {
+        $arguments = [];
         $attributes = $markup->getAttributes();
 
         foreach ($attributes as $attribute) {
@@ -294,17 +452,27 @@ class XmlFormat extends AbstractFormat
 
         $attributes->removeAll($attributes);
 
-        foreach ($markup->getAssignments() as $assignment) {
-            /* @var AssignmentElement $assignment */
-            $this->throwException(
-                'Unable to handle '.$assignment->getName().' assignment',
-                $assignment
-            );
-        }
+        return $arguments;
+    }
 
-        if (count($arguments)) {
-            yield $this->attributesAssignmentsFromPairs($arguments);
+    /**
+     * @param AttributesInterface $markup
+     *
+     * @return list<OrderedValue<string>>
+     */
+    protected function formatOrderedMarkupAttributes(AttributesInterface $markup)
+    {
+        $arguments = [];
+        $attributes = $markup->getAttributes();
+
+        foreach ($attributes as $attribute) {
+            /* @var AttributeElement $attribute */
+            $arguments[] = new OrderedValue($this->formatAttributeAsArrayItem($attribute), $attribute->getOrder());
         }
+
+        $attributes->removeAll($attributes);
+
+        return $arguments;
     }
 
     /**
@@ -325,7 +493,9 @@ class XmlFormat extends AbstractFormat
             $names = [];
             foreach ($element->getAttributes() as $attribute) {
                 $name = $attribute->getName();
-                if (($name instanceof ExpressionElement && !$name->hasStaticValue()) || in_array($name, $names)) {
+                if (($name instanceof ExpressionElement && !$name->hasStaticValue()) ||
+                    in_array($name, $names, true)
+                ) {
                     return true;
                 }
 
@@ -395,4 +565,27 @@ class XmlFormat extends AbstractFormat
             ? $this->getIndent().$tag.$this->getNewLine()
             : $tag;
     }
+
+    /**
+     * @param AssignmentContainerInterface|AttributesInterface|mixed $markup
+     * @param Closure(OrderedValue, OrderedValue): int               $sorter
+     *
+     * @return list<string>
+     */
+    private function getSortedAttributes($markup, Closure $sorter)
+    {
+        $arguments = array_merge(
+            $markup instanceof AssignmentContainerInterface
+                ? $this->formatOrderedAttributeAssignments($markup)
+                : [],
+            $markup instanceof AttributesInterface
+                ? $this->formatOrderedMarkupAttributes($markup)
+                : []
+        );
+        usort($arguments, $sorter);
+
+        return array_map(static function (OrderedValue $value) {
+            return $value->getValue();
+        }, $arguments);
+    }
 }

package/support/vendor/phug/phug/src/Phug/Formatter/Formatter/Partial/AssignmentHelpersTrait.php

@@ -14,7 +14,7 @@ trait AssignmentHelpersTrait
             'get_helper',
             function ($availableAssignments, $getHelper) {
                 return function (&$attributes, $name, $value) use ($availableAssignments, $getHelper) {
-                    if (!in_array($name, $availableAssignments)) {
+                    if (!in_array($name, $availableAssignments, true)) {
                         return $value;
                     }
 
@@ -37,7 +37,7 @@ trait AssignmentHelpersTrait
                 return function (&$attributes, $name, $value) use ($attributeAssignments) {
                     if (isset($name) && $name !== '') {
                         $result = $attributeAssignments($attributes, $name, $value);
-                        if (($result !== null && $result !== false && ($result !== '' || $name !== 'class'))) {
+                        if ($result !== null && $result !== false && ($result !== '' || $name !== 'class')) {
                             $attributes[$name] = $result;
                         }
                     }
@@ -143,7 +143,7 @@ trait AssignmentHelpersTrait
                 'pattern.html_text_escape',
                 function ($arrayEscape, $escape) {
                     return function ($name, $input) use ($arrayEscape, $escape) {
-                        if (is_array($input) && in_array(strtolower($name), ['class', 'style'])) {
+                        if (is_array($input) && in_array(strtolower($name), ['class', 'style'], true)) {
                             $result = [];
                             foreach ($input as $key => $value) {
                                 $result[$escape($key)] = $arrayEscape($name, $value);
@@ -183,7 +183,7 @@ trait AssignmentHelpersTrait
                     $input = $key;
                 }
                 foreach ($split($input) as $class) {
-                    if (!in_array($class, $classes)) {
+                    if (!in_array($class, $classes, true)) {
                         $classes[] = $class;
                     }
                 }
@@ -202,11 +202,14 @@ trait AssignmentHelpersTrait
             if (is_string($value) && mb_substr($value, 0, 7) === '{"') {
                 $value = json_decode(htmlspecialchars_decode($value));
             }
+
             $styles = isset($attributes['style']) ? array_filter(explode(';', $attributes['style'])) : [];
+
             foreach ((array) $value as $propertyName => $propertyValue) {
                 if (!is_int($propertyName)) {
                     $propertyValue = $propertyName.':'.$propertyValue;
                 }
+
                 $styles[] = $propertyValue;
             }
 

package/support/vendor/phug/phug/src/Phug/Formatter/Formatter/Partial/HandleVariable.php

@@ -24,7 +24,7 @@ trait HandleVariable
     {
         $afterOpen = false;
         for ($i = $index - 1; $i >= 0; $i--) {
-            if (in_array($tokens[$i], [')', '}'])) {
+            if (in_array($tokens[$i], [')', '}'], true)) {
                 break;
             }
             if ($tokens[$i] === '(') {
@@ -34,7 +34,7 @@ trait HandleVariable
             if ($afterOpen && is_array($tokens[$i]) && in_array($tokens[$i][0], [
                 T_FUNCTION,
                 T_USE,
-            ])) {
+            ], true)) {
                 return true;
             }
         }
@@ -102,13 +102,13 @@ trait HandleVariable
                     T_COMMENT,
                     T_DOC_COMMENT,
                     T_WHITESPACE,
-                ])) {
+                ], true)) {
                     continue;
                 }
                 break;
             }
 
-            if (in_array($tokenId, $exclusions)) {
+            if (in_array($tokenId, $exclusions, true)) {
                 return true;
             }
         }

package/support/vendor/phug/phug/src/Phug/Formatter/Formatter/Partial/MagicAccessorTrait.php

@@ -6,13 +6,7 @@ trait MagicAccessorTrait
 {
     private function getMethod($prefix, $name)
     {
-        switch ($name) {
-            case 'nodes':
-                $name = 'children';
-                break;
-        }
-
-        return $prefix.ucfirst($name);
+        return $prefix.ucfirst($name === 'nodes' ? 'children' : $name);
     }
 
     public function __get($name)

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

@@ -504,7 +504,7 @@ class Formatter implements ModuleContainerInterface
         }
 
         foreach ($this->mixins->getRequirementsStates() as $key => $value) {
-            if ($value || $this->mixinsAllRequired || in_array($key, $this->mixinsPreCalled)) {
+            if ($value || $this->mixinsAllRequired || in_array($key, $this->mixinsPreCalled, true)) {
                 $dependencies .= $this->mixins->get($key);
             }
         }

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

@@ -7,8 +7,7 @@
     "homepage": "http://phug-lang.com",
     "authors": [
         {
-            "name": "KyleKatarn",
-            "email": "jade-php@selfbuild.fr",
+            "name": "kylekatarnls",
             "homepage": "http://github.com/kylekatarnls"
         },
         {

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

@@ -107,7 +107,7 @@ class Invoker implements InvokerInterface
             $filteredQueue = new ListenerQueue();
 
             foreach ($queue as $invokable) {
-                if (!in_array($invokable, $invokables)) {
+                if (!in_array($invokable, $invokables, true)) {
                     $filteredQueue->insert($invokable, 0);
                 }
             }

package/support/vendor/phug/phug/src/Phug/Invoker/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/Lexer/Lexer/Partial/IndentStyleTrait.php

@@ -23,7 +23,7 @@ trait IndentStyleTrait
     /**
      * Returns the currently used indentation style.
      *
-     * @return string
+     * @return string|null
      */
     public function getIndentStyle()
     {
@@ -36,13 +36,13 @@ trait IndentStyleTrait
      * The value needs to be one of the `Lexer::INDENT_*` constants, but you can also just
      * pass either a single space or a single tab for the respective style.
      *
-     * @param $indentStyle
+     * @param string|null $indentStyle
      *
      * @return $this
      */
     public function setIndentStyle($indentStyle)
     {
-        if (!in_array($indentStyle, [null, Lexer::INDENT_TAB, Lexer::INDENT_SPACE])) {
+        if (!in_array($indentStyle, [null, Lexer::INDENT_TAB, Lexer::INDENT_SPACE], true)) {
             throw new \InvalidArgumentException(
                 'indentStyle needs to be null or one of the INDENT_* constants of the lexer'
             );
@@ -56,7 +56,7 @@ trait IndentStyleTrait
     /**
      * Returns the currently used indentation width.
      *
-     * @return int
+     * @return int|null
      */
     public function getIndentWidth()
     {
@@ -68,7 +68,7 @@ trait IndentStyleTrait
      *
      * The value of this specifies if e.g. 2 spaces make up one indentation level or 4.
      *
-     * @param $indentWidth
+     * @param int|null $indentWidth
      *
      * @return $this
      */

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

@@ -14,9 +14,15 @@ class AssignmentScanner implements ScannerInterface
 {
     public function scan(State $state)
     {
-        return $state->scanToken(
+        foreach ($state->scanToken(
             AssignmentToken::class,
             '&(?<name>[a-zA-Z_][a-zA-Z0-9\-_]*)'
-        );
+        ) as $token) {
+            yield $token;
+
+            foreach ($state->scan(AttributeScanner::class, ['allow_name' => false]) as $attributeToken) {
+                yield $attributeToken;
+            }
+        }
     }
 }

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

@@ -30,7 +30,7 @@ class AttributeScanner implements ScannerInterface
         $expression = preg_replace('/
                 "(?:\\\\[\\S\\s]|[^"\\\\])*"|
                 \'(?:\\\\[\\S\\s]|[^\'\\\\])*\'
-            /x', '0', $expression);
+            /x', '0', (string) $expression);
         $expression = preg_replace('/\\s*(
                 (\\[([^\\[\\]]+|(?1))*\\]) |
                 (\\(([^\\(\\)]+|(?1))*\\)) |
@@ -42,6 +42,8 @@ class AttributeScanner implements ScannerInterface
 
     private function isTruncatedExpression(Reader $reader, &$expression)
     {
+        $expression = (string) $expression;
+
         if (mb_substr($expression, -3) === 'new' || mb_substr($expression, -5) === 'clone') {
             $expression .= $reader->getLastPeekResult();
             $reader->consume();
@@ -118,13 +120,15 @@ class AttributeScanner implements ScannerInterface
         return $expression;
     }
 
-    private function readAttributeValue(Reader $reader, AttributeToken $token)
+    private function readAttributeValue(Reader $reader, AttributeToken $token, $expression = '')
     {
-        $expression = $this->getAttributeValue($reader);
+        $expression .= $this->getAttributeValue($reader);
+
         while ($this->isTruncatedExpression($reader, $expression)) {
             $this->skipComments($reader);
             $expression .= $this->getAttributeValue($reader);
         }
+
         $token->setValue($expression);
 
         //Ignore a comma if found
@@ -210,7 +214,7 @@ class AttributeScanner implements ScannerInterface
         $token->escape();
         $token->check();
 
-        if ($variadic = $reader->peekString('...')) {
+        if ($reader->peekString('...')) {
             $token->setIsVariadic(true);
             $reader->consume();
         }
@@ -218,9 +222,17 @@ class AttributeScanner implements ScannerInterface
         return $token;
     }
 
-    private function seedAttributeToken(State $state, AttributeToken $token, $expression)
+    private function seedAttributeToken(State $state, AttributeToken $token, $expression, array $options)
     {
         $reader = $state->getReader();
+        $allowName = isset($options['allow_name']) ? $options['allow_name'] : true;
+
+        if (!$allowName) {
+            $this->readAttributeValue($reader, $token, $expression);
+            $this->skipComments($reader);
+
+            return;
+        }
 
         $token->setName($expression);
 
@@ -252,7 +264,7 @@ class AttributeScanner implements ScannerInterface
         }
     }
 
-    private function scanParenthesesContent(State $state)
+    private function scanParenthesesContent(State $state, array $options)
     {
         $reader = $state->getReader();
 
@@ -263,7 +275,7 @@ class AttributeScanner implements ScannerInterface
                 continue;
             }
 
-            $this->seedAttributeToken($state, $token, $expression);
+            $this->seedAttributeToken($state, $token, $expression, $options);
 
             yield $token;
 
@@ -275,7 +287,7 @@ class AttributeScanner implements ScannerInterface
         }
     }
 
-    private function scanParentheses(State $state)
+    private function scanParentheses(State $state, array $options)
     {
         $reader = $state->getReader();
 
@@ -283,7 +295,7 @@ class AttributeScanner implements ScannerInterface
             return;
         }
 
-        foreach ($this->scanParenthesesContent($state) as $token) {
+        foreach ($this->scanParenthesesContent($state, $options) as $token) {
             yield $token;
         }
 
@@ -294,7 +306,7 @@ class AttributeScanner implements ScannerInterface
         }
     }
 
-    public function scan(State $state)
+    public function scan(State $state, array $options = [])
     {
         $reader = $state->getReader();
 
@@ -307,7 +319,7 @@ class AttributeScanner implements ScannerInterface
         $reader->consume();
         yield $state->endToken($start);
 
-        foreach ($this->scanParentheses($state) as $token) {
+        foreach ($this->scanParentheses($state, $options) as $token) {
             yield $token;
         }
 

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

@@ -26,7 +26,7 @@ class ConditionalScanner extends ControlStatementScanner
                 //Make sure spaces are replaced from `elseif`/`else if` to make a final keyword, "elseif"
                 $token->setName(preg_replace('/[ \t]/', '', $token->getName()));
 
-                if ($token->getName() === 'else' && !in_array($token->getSubject(), ['', false, null])) {
+                if ($token->getName() === 'else' && !in_array($token->getSubject(), ['', false, null], true)) {
                     $state->throwException(
                         'The `else`-conditional statement can\'t have a subject'
                     );