Changeset 115301 in spip-zone


Ignore:
Timestamp:
May 10, 2019, 8:03:27 AM (9 days ago)
Author:
cedric@…
Message:

Mise a jour de la lib ScssPHP en version 0.8.2+ depuis https://github.com/Cerdic/scssphp/tree/maint/leafo/master qui resoud encore un certain nombre de bugs du compilateur
C'est sans doute la derniere version qui tourne encore en PHP 5.4 car le prerequis vient de passer a PHP 5.6,
on va donc archiver la branche a suivre pour les utilisateurs de vieilles versions SPIP et passer cette branche du plugin en compat SPIP 3.1+/PHP 5.6+ uniquement

Location:
_plugins_/scssphp/trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/scssphp/trunk/lib/scssphp/src/Block.php

    r115043 r115301  
    6363     */
    6464    public $children;
     65
    6566    /**
    6667     * @var \Leafo\ScssPhp\Block
  • _plugins_/scssphp/trunk/lib/scssphp/src/Compiler.php

    r115183 r115301  
    150150
    151151    protected $indentLevel;
    152     protected $commentsSeen;
    153152    protected $extends;
    154153    protected $extendsMap;
     
    227226
    228227        $this->indentLevel    = -1;
    229         $this->commentsSeen   = [];
    230228        $this->extends        = [];
    231229        $this->extendsMap     = [];
     
    484482
    485483    /**
     484     * Glue parts of :not( or :nth-child( ... that are in general splitted in selectors parts
     485     *
     486     * @param array $parts
     487     *
     488     * @return array
     489     */
     490    protected function glueFunctionSelectors($parts)
     491    {
     492        $new = [];
     493        foreach ($parts as $part) {
     494            if (is_array($part)) {
     495                $part = $this->glueFunctionSelectors($part);
     496                $new[] = $part;
     497            } else {
     498                // a selector part finishing with a ) is the last part of a :not( or :nth-child(
     499                // and need to be joined to this
     500                if (count($new) && is_string($new[count($new) - 1])
     501                    && strlen($part) && substr($part, -1) === ')' && strpos($part, '(') === false
     502                ) {
     503                    $new[count($new) - 1] .= $part;
     504                } else {
     505                    $new[] = $part;
     506                }
     507            }
     508        }
     509        return $new;
     510    }
     511
     512    /**
    486513     * Match extends
    487514     *
     
    493520    protected function matchExtends($selector, &$out, $from = 0, $initial = true)
    494521    {
     522        $selector = $this->glueFunctionSelectors($selector);
     523
    495524        foreach ($selector as $i => $part) {
    496525            if ($i < $from) {
     
    519548                    for ($l = count($tempReplacement) - 1; $l >= 0; $l--) {
    520549                        $slice = [];
     550
    521551                        foreach ($tempReplacement[$l] as $chunk) {
    522552                            if (!in_array($chunk, $slice)) {
     
    524554                            }
    525555                        }
     556
    526557                        array_unshift($replacement, $slice);
    527558
     
    622653        foreach ($counts as $idx => $count) {
    623654            list($target, $origin, /* $block */) = $this->extends[$idx];
     655            $origin = $this->glueFunctionSelectors($origin);
    624656
    625657            // check count
     
    663695    }
    664696
    665 
    666697    /**
    667698     * Extract a relationship from the fragment.
     
    673704     *
    674705     * @param array $fragment The selector fragment maybe ending with a direction relationship combinator.
     706     *
    675707     * @return array The selector without the relationship fragment if any, the relationship fragment.
    676708     */
     
    857889
    858890        $selfParent = $block->selfParent;
    859         if (! $block->selfParent->selectors && isset($block->parent) && $block->parent && isset($block->parent->selectors) && $block->parent->selectors) {
     891
     892        if (! $block->selfParent->selectors && isset($block->parent) && $block->parent &&
     893            isset($block->parent->selectors) && $block->parent->selectors
     894        ) {
    860895            $selfParent = $block->parent;
    861896        }
     
    878913    /**
    879914     * Filter at-root scope depending of with/without option
    880      * @param $scope
    881      * @param $without
     915     *
     916     * @param \Leafo\ScssPhp\Formatter\OutputBlock $scope
     917     * @param mixed                                $without
     918     *
    882919     * @return mixed
    883920     */
     
    899936                break;
    900937            }
     938
    901939            if (! $this->isWithout($without, $scope)) {
    902940                $s = clone $scope;
     
    904942                $s->lines = [];
    905943                $s->parent = null;
     944
    906945                if ($s->type !== Type::T_MEDIA && $s->type !== Type::T_DIRECTIVE) {
    907946                    $s->selectors = [];
    908947                }
     948
    909949                $filteredScopes[] = $s;
    910950            }
     
    916956            }
    917957        }
     958
    918959        if (!count($filteredScopes)) {
    919960            return $this->rootBlock;
     
    922963        $newScope = array_shift($filteredScopes);
    923964        $newScope->parent = $this->rootBlock;
     965
    924966        $this->rootBlock->children[] = $newScope;
    925967
    926968        $p = &$newScope;
     969
    927970        while (count($filteredScopes)) {
    928971            $s = array_shift($filteredScopes);
     
    938981     * found missing selector from a at-root compilation in the previous scope
    939982     * (if at-root is just enclosing a property, the selector is in the parent tree)
    940      * @param $scope
    941      * @param $previousScope
     983     *
     984     * @param \Leafo\ScssPhp\Formatter\OutputBlock $scope
     985     * @param \Leafo\ScssPhp\Formatter\OutputBlock $previousScope
     986     *
    942987     * @return mixed
    943988     */
     
    947992            $scope->selectors = $this->findScopeSelectors($previousScope, $scope->depth);
    948993        }
     994
    949995        if ($scope->children) {
    950996            foreach ($scope->children as $k => $c) {
     
    9581004    /**
    9591005     * Find a selector by the depth node in the scope
    960      * @param $scope
    961      * @param $depth
     1006     *
     1007     * @param \Leafo\ScssPhp\Formatter\OutputBlock $scope
     1008     * @param integer                              $depth
     1009     *
    9621010     * @return array
    9631011     */
     
    9671015            return $scope->selectors;
    9681016        }
     1017
    9691018        if ($scope->children) {
    9701019            foreach (array_reverse($scope->children) as $c) {
     
    9741023            }
    9751024        }
     1025
    9761026        return [];
    9771027    }
     
    10531103     * Filter WITH rules
    10541104     *
    1055      * @param integer              $without
     1105     * @param integer                                                   $without
    10561106     * @param \Leafo\ScssPhp\Block|\Leafo\ScssPhp\Formatter\OutputBlock $block
    10571107     *
     
    10691119                    return ($without & static::WITH_SUPPORTS) ? true : false;
    10701120                }
     1121
    10711122                if (isset($block->selectors) && strpos(serialize($block->selectors), '@supports') !== false) {
    10721123                    return ($without & static::WITH_SUPPORTS) ? true : false;
     
    10741125            }
    10751126        }
     1127
    10761128        if ((($without & static::WITH_RULE) && isset($block->selectors))) {
    10771129            return true;
     
    11231175
    11241176        // wrap assign children in a block
    1125         foreach ($block->children as $k => $child) {
    1126             if ($child[0] === Type::T_ASSIGN) {
     1177        // except for @font-face
     1178        if ($block->type !== Type::T_DIRECTIVE || $block->name !== "font-face") {
     1179            // need wrapping?
     1180            $needWrapping = false;
     1181
     1182            foreach ($block->children as $child) {
     1183                if ($child[0] === Type::T_ASSIGN) {
     1184                    $needWrapping = true;
     1185                    break;
     1186                }
     1187            }
     1188
     1189            if ($needWrapping) {
    11271190                $wrapped = new Block;
    1128                 $wrapped->sourceName   = $block->sourceName;
    1129                 $wrapped->sourceIndex  = $block->sourceIndex;
    1130                 $wrapped->sourceLine   = $block->sourceLine;
     1191                $wrapped->sourceName = $block->sourceName;
     1192                $wrapped->sourceIndex = $block->sourceIndex;
     1193                $wrapped->sourceLine = $block->sourceLine;
    11311194                $wrapped->sourceColumn = $block->sourceColumn;
    1132                 $wrapped->selectors    = [];
    1133                 $wrapped->comments     = [];
    1134                 $wrapped->parent       = $block;
    1135                 $wrapped->children     = [$child];
    1136                 $wrapped->selfParent   = $block->selfParent;
    1137 
    1138                 $block->children[$k] = [Type::T_BLOCK, $wrapped];
     1195                $wrapped->selectors = [];
     1196                $wrapped->comments = [];
     1197                $wrapped->parent = $block;
     1198                $wrapped->children = $block->children;
     1199                $wrapped->selfParent = $block->selfParent;
     1200
     1201                $block->children = [[Type::T_BLOCK, $wrapped]];
    11391202            }
    11401203        }
     
    12001263        if (count($block->children)) {
    12011264            $out->selectors = $this->multiplySelectors($env, $block->selfParent);
     1265
    12021266            // propagate selfParent to the children where they still can be useful
    12031267            $selfParentSelectors = null;
     1268
    12041269            if (isset($block->selfParent->selectors)) {
    12051270                $selfParentSelectors = $block->selfParent->selectors;
    12061271                $block->selfParent->selectors = $out->selectors;
    12071272            }
     1273
    12081274            $this->compileChildrenNoReturn($block->children, $out, $block->selfParent);
     1275
    12091276            // and revert for the following childs of the same block
    12101277            if ($selfParentSelectors) {
     
    12271294        $out = $this->makeOutputBlock(Type::T_COMMENT);
    12281295        $out->lines[] = $block[1];
     1296
    12291297        $this->scope->children[] = $out;
    12301298    }
     
    14591527            }
    14601528        }
     1529
    14611530        return null;
    14621531    }
     
    14671536     * @param array                                $stms
    14681537     * @param \Leafo\ScssPhp\Formatter\OutputBlock $out
    1469      * @param \Leafo\ScssPhp\Block $selfParent
     1538     * @param \Leafo\ScssPhp\Block                 $selfParent
    14701539     *
    14711540     * @throws \Exception
     
    14731542    protected function compileChildrenNoReturn($stms, OutputBlock $out, $selfParent = null)
    14741543    {
    1475 
    14761544        foreach ($stms as $stm) {
    1477             if ($selfParent && isset($stm[1]) && is_object($stm[1]) && get_class($stm[1]) == 'Leafo\ScssPhp\Block') {
     1545            if ($selfParent && isset($stm[1]) && is_object($stm[1]) && $stm[1] instanceof Block) {
    14781546                $stm[1]->selfParent = $selfParent;
    14791547                $ret = $this->compileChild($stm, $out);
    14801548                $stm[1]->selfParent = null;
    1481             }
    1482             elseif ($selfParent && $stm[0] === TYPE::T_INCLUDE) {
     1549            } elseif ($selfParent && $stm[0] === TYPE::T_INCLUDE) {
    14831550                $stm['selfParent'] = $selfParent;
    14841551                $ret = $this->compileChild($stm, $out);
     
    14941561            }
    14951562        }
     1563    }
     1564
     1565
     1566    /**
     1567     * evaluate media query : compile internal value keeping the structure inchanged
     1568     *
     1569     * @param array $queryList
     1570     *
     1571     * @return array
     1572     */
     1573    protected function evaluateMediaQuery($queryList)
     1574    {
     1575        foreach ($queryList as $kql => $query) {
     1576            foreach ($query as $kq => $q) {
     1577                for ($i = 1; $i < count($q); $i++) {
     1578                    $value = $this->compileValue($q[$i]);
     1579
     1580                    // the parser had no mean to know if media type or expression if it was an interpolation
     1581                    if ($q[0] == Type::T_MEDIA_TYPE &&
     1582                        (strpos($value, '(') !== false ||
     1583                        strpos($value, ')') !== false ||
     1584                        strpos($value, ':') !== false)
     1585                    ) {
     1586                        $queryList[$kql][$kq][0] = Type::T_MEDIA_EXPRESSION;
     1587
     1588                        if (strpos($value, 'and') !== false) {
     1589                            $values = explode('and', $value);
     1590                            $value = trim(array_pop($values));
     1591
     1592                            while ($v = trim(array_pop($values))) {
     1593                                $type = Type::T_MEDIA_EXPRESSION;
     1594
     1595                                if (strpos($v, '(') === false &&
     1596                                    strpos($v, ')') === false &&
     1597                                    strpos($v, ':') === false
     1598                                ) {
     1599                                    $type = Type::T_MEDIA_TYPE;
     1600                                }
     1601
     1602                                if (substr($v, 0, 1) === '(' && substr($v, -1) === ')') {
     1603                                    $v = substr($v, 1, -1);
     1604                                }
     1605
     1606                                $queryList[$kql][] = [$type,[Type::T_KEYWORD, $v]];
     1607                            }
     1608                        }
     1609
     1610                        if (substr($value, 0, 1) === '(' && substr($value, -1) === ')') {
     1611                            $value = substr($value, 1, -1);
     1612                        }
     1613                    }
     1614
     1615                    $queryList[$kql][$kq][$i] = [Type::T_KEYWORD, $value];
     1616                }
     1617            }
     1618        }
     1619
     1620        return $queryList;
    14961621    }
    14971622
     
    15681693    }
    15691694
     1695    /**
     1696     * Merge direct relationships between selectors
     1697     *
     1698     * @param array $selectors1
     1699     * @param array $selectors2
     1700     *
     1701     * @return array
     1702     */
    15701703    protected function mergeDirectRelationships($selectors1, $selectors2)
    15711704    {
     
    16681801     * Compile import; returns true if the value was something that could be imported
    16691802     *
    1670      * @param array   $rawPath
    1671      * @param array  $out
    1672      * @param boolean $once
     1803     * @param array                                $rawPath
     1804     * @param \Leafo\ScssPhp\Formatter\OutputBlock $out
     1805     * @param boolean                              $once
    16731806     *
    16741807     * @return boolean
    16751808     */
    1676     protected function compileImport($rawPath, $out, $once = false)
     1809    protected function compileImport($rawPath, OutputBlock $out, $once = false)
    16771810    {
    16781811        if ($rawPath[0] === Type::T_STRING) {
     
    17341867            $this->sourceLine = $out->sourceLine;
    17351868            $this->sourceIndex = array_search($out->sourceName, $this->sourceNames);
     1869
    17361870            if ($this->sourceIndex === false) {
    17371871                $this->sourceIndex = null;
     
    18061940
    18071941                // handle shorthand syntax: size / line-height
    1808                 if ($compiledName === 'font') {
     1942                if ($compiledName === 'font' || $compiledName === 'grid-row' || $compiledName === 'grid-column') {
    18091943                    if ($value[0] === Type::T_VARIABLE) {
    1810                         // if the font value comes from variable, the content is already reduced (which means formulars where already calculated)
    1811                         // so we need the original unreduced value
     1944                        // if the font value comes from variable, the content is already reduced
     1945                        // (i.e., formulas were already calculated), so we need the original unreduced value
    18121946                        $value = $this->get($value[1], true, null, true);
    18131947                    }
    18141948
    18151949                    $fontValue=&$value;
     1950
    18161951                    if ($value[0] === Type::T_LIST && $value[1]==',') {
    18171952                        // this is the case if more than one font is given: example: "font: 400 1em/1.3 arial,helvetica"
     
    20452180                // and assign this fake parent to childs
    20462181                $selfParent = null;
     2182
    20472183                if (isset($child['selfParent']) && isset($child['selfParent']->selectors)) {
    20482184                    $selfParent = $child['selfParent'];
    2049                 }
    2050                 else {
     2185                } else {
    20512186                    $parentSelectors = $this->multiplySelectors($this->env);
     2187
    20522188                    if ($parentSelectors) {
    20532189                        $parent = new Block();
    20542190                        $parent->selectors = $parentSelectors;
     2191
    20552192                        foreach ($mixin->children as $k => $child) {
    2056                             if (isset($child[1]) && is_object($child[1]) && get_class($child[1]) == 'Leafo\ScssPhp\Block') {
     2193                            if (isset($child[1]) && is_object($child[1]) && $child[1] instanceof Block) {
    20572194                                $mixin->children[$k][1]->parent = $parent;
    20582195                            }
     
    20612198                }
    20622199
     2200                // clone the stored content to not have its scope spoiled by a further call to the same mixin
     2201                // i.e., recursive @include of the same mixin
    20632202                if (isset($content)) {
    2064                     $content->scope = $callingScope;
    2065 
    2066                     $this->setRaw(static::$namespaces['special'] . 'content', $content, $this->env);
     2203                    $copyContent = clone $content;
     2204                    $copyContent->scope = $callingScope;
     2205
     2206                    $this->setRaw(static::$namespaces['special'] . 'content', $copyContent, $this->env);
    20672207                }
    20682208
     
    20952235                $storeEnv = $this->storeEnv;
    20962236                $this->storeEnv = $content->scope;
    2097 
    20982237                $this->compileChildrenNoReturn($content->children, $out);
    20992238
     
    21702309     * @param array $value
    21712310     *
    2172      * @return array
     2311     * @return boolean
    21732312     */
    21742313    protected function isTruthy($value)
     
    23972536                $selfSelector = $this->multiplySelectors($this->env);
    23982537                $selfSelector = $this->collapseSelectors($selfSelector);
     2538
    23992539                return [Type::T_STRING, '', [$selfSelector]];
    24002540
     
    25852725            return $strRight;
    25862726        }
     2727
    25872728        return null;
    25882729    }
     
    30913232     *
    30923233     * @param \Leafo\ScssPhp\Compiler\Environment $env
    3093      * @param Leafo\ScssPhp\Block $selfParent
     3234     * @param \Leafo\ScssPhp\Block                $selfParent
    30943235     *
    30953236     * @return array
     
    31023243
    31033244        $selfParentSelectors = null;
     3245
    31043246        if (!is_null($selfParent) and $selfParent->selectors) {
    31053247            $selfParentSelectors = $this->evalSelectors($selfParent->selectors);
     
    31173259                    if ($selfParentSelectors) {
    31183260                        $previous = null;
     3261
    31193262                        foreach ($selfParentSelectors as $selfParent) {
    31203263                            // if no '&' in the selector, each call will give same result, only add once
    31213264                            $s = $this->joinSelectors($parent, $selector, $selfParent);
     3265
    31223266                            if ($s !== $previous) {
    31233267                                $selectors[serialize($s)] = $s;
    31243268                            }
     3269
    31253270                            $previous = $s;
    31263271                        }
     
    31363281
    31373282        $selectors = array_values($selectors);
     3283
    31383284        return $selectors;
    31393285    }
     
    31453291     * @param array $child
    31463292     * @param array $selfParentSelectors
     3293
    31473294     * @return array
    31483295     */
     
    31583305                if ($p === static::$selfSelector) {
    31593306                    $setSelf = true;
     3307
    31603308                    if (is_null($selfParentSelectors)) {
    31613309                        $selfParentSelectors = $parent;
    31623310                    }
     3311
    31633312                    foreach ($selfParentSelectors as $i => $parentPart) {
    31643313                        if ($i > 0) {
     
    32143363            : [[[Type::T_MEDIA_VALUE, $env->block->value]]];
    32153364
     3365        $store = [$this->env, $this->storeEnv];
     3366        $this->env = $env;
     3367        $this->storeEnv = null;
     3368        $parentQueries = $this->evaluateMediaQuery($parentQueries);
     3369        list($this->env, $this->storeEnv) = $store;
     3370
    32163371        if ($childQueries === null) {
    32173372            $childQueries = $parentQueries;
     
    33583513
    33593514        $env->store[$name] = $value;
     3515
    33603516        if ($valueUnreduced) {
    33613517            $env->storeUnreduced[$name] = $valueUnreduced;
     
    33743530    {
    33753531        $env->store[$name] = $value;
     3532
    33763533        if ($valueUnreduced) {
    33773534            $env->storeUnreduced[$name] = $valueUnreduced;
     
    34033560        $hasNamespace = $normalizedName[0] === '^' || $normalizedName[0] === '@' || $normalizedName[0] === '%';
    34043561
     3562        $maxDepth = 10000;
     3563
    34053564        for (;;) {
     3565            if ($maxDepth-- <= 0) {
     3566                break;
     3567            }
    34063568            if (array_key_exists($normalizedName, $env->store)) {
    34073569                if ($unreduced && isset($env->storeUnreduced[$normalizedName])) {
    34083570                    return $env->storeUnreduced[$normalizedName];
    34093571                }
     3572
    34103573                return $env->store[$normalizedName];
    34113574            }
     
    34293592
    34303593        if ($shouldThrow) {
    3431             $this->throwError("Undefined variable \$$name");
     3594            $this->throwError("Undefined variable \$$name" . ($maxDepth<=0 ? " (infinite recursion)" : ""));
    34323595        }
    34333596
     
    36643827     * Import file
    36653828     *
    3666      * @param string $path
    3667      * @param array $out
    3668      */
    3669     protected function importFile($path, $out)
     3829     * @param string                               $path
     3830     * @param \Leafo\ScssPhp\Formatter\OutputBlock $out
     3831     */
     3832    protected function importFile($path, OutputBlock $out)
    36703833    {
    36713834        // see if tree is cached
     
    37653928    {
    37663929        $this->ignoreErrors = $ignoreErrors;
     3930
    37673931        return $this;
    37683932    }
     
    37883952
    37893953        $line = $this->sourceLine;
    3790         $loc = isset($this->sourceNames[$this->sourceIndex]) ? $this->sourceNames[$this->sourceIndex] . " on line $line" : "line: $line";
     3954        $loc = isset($this->sourceNames[$this->sourceIndex])
     3955             ? $this->sourceNames[$this->sourceIndex] . " on line $line"
     3956             : "line: $line";
    37913957        $msg = "$msg: $loc";
     3958
    37923959        if ($this->callStack) {
    37933960            $msg .= "\nCall Stack:\n";
    37943961            $ncall = 0;
     3962
    37953963            foreach (array_reverse($this->callStack) as $call) {
    37963964                $msg .= "#" . $ncall++ . " " . $call['n'] . " ";
    3797                 $msg .= (isset($this->sourceNames[$call[Parser::SOURCE_INDEX]]) ? $this->sourceNames[$call[Parser::SOURCE_INDEX]] : '(unknown file)');
     3965                $msg .= (isset($this->sourceNames[$call[Parser::SOURCE_INDEX]])
     3966                      ? $this->sourceNames[$call[Parser::SOURCE_INDEX]]
     3967                      : '(unknown file)');
    37983968                $msg .= " on line " . $call[Parser::SOURCE_LINE] . "\n";
    37993969            }
  • _plugins_/scssphp/trunk/lib/scssphp/src/Parser.php

    r115183 r115301  
    6868    private $encoding;
    6969    private $patternModifiers;
     70    private $commentsSeen;
    7071
    7172    /**
     
    8687        $this->utf8             = ! $encoding || strtolower($encoding) === 'utf-8';
    8788        $this->patternModifiers = $this->utf8 ? 'Aisu' : 'Ais';
     89        $this->commentsSeen   = [];
    8890
    8991        if (empty(static::$operatorPattern)) {
     
    442444
    443445            $this->seek($s);
    444 
    445446
    446447            if ($this->literal('@return', 7) && ($this->valueList($retVal) || true) && $this->end()) {
     
    794795
    795796        $this->env = $block->parent;
     797
    796798        unset($block->parent);
    797799
    798800        $comments = $block->comments;
     801
    799802        if ($comments) {
    800803            $this->env->comments = $comments;
     
    830833     *
    831834     * @param integer $where
    832      *
    833      * @return integer
    834835     */
    835836    protected function seek($where)
     
    890891    protected function match($regex, &$out, $eatWhitespace = null)
    891892    {
    892 
    893893        $r = '/' . $regex . '/' . $this->patternModifiers;
    894894
     
    910910    }
    911911
    912 
    913912    /**
    914913     * Match a single string
     
    921920    protected function matchChar($char, $eatWhitespace = null)
    922921    {
    923 
    924922        if (! isset($this->buffer[$this->count]) || $this->buffer[$this->count] !== $char) {
    925923            return false;
     
    937935        return true;
    938936    }
    939 
    940937
    941938    /**
     
    966963        return true;
    967964    }
    968 
    969965
    970966    /**
     
    11931189     * Parse comma separated value list
    11941190     *
    1195      * @param string $out
     1191     * @param array $out
    11961192     *
    11971193     * @return boolean
     
    12291225        $items = [];
    12301226        $value = null;
     1227
    12311228        while ($this->$parseItem($value)) {
    12321229            $items[] = $value;
     
    12661263
    12671264        if ($this->matchChar('(')) {
    1268             if ($this->matchChar(')')) {
    1269                 $out = [Type::T_LIST, '', []];
    1270 
    1271                 return true;
    1272             }
    1273 
    1274             if ($this->valueList($out) && $this->matchChar(')') && $out[0] === Type::T_LIST) {
    1275                 return true;
    1276             }
    1277 
    1278             $this->seek($s);
    1279 
    1280             if ($this->map($out)) {
     1265            if ($this->parenExpression($out, $s, ")")) {
     1266                return true;
     1267            }
     1268
     1269            $this->seek($s);
     1270        }
     1271
     1272        if ($this->matchChar('[')) {
     1273            if ($this->parenExpression($out, $s, "]")) {
    12811274                return true;
    12821275            }
     
    12881281            $out = $this->expHelper($lhs, 0);
    12891282
     1283            return true;
     1284        }
     1285
     1286        return false;
     1287    }
     1288
     1289    /**
     1290     * Parse expression specifically checking for lists in parenthesis or brackets
     1291     *
     1292     * @param array   $out
     1293     * @param integer $s
     1294     * @param string  $closingParen
     1295     *
     1296     * @return boolean
     1297     */
     1298    protected function parenExpression(&$out, $s, $closingParen = ")")
     1299    {
     1300        if ($this->matchChar($closingParen)) {
     1301            $out = [Type::T_LIST, '', []];
     1302
     1303            return true;
     1304        }
     1305
     1306        if ($this->valueList($out) && $this->matchChar($closingParen) && $out[0] === Type::T_LIST) {
     1307            return true;
     1308        }
     1309
     1310        $this->seek($s);
     1311
     1312        if ($this->map($out)) {
    12901313            return true;
    12911314        }
     
    13541377    protected function value(&$out)
    13551378    {
    1356 
    13571379        if (! isset($this->buffer[$this->count])) {
    13581380            return false;
     
    13811403            if ($this->whitespace() && $this->value($inner)) {
    13821404                $out = [Type::T_UNARY, 'not', $inner, $this->inParens];
     1405
    13831406                return true;
    13841407            }
     
    13881411            if ($this->parenValue($inner)) {
    13891412                $out = [Type::T_UNARY, 'not', $inner, $this->inParens];
     1413
    13901414                return true;
    13911415            }
     
    13971421        if ($char === '+') {
    13981422            $this->count++;
     1423
    13991424            if ($this->value($inner)) {
    14001425                $out = [Type::T_UNARY, '+', $inner, $this->inParens];
    14011426                return true;
    14021427            }
     1428
    14031429            $this->count--;
     1430
    14041431            return false;
    14051432        }
    1406 
    14071433
    14081434        // negation
    14091435        if ($char === '-') {
    14101436            $this->count++;
     1437
    14111438            if ($this->variable($inner) || $this->unit($inner) || $this->parenValue($inner)) {
    14121439                $out = [Type::T_UNARY, '-', $inner, $this->inParens];
     
    14431470            return true;
    14441471        }
    1445 
    14461472
    14471473        if ($this->unit($out)) {
     
    15391565     *
    15401566     * @param string $name
    1541      * @param array $out
     1567     * @param array  $func
    15421568     *
    15431569     * @return boolean
     
    17901816     * Parse number with unit
    17911817     *
    1792      * @param array $out
     1818     * @param array $unit
    17931819     *
    17941820     * @return boolean
     
    22192245            }
    22202246
    2221 
    22222247            //self
    22232248            switch ($char) {
     
    22362261            }
    22372262
    2238 
    22392263            if ($char === '\\' && $this->match('\\\\\S', $m)) {
    22402264                $parts[] = $m[0];
     
    22422266            }
    22432267
    2244 
    22452268            if ($char === '%') {
    22462269                $this->count++;
     2270
    22472271                if ($this->placeholder($placeholder)) {
    22482272                    $parts[] = '%';
     
    22502274                    continue;
    22512275                }
     2276
    22522277                break;
    22532278            }
     
    22632288                continue;
    22642289            }
    2265 
    22662290
    22672291            // a pseudo selector
     
    22742298                    $part = ':';
    22752299                }
     2300
    22762301                if ($this->mixedKeyword($nameParts)) {
    22772302                    $parts[] = $part;
     
    23022327            }
    23032328
    2304 
    2305             $this->seek($s);
    2306 
     2329            $this->seek($s);
    23072330
    23082331            // attribute selector
     
    23252348            $this->seek($s);
    23262349
    2327 
    23282350            // for keyframes
    23292351            if ($this->unit($unit)) {
     
    23362358                continue;
    23372359            }
    2338 
    2339 
    2340 
    23412360
    23422361            break;
     
    26112630     * @param integer $pos
    26122631     *
    2613      * @return integer
     2632     * @return array
    26142633     */
    26152634    private function getSourcePosition($pos)
  • _plugins_/scssphp/trunk/lib/scssphp/src/SourceMap/SourceMapGenerator.php

    r115044 r115301  
    8686     */
    8787    protected $sources = [];
    88     protected $source_keys = [];
     88    protected $sourceKeys = [];
    8989
    9090    /**
     
    111111    {
    112112        $this->mappings[] = [
    113             'generated_line' => $generatedLine,
     113            'generated_line'   => $generatedLine,
    114114            'generated_column' => $generatedColumn,
    115             'original_line' => $originalLine,
    116             'original_column' => $originalColumn,
    117             'source_file' => $sourceFile
     115            'original_line'    => $originalLine,
     116            'original_column'  => $originalColumn,
     117            'source_file'      => $sourceFile
    118118        ];
    119119
     
    124124     * Saves the source map to a file
    125125     *
    126      * @param string $file    The absolute path to a file
    127126     * @param string $content The content to write
     127     *
     128     * @return string
    128129     *
    129130     * @throws \Leafo\ScssPhp\Exception\CompilerException If the file could not be saved
     
    181182        $sourceMap['sources'] = [];
    182183
    183         foreach ($this->sources as $source_uri => $source_filename) {
    184             $sourceMap['sources'][] = $this->normalizeFilename($source_filename);
     184        foreach ($this->sources as $sourceUri => $sourceFilename) {
     185            $sourceMap['sources'][] = $this->normalizeFilename($sourceFilename);
    185186        }
    186187
     
    237238        }
    238239
    239         $this->source_keys = array_flip(array_keys($this->sources));
     240        $this->sourceKeys = array_flip(array_keys($this->sources));
    240241
    241242        // group mappings by generated line number.
     
    249250        $lastGeneratedLine = $lastOriginalIndex = $lastOriginalLine = $lastOriginalColumn = 0;
    250251
    251         foreach ($groupedMap as $lineNumber => $line_map) {
     252        foreach ($groupedMap as $lineNumber => $lineMap) {
    252253            while (++$lastGeneratedLine < $lineNumber) {
    253254                $groupedMapEncoded[] = ';';
     
    257258            $lastGeneratedColumn = 0;
    258259
    259             foreach ($line_map as $m) {
     260            foreach ($lineMap as $m) {
    260261                $mapEncoded = $this->encoder->encode($m['generated_column'] - $lastGeneratedColumn);
    261262                $lastGeneratedColumn = $m['generated_column'];
     
    294295    protected function findFileIndex($filename)
    295296    {
    296         return $this->source_keys[$filename];
    297     }
    298 
     297        return $this->sourceKeys[$filename];
     298    }
     299
     300    /**
     301     * Normalize filename
     302     *
     303     * @param string $filename
     304     *
     305     * @return string
     306     */
    299307    protected function normalizeFilename($filename)
    300308    {
  • _plugins_/scssphp/trunk/lib/scssphp/src/Version.php

    r115183 r115301  
    1919class Version
    2020{
    21     const VERSION = 'v0.8.0.1';
     21    const VERSION = 'v0.8.2.1';
    2222}
  • _plugins_/scssphp/trunk/paquet.xml

    r115259 r115301  
    22        prefix="scssphp"
    33        categorie="outil"
    4         version="1.9.1"
     4        version="1.9.2"
    55        etat="test"
    66        compatibilite="[2.1.0;3.2.*]"
     
    2222        <pipeline nom="formulaire_admin"  inclure="scssphp_pipelines.php" />
    2323
    24         <procure nom="scssphp" version="0.8.0.1" />
     24        <procure nom="scssphp" version="0.8.2.1" />
    2525
    2626        <spip compatibilite="[3.1.0;[">
Note: See TracChangeset for help on using the changeset viewer.