Changeset 124750 in spip-zone for _plugins_


Ignore:
Timestamp:
May 18, 2020, 3:00:58 PM (7 weeks ago)
Author:
Cerdic
Message:

Mise a jour de ScssPHP en version 1.1.0

Location:
_plugins_/scssphp/tags/v2.4.1
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/scssphp/tags/v2.4.1

    • Property subgit:lock:a74e6da65d2ffe051e427ff8de51b5281af58177 deleted
    • Property subgit:lock:8b427b08405e36faff790a90d9f2fc3c1784e1db set to 2020-05-18T17:03:32.008
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/composer.json

    r118014 r124750  
    3232    },
    3333    "require-dev": {
    34         "squizlabs/php_codesniffer": "~2.5",
     34        "squizlabs/php_codesniffer": "~3.5",
    3535        "phpunit/phpunit": "^5.7 || ^6.5 || ^7.5 || ^8.3",
    3636        "twbs/bootstrap": "~4.3",
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Cache.php

    r124748 r124750  
    2323 *
    2424 * The cache manager is agnostic about data format and only the operation is expected to be described by string
    25  *
    2625 */
    2726
     
    2928 * SCSS cache
    3029 *
    31  * @author Cedric Morin
     30 * @author Cedric Morin <cedric@yterium.com>
    3231 */
    3332class Cache
     
    133132        $c = ['value' => $value];
    134133        $c = serialize($c);
     134
    135135        file_put_contents($fileCache, $c);
    136136
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Colors.php

    r124748 r124750  
    218218
    219219        if ($a < 1) {
    220             # specific case we dont' revert according to spec
    221             #if (! $a && ! $r && ! $g && ! $b) {
    222             #    return 'transparent';
    223             #}
    224 
    225220            return null;
    226221        }
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Compiler.php

    r124748 r124750  
    7474     * @var array
    7575     */
    76     static protected $operatorNames = [
     76    protected static $operatorNames = [
    7777        '+'   => 'add',
    7878        '-'   => 'sub',
     
    9494     * @var array
    9595     */
    96     static protected $namespaces = [
     96    protected static $namespaces = [
    9797        'special'  => '%',
    9898        'mixin'    => '@',
     
    100100    ];
    101101
    102     static public $true         = [Type::T_KEYWORD, 'true'];
    103     static public $false        = [Type::T_KEYWORD, 'false'];
    104     static public $NaN          = [Type::T_KEYWORD, 'NaN'];
    105     static public $Infinity     = [Type::T_KEYWORD, 'Infinity'];
    106     static public $null         = [Type::T_NULL];
    107     static public $nullString   = [Type::T_STRING, '', []];
    108     static public $defaultValue = [Type::T_KEYWORD, ''];
    109     static public $selfSelector = [Type::T_SELF];
    110     static public $emptyList    = [Type::T_LIST, '', []];
    111     static public $emptyMap     = [Type::T_MAP, [], []];
    112     static public $emptyString  = [Type::T_STRING, '"', []];
    113     static public $with         = [Type::T_KEYWORD, 'with'];
    114     static public $without      = [Type::T_KEYWORD, 'without'];
     102    public static $true         = [Type::T_KEYWORD, 'true'];
     103    public static $false        = [Type::T_KEYWORD, 'false'];
     104    public static $NaN          = [Type::T_KEYWORD, 'NaN'];
     105    public static $Infinity     = [Type::T_KEYWORD, 'Infinity'];
     106    public static $null         = [Type::T_NULL];
     107    public static $nullString   = [Type::T_STRING, '', []];
     108    public static $defaultValue = [Type::T_KEYWORD, ''];
     109    public static $selfSelector = [Type::T_SELF];
     110    public static $emptyList    = [Type::T_LIST, '', []];
     111    public static $emptyMap     = [Type::T_MAP, [], []];
     112    public static $emptyString  = [Type::T_STRING, '"', []];
     113    public static $with         = [Type::T_KEYWORD, 'with'];
     114    public static $without      = [Type::T_KEYWORD, 'without'];
    115115
    116116    protected $importPaths = [''];
     
    328328        // Otherwise, the CSS will be rendered as-is. It can even be extended!
    329329        $cssOnly = false;
     330
    330331        if (substr($path, '-4') === '.css') {
    331332            $cssOnly = true;
    332333        }
     334
    333335        $parser = new Parser($path, \count($this->sourceNames), $this->encoding, $this->cache, $cssOnly);
    334336
     
    564566
    565567        $outRecurs = [];
     568
    566569        foreach ($selector as $i => $part) {
    567570            if ($i < $from) {
     
    580583
    581584            $partsPile[] = $part;
     585
    582586            if ($this->matchExtendsSingle($part, $origin, $initial)) {
    583587                $after       = \array_slice($selector, $i + 1);
     
    594598                        }
    595599                    }
     600
    596601                    if (\count($nonBreakableBefore) and $k == \count($new)) {
    597602                        $k--;
     
    637642                    // recursively check for more matches
    638643                    $startRecurseFrom = \count($before) + min(\count($nonBreakableBefore), \count($mergedBefore));
     644
    639645                    if (\count($origin) > 1) {
    640646                        $this->matchExtends($result, $out, $startRecurseFrom, false);
     
    666672            array_pop($partsPile);
    667673        }
     674
    668675        while (\count($outRecurs)) {
    669676            $result = array_shift($outRecurs);
     
    674681    /**
    675682     * Test a part for being a pseudo selector
     683     *
    676684     * @param string $part
    677      * @param array $matches
    678      * @return bool
     685     * @param array  $matches
     686     *
     687     * @return boolean
    679688     */
    680689    protected function isPseudoSelector($part, &$matches)
    681690    {
    682691        if (strpos($part, ":") === 0
    683             && preg_match(",^::?([\w-]+)\((.+)\)$,", $part, $matches)) {
     692            && preg_match(",^::?([\w-]+)\((.+)\)$,", $part, $matches)
     693        ) {
    684694            return true;
    685695        }
     696
    686697        return false;
    687698    }
     
    693704     *  - in a white list
    694705     * in this case we merge the pseudo selector content
     706     *
    695707     * @param array $out
    696708     * @param array $extended
     
    701713            $single = reset($extended);
    702714            $part = reset($single);
    703             if ($this->isPseudoSelector($part, $matchesExtended)
    704               && \in_array($matchesExtended[1], [ 'slotted' ])) {
     715
     716            if ($this->isPseudoSelector($part, $matchesExtended) &&
     717                \in_array($matchesExtended[1], [ 'slotted' ])
     718            ) {
    705719                $prev = end($out);
    706720                $prev = $this->glueFunctionSelectors($prev);
     721
    707722                if (\count($prev) === 1 && \count(reset($prev)) === 1) {
    708723                    $single = reset($prev);
    709724                    $part = reset($single);
    710                     if ($this->isPseudoSelector($part, $matchesPrev)
    711                       && $matchesPrev[1] === $matchesExtended[1]) {
     725
     726                    if ($this->isPseudoSelector($part, $matchesPrev) &&
     727                        $matchesPrev[1] === $matchesExtended[1]
     728                    ) {
    712729                        $extended = explode($matchesExtended[1] . '(', $matchesExtended[0], 2);
    713730                        $extended[1] = $matchesPrev[2] . ", " . $extended[1];
     
    725742     * Match extends single
    726743     *
    727      * @param array $rawSingle
    728      * @param array $outOrigin
    729      * @param bool $initial
     744     * @param array   $rawSingle
     745     * @param array   $outOrigin
     746     * @param boolean $initial
    730747     *
    731748     * @return boolean
     
    770787                }
    771788            }
    772             if ($initial
    773                 && $this->isPseudoSelector($part, $matches)
    774                 && ! \in_array($matches[1], [ 'not' ])) {
     789
     790            if ($initial &&
     791                $this->isPseudoSelector($part, $matches) &&
     792                ! \in_array($matches[1], [ 'not' ])
     793            ) {
    775794                $buffer    = $matches[2];
    776795                $parser    = $this->parserFactory(__METHOD__);
     796
    777797                if ($parser->parseSelector($buffer, $subSelectors)) {
    778798                    foreach ($subSelectors as $ksub => $subSelector) {
    779799                        $subExtended = [];
    780800                        $this->matchExtends($subSelector, $subExtended, 0, false);
     801
    781802                        if ($subExtended) {
    782803                            $subSelectorsExtended = $subSelectors;
    783804                            $subSelectorsExtended[$ksub] = $subExtended;
     805
    784806                            foreach ($subSelectorsExtended as $ksse => $sse) {
    785807                                $subSelectorsExtended[$ksse] = $this->collapseSelectors($sse);
    786808                            }
     809
    787810                            $subSelectorsExtended = implode(', ', $subSelectorsExtended);
    788811                            $singleExtended = $single;
     
    916939            array_unshift($out, $tag[0]);
    917940        }
     941
    918942        while (\count($pseudo)) {
    919943            $out[] = array_shift($pseudo);
     
    10371061        if (\is_array($directive)) {
    10381062            $s = '@' . $directive[0];
     1063
    10391064            if (! empty($directive[1])) {
    10401065                $s .= ' ' . $this->compileValue($directive[1]);
    10411066            }
     1067
    10421068            $this->appendRootDirective($s . ';', $out);
    10431069        } else {
     
    12721298     * Filter env stack
    12731299     *
    1274      * @param array   $envs
     1300     * @param array $envs
    12751301     * @param array $with
    12761302     * @param array $without
     
    13961422     * Compile nested properties lines
    13971423     *
    1398      * @param \ScssPhp\ScssPhp\Block $block
    1399      * @param OutputBlock            $out
     1424     * @param \ScssPhp\ScssPhp\Block                 $block
     1425     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
    14001426     */
    14011427    protected function compileNestedPropertiesBlock(Block $block, OutputBlock $out)
     
    15691595            $ignoreCallStackMessage = $this->ignoreCallStackMessage;
    15701596            $this->ignoreCallStackMessage = true;
     1597
    15711598            try {
    15721599                $c = $this->compileValue($value[2]);
     
    15741601                // ignore error in comment compilation which are only interpolation
    15751602            }
     1603
    15761604            $this->ignoreCallStackMessage = $ignoreCallStackMessage;
    15771605
     
    18981926            if (isset($ret)) {
    18991927                $this->popCallStack();
     1928
    19001929                return $ret;
    19011930            }
     
    23672396            $lastChild = &$out->children[\count($out->children) - 1];
    23682397
    2369             if ($lastChild->depth === $out->depth && \is_null($lastChild->selectors) && ! \count($lastChild->children)) {
     2398            if ($lastChild->depth === $out->depth &&
     2399                \is_null($lastChild->selectors) &&
     2400                ! \count($lastChild->children)
     2401            ) {
    23702402                $outWrite = $lastChild;
    23712403            } else {
     
    25322564                            }
    25332565
    2534                             if (\intval($divider->dimension) and !\count($divider->units)) {
     2566                            if (\intval($divider->dimension) and ! \count($divider->units)) {
    25352567                                $revert = false;
    25362568                            }
     
    25552587                                            }
    25562588
    2557                                             if (\intval($divider->dimension) and !\count($divider->units)) {
     2589                                            if (\intval($divider->dimension) and ! \count($divider->units)) {
    25582590                                                $revert = false;
    25592591                                            }
     
    30803112                        $baseUnitLeft = $left->isNormalizable();
    30813113                        $baseUnitRight = $right->isNormalizable();
     3114
    30823115                        if ($baseUnitLeft && $baseUnitRight && $baseUnitLeft === $baseUnitRight) {
    30833116                            $left = $left->normalize();
     
    37593792                list(, $delim, $items) = $value;
    37603793                $pre = $post = "";
     3794
    37613795                if (! empty($value['enclosing'])) {
    37623796                    switch ($value['enclosing']) {
     
    40164050     * @param array   $parent
    40174051     * @param array   $child
    4018      * @param boolean &$stillHasSelf
     4052     * @param boolean $stillHasSelf
    40194053     * @param array   $selfParentSelectors
    40204054
     
    41914225
    41924226    /**
    4193      * propagate vars from a just poped Env (used in @each and @for)
    4194      * @param array $store
     4227     * Propagate vars from a just poped Env (used in @each and @for)
     4228     *
     4229     * @param array      $store
    41954230     * @param null|array $excludedVars
    41964231     */
     
    41984233    {
    41994234        foreach ($store as $key => $value) {
    4200             if (empty($excludedVars) || !\in_array($key, $excludedVars)) {
     4235            if (empty($excludedVars) || ! \in_array($key, $excludedVars)) {
    42014236                $this->set($key, $value, true);
    42024237            }
     
    46574692        if (! preg_match('~\.css$|^https?://|^//~', $url)) {
    46584693            $isPartial = (strpos(basename($url), '_') === 0);
     4694
    46594695            // try both normal and the _partial filename
    46604696            $urls = [$url . ($hasExtension ? '' : '.scss')];
     4697
    46614698            if (! $isPartial) {
    46624699                $urls[] = preg_replace('~[^/]+$~', '_\0', $url) . ($hasExtension ? '' : '.scss');
    46634700            }
    4664             if (!$hasExtension) {
     4701
     4702            if (! $hasExtension) {
    46654703                $urls[] = "$url/index.scss";
    46664704                $urls[] = "$url/_index.scss";
     
    46964734
    46974735        if ($urls) {
    4698             if (!$hasExtension or preg_match('/[.]scss$/', $url)) {
     4736            if (! $hasExtension or preg_match('/[.]scss$/', $url)) {
    46994737                $this->throwError("`$url` file not found for @import");
    47004738            }
     
    47514789        }
    47524790
    4753         if (!$this->ignoreCallStackMessage) {
     4791        if (! $this->ignoreCallStackMessage) {
    47544792            $line   = $this->sourceLine;
    47554793            $column = $this->sourceColumn;
     
    48584896
    48594897        $this->env->marker = 'function';
     4898
    48604899        if (! empty($func->parentEnv)) {
    48614900            $this->env->declarationScopeParent = $func->parentEnv;
     
    51045143    {
    51055144        $output = [];
     5145
    51065146        if (\is_array($argValues) && \count($argValues) && end($argValues) === static::$null) {
    51075147            array_pop($argValues);
     
    51455185                    }
    51465186                }
     5187
    51475188                if (! isset($args[$name]) || $args[$name][3]) {
    51485189                    if ($hasVariable) {
     
    53295370        }
    53305371
    5331         if ($item[0] === static::$emptyList[0]
    5332             && $item[1] === static::$emptyList[1]
    5333             && $item[2] === static::$emptyList[2]) {
     5372        if ($item[0] === static::$emptyList[0] &&
     5373            $item[1] === static::$emptyList[1] &&
     5374            $item[2] === static::$emptyList[2]
     5375        ) {
    53345376            return static::$emptyMap;
    53355377        }
     
    53415383     * Coerce something to list
    53425384     *
    5343      * @param array  $item
    5344      * @param string $delim
    5345      * @param bool $removeTrailingNull
     5385     * @param array   $item
     5386     * @param string  $delim
     5387     * @param boolean $removeTrailingNull
    53465388     *
    53475389     * @return array
     
    53545396                array_pop($item[2]);
    53555397            }
     5398
    53565399            return $item;
    53575400        }
     
    54625505
    54635506                $name = strtolower($value[1]);
     5507
    54645508                // hexa color?
    54655509                if (preg_match('/^#([0-9a-f]+)$/i', $name, $m)) {
     
    58885932        list($list, $value) = $args;
    58895933
    5890         if ($value[0] === Type::T_MAP) {
    5891             return static::$null;
    5892         }
    5893 
    58945934        if ($list[0] === Type::T_MAP ||
    58955935            $list[0] === Type::T_STRING ||
     
    64676507        foreach ($numbers as $key => $pair) {
    64686508            list($original, $normalized) = $pair;
     6509
    64696510            if (\is_null($normalized) or \is_null($minNormalized)) {
    64706511                if (\is_null($minOriginal) || $original[1] <= $minOriginal[1]) {
     
    64896530        foreach ($numbers as $key => $pair) {
    64906531            list($original, $normalized) = $pair;
     6532
    64916533            if (\is_null($normalized) or \is_null($maxNormalized)) {
    64926534                if (\is_null($maxOriginal) || $original[1] >= $maxOriginal[1]) {
     
    65276569                $unit = $number[2];
    65286570                $originalUnit = $item->unitStr();
    6529             } elseif ($number[1] && $unit !== $number[2] && !empty($number[2])) {
     6571            } elseif ($number[1] && $unit !== $number[2] && ! empty($number[2])) {
    65306572                $this->throwError('Incompatible units: "%s" and "%s".', $originalUnit, $item->unitStr());
    65316573                break;
     
    67166758        $list = $args[0];
    67176759        $this->coerceList($list, ' ');
     6760
    67186761        if (! empty($list['enclosing']) && $list['enclosing'] === 'bracket') {
    67196762            return true;
    67206763        }
     6764
    67216765        return false;
    67226766    }
    6723 
    67246767
    67256768    protected function listSeparatorForJoin($list1, $sep)
     
    67616804            $bracketed = $this->compileValue($bracketed);
    67626805            $bracketed = ! ! $bracketed;
     6806
    67636807            if ($bracketed === true) {
    67646808                $bracketed = true;
     
    67686812        if ($bracketed === 'auto') {
    67696813            $bracketed = false;
     6814
    67706815            if (! empty($list1['enclosing']) && $list1['enclosing'] === 'bracket') {
    67716816                $bracketed = true;
     
    67746819
    67756820        $res = [Type::T_LIST, $sep, array_merge($list1[2], $list2[2])];
     6821
    67766822        if (isset($list1['enclosing'])) {
    67776823            $res['enlcosing'] = $list1['enclosing'];
    67786824        }
     6825
    67796826        if ($bracketed) {
    67806827            $res['enclosing'] = 'bracket';
    67816828        }
     6829
    67826830        return $res;
    67836831    }
     
    67896837
    67906838        $list1 = $this->coerceList($list1, ' ', true);
    6791         $sep = $this->listSeparatorForJoin($list1, $sep);
    6792 
    6793         $res = [Type::T_LIST, $sep, array_merge($list1[2], [$value])];
     6839        $sep   = $this->listSeparatorForJoin($list1, $sep);
     6840        $res   = [Type::T_LIST, $sep, array_merge($list1[2], [$value])];
     6841
    67946842        if (isset($list1['enclosing'])) {
    67956843            $res['enclosing'] = $list1['enclosing'];
    67966844        }
     6845
    67976846        return $res;
    67986847    }
     
    70667115                return null;
    70677116            }
     7117
    70687118            if ($n - \intval($n) > 0) {
    70697119                $this->throwError("Expected \$limit to be an integer but got $n for `random`");
     
    70967146            $value = [Type::T_KEYWORD, 'null'];
    70977147        }
     7148
    70987149        $stringValue = [$value];
     7150
    70997151        if ($value[0] === Type::T_LIST) {
    71007152            if (end($value[2]) === static::$null) {
     
    71037155                $force_enclosing_display = true;
    71047156            }
    7105             if (! empty($value['enclosing'])) {
    7106                 if ($force_enclosing_display
    7107                     || ($value['enclosing'] === 'bracket' )
    7108                     || !\count($value[2])) {
    7109                     $value['enclosing'] = 'forced_'.$value['enclosing'];
    7110                     $force_enclosing_display = true;
    7111                 }
    7112             }
     7157
     7158            if (! empty($value['enclosing']) &&
     7159                ($force_enclosing_display ||
     7160                    ($value['enclosing'] === 'bracket') ||
     7161                    ! \count($value[2]))
     7162            ) {
     7163                $value['enclosing'] = 'forced_'.$value['enclosing'];
     7164                $force_enclosing_display = true;
     7165            }
     7166
    71137167            foreach ($value[2] as $k => $listelement) {
    71147168                $value[2][$k] = $this->inspectFormatValue($listelement, $force_enclosing_display);
    71157169            }
     7170
    71167171            $stringValue = [$value];
    71177172        }
     
    71247179    {
    71257180        $value = $args[0];
     7181
    71267182        return $this->inspectFormatValue($value);
    71277183    }
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Formatter.php

    r124748 r124750  
    143143    {
    144144        $inner = $this->indentStr();
    145 
    146         $glue = $this->break . $inner;
     145        $glue  = $this->break . $inner;
    147146
    148147        $this->write($inner . implode($glue, $block->lines));
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Formatter/Nested.php

    r124748 r124750  
    5959    {
    6060        $inner = $this->indentStr();
    61 
    62         $glue = $this->break . $inner;
     61        $glue  = $this->break . $inner;
    6362
    6463        foreach ($block->lines as $index => $line) {
     
    120119                if (! $previousEmpty || $this->depth < 1) {
    121120                    $this->depth++;
     121
    122122                    $depths[] = $block->depth;
    123123                } else {
    124124                    // keep the current depth unchanged but take the block depth as a new reference for following blocks
    125125                    array_pop($depths);
     126
    126127                    $depths[] = $block->depth;
    127128                }
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Node/Number.php

    r124748 r124750  
    3232     * @var integer
    3333     */
    34     static public $precision = 10;
     34    public static $precision = 10;
    3535
    3636    /**
     
    3939     * @var array
    4040     */
    41     static protected $unitTable = [
     41    protected static $unitTable = [
    4242        'in' => [
    4343            'in' => 1,
     
    240240
    241241    /**
    242      * Test if a number can be normalized in a baseunit
    243      * ie if it's units are homogeneous
    244      * @return bool
     242     * Test if a number can be normalized in a base unit
     243     * ie if its units are homogeneous
     244     *
     245     * @return boolean
    245246     */
    246247    public function isNormalizable()
     
    251252
    252253        $baseUnit = null;
     254
    253255        foreach ($this->units as $unit => $exp) {
    254256            $b = $this->findBaseUnit($unit);
     257
    255258            if (\is_null($baseUnit)) {
    256259                $baseUnit = $b;
    257260            }
     261
    258262            if (\is_null($b) or $b !== $baseUnit) {
    259263                return false;
    260264            }
    261265        }
     266
    262267        return $baseUnit;
    263268    }
     
    351356
    352357        foreach ($this->units as $unit => $exp) {
    353             if (!$baseUnit) {
     358            if (! $baseUnit) {
    354359                $baseUnit = $this->findBaseUnit($unit);
    355360            }
     361
    356362            if ($baseUnit && isset(static::$unitTable[$baseUnit][$unit])) {
    357363                $factor = pow(static::$unitTable[$baseUnit][$unit], $exp);
     
    367373    /**
    368374     * Find the base unit family for a given unit
    369      * @param $unit
     375     *
     376     * @param string $unit
     377     *
    370378     * @return string|null
    371379     */
     
    377385            }
    378386        }
     387
    379388        return null;
    380389    }
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Parser.php

    r124748 r124750  
    360360                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    361361                }
     362
    362363                $atRoot = $this->pushSpecialBlock(Type::T_AT_ROOT, $s);
    363364                $atRoot->selector = $selector;
     
    386387                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    387388                }
     389
    388390                $mixin = $this->pushSpecialBlock(Type::T_MIXIN, $s);
    389391                $mixin->name = $mixinName;
     
    409411                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    410412                }
     413
    411414                $child = [
    412415                    Type::T_INCLUDE,
     
    436439                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    437440                }
     441
    438442                $this->append([Type::T_SCSSPHP_IMPORT_ONCE, $importPath], $s);
    439443
     
    461465                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    462466                }
     467
    463468                $this->append([Type::T_IMPORT, $importPath], $s);
    464469
     
    475480                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    476481                }
     482
    477483                // check for '!flag'
    478484                $optional = $this->stripOptionalFlag($selectors);
     
    492498                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    493499                }
     500
    494501                $func = $this->pushSpecialBlock(Type::T_FUNCTION, $s);
    495502                $func->name = $fnName;
     
    505512                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    506513                }
     514
    507515                $this->append([Type::T_BREAK], $s);
    508516
     
    516524                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    517525                }
     526
    518527                $this->append([Type::T_CONTINUE], $s);
    519528
     
    527536                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    528537                }
     538
    529539                $this->append([Type::T_RETURN, isset($retVal) ? $retVal : [Type::T_NULL]], $s);
    530540
     
    543553                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    544554                }
     555
    545556                $each = $this->pushSpecialBlock(Type::T_EACH, $s);
    546557
     
    563574                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    564575                }
     576
    565577                $while = $this->pushSpecialBlock(Type::T_WHILE, $s);
    566578                $while->cond = $cond;
     
    583595                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    584596                }
     597
    585598                $for = $this->pushSpecialBlock(Type::T_FOR, $s);
    586599                $for->var   = $varName[1];
     
    598611                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    599612                }
     613
    600614                $if = $this->pushSpecialBlock(Type::T_IF, $s);
     615
    601616                while ($cond[0] === Type::T_LIST
    602                     && !empty($cond['enclosing'])
     617                    && ! empty($cond['enclosing'])
    603618                    && $cond['enclosing'] === 'parent'
    604619                    && \count($cond[2]) == 1) {
    605620                    $cond = reset($cond[2]);
    606621                }
     622
    607623                $if->cond  = $cond;
    608624                $if->cases = [];
     
    620636                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    621637                }
     638
    622639                $this->append([Type::T_DEBUG, $value], $s);
    623640
     
    634651                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    635652                }
     653
    636654                $this->append([Type::T_WARN, $value], $s);
    637655
     
    648666                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    649667                }
     668
    650669                $this->append([Type::T_ERROR, $value], $s);
    651670
     
    654673
    655674            $this->seek($s);
    656 
    657             #if ($this->literal('@content', 8))
    658675
    659676            if ($this->literal('@content', 8) &&
    660677                ($this->end() ||
    661678                    $this->matchChar('(') &&
    662                         $this->argValues($argContent) &&
    663                         $this->matchChar(')') &&
    664                     $this->end())) {
     679                    $this->argValues($argContent) &&
     680                    $this->matchChar(')') &&
     681                    $this->end())
     682            ) {
    665683                if ($this->cssOnly) {
    666684                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    667685                }
     686
    668687                $this->append([Type::T_MIXIN_CONTENT, isset($argContent) ? $argContent : null], $s);
    669688
     
    771790        // custom properties : right part is static
    772791        if (($this->customProperty($name) || ($this->cssOnly && $this->propertyName($name))) &&
    773             $this->matchChar(':', false)) {
     792            $this->matchChar(':', false)
     793        ) {
    774794            $start = $this->count;
     795
    775796            // but can be complex and finish with ; or }
    776797            foreach ([';','}'] as $ending) {
    777                 if ($this->openString($ending, $stringValue, '(', ')', false)
    778                     && $this->end()) {
     798                if ($this->openString($ending, $stringValue, '(', ')', false) &&
     799                    $this->end()
     800                ) {
    779801                    $end = $this->count;
    780802                    $value = $stringValue;
     803
    781804                    // check if we have only a partial value due to nested [] or { } to take in account
    782805                    $nestingPairs = [['[', ']'], ['{', '}']];
     806
    783807                    foreach ($nestingPairs as $nestingPair) {
    784808                        $p = strpos($this->buffer, $nestingPair[0], $start);
     809
    785810                        if ($p && $p < $end) {
    786811                            $this->seek($start);
    787                             if ($this->openString($ending, $stringValue, $nestingPair[0], $nestingPair[1], false)
    788                                 && $this->end()) {
    789                                 if ($this->count > $end) {
    790                                     $end = $this->count;
    791                                     $value = $stringValue;
    792                                 }
     812
     813                            if ($this->openString($ending, $stringValue, $nestingPair[0], $nestingPair[1], false) &&
     814                                $this->end() &&
     815                                $this->count > $end
     816                            ) {
     817                                $end = $this->count;
     818                                $value = $stringValue;
    793819                            }
    794820                        }
    795821                    }
     822
    796823                    $this->seek($end);
    797824                    $this->append([Type::T_CUSTOM_PROPERTY, $name, $value], $s);
     825
    798826                    return true;
    799827                }
    800828            }
     829
    801830            // TODO: output an error here if nothing found according to sass spec
    802831        }
     
    828857                $this->throwParseError("SCSS syntax not allowed in CSS file");
    829858            }
     859
    830860            // check for '!flag'
    831861            $assignmentFlags = $this->stripAssignmentFlags($value);
     
    845875        if ($this->selectors($selectors) && $this->matchChar('{', false)) {
    846876            if ($this->cssOnly) {
    847                 if (!empty($this->env->parent)) {
     877                if (! empty($this->env->parent)) {
    848878                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    849879                }
    850880            }
     881
    851882            $this->pushBlock($selectors, $s);
    852883
     
    878909                    $this->throwParseError("SCSS syntax not allowed in CSS file");
    879910                }
     911
    880912                $propBlock = $this->pushSpecialBlock(Type::T_NESTED_PROPERTY, $s);
    881913                $propBlock->prefix = $name;
     
    12711303                    $comment[1] = substr(preg_replace(['/^\s+/m', '/^(.)/m'], ['', ' \1'], $comment[1]), 1);
    12721304                }
     1305
    12731306                if (isset($comment[2]) and \is_array($comment[2]) and $comment[2][0] === Type::T_STRING) {
    12741307                    foreach ($comment[2][2] as $k => $v) {
    12751308                        if (\is_string($v)) {
    12761309                            $p = strpos($v, "\n");
     1310
    12771311                            if ($p !== false) {
    12781312                                $comment[2][2][$k] = substr($v, 0, $p + 1)
     
    14161450            $this->valueList($value) &&
    14171451            $this->matchChar(')')
    1418          ) {
     1452        ) {
    14191453            $support = [Type::T_STRING, '', [[Type::T_KEYWORD, ($not ? 'not ' : '') . '(']]];
    14201454            $support[2][] = $property;
     
    14691503                $selectorList[2][] = $compound;
    14701504            }
     1505
    14711506            $support[2][] = $selectorList;
    14721507            $support[2][] = [Type::T_KEYWORD, ')'];
     
    16041639    /**
    16051640     * Parse directive value list that considers $vars as keyword
    1606      * @param array $out
    1607      * @param bool|string $endChar
    1608      * @return bool
     1641     *
     1642     * @param array          $out
     1643     * @param boolean|string $endChar
     1644     *
     1645     * @return boolean
    16091646     */
    16101647    protected function directiveValue(&$out, $endChar = false)
    16111648    {
    16121649        $s = $this->count;
     1650
    16131651        if ($this->variable($out)) {
    16141652            if ($endChar && $this->matchChar($endChar, false)) {
    16151653                return true;
    16161654            }
    1617             if (!$endChar && $this->end()) {
     1655
     1656            if (! $endChar && $this->end()) {
    16181657                return true;
    16191658            }
     
    16321671        $allowVars = $this->allowVars;
    16331672        $this->allowVars = false;
    1634         //$res = $this->valueList($out);
     1673
    16351674        $res = $this->genericList($out, 'spaceList', ',');
    16361675        $this->allowVars = $allowVars;
     
    16401679                return true;
    16411680            }
    1642             if (!$endChar && $this->end()) {
     1681
     1682            if (! $endChar && $this->end()) {
    16431683                return true;
    16441684            }
     
    17071747                    break;
    17081748                }
     1749
    17091750                $trailing_delim = true;
    17101751            }
     
    17201761            $items[] = [Type::T_NULL];
    17211762        }
     1763
    17221764        if ($flatten && \count($items) === 1) {
    17231765            $out = $items[0];
     
    17321774     * Parse expression
    17331775     *
    1734      * @param array $out
    1735      * @param bool $listOnly
    1736      * @param bool $lookForExp
     1776     * @param array   $out
     1777     * @param boolean $listOnly
     1778     * @param boolean $lookForExp
    17371779     *
    17381780     * @return boolean
     
    17681810                    $out = $lhs;
    17691811                }
     1812
    17701813                $this->discardComments = $discard;
    17711814
     
    17761819        }
    17771820
    1778         if (!$listOnly && $this->value($lhs)) {
     1821        if (! $listOnly && $this->value($lhs)) {
    17791822            if ($lookForExp) {
    17801823                $out = $this->expHelper($lhs, 0);
     
    17891832
    17901833        $this->discardComments = $discard;
     1834
    17911835        return false;
    17921836    }
     
    18061850        if ($this->matchChar($closingParen) && \in_array(Type::T_LIST, $allowedTypes)) {
    18071851            $out = [Type::T_LIST, '', []];
     1852
    18081853            switch ($closingParen) {
    18091854                case ")":
    18101855                    $out['enclosing'] = 'parent'; // parenthesis list
    18111856                    break;
     1857
    18121858                case "]":
    18131859                    $out['enclosing'] = 'bracket'; // bracketed list
    18141860                    break;
    18151861            }
     1862
    18161863            return true;
    18171864        }
    18181865
    1819         if ($this->valueList($out) && $this->matchChar($closingParen)
    1820             && \in_array($out[0], [Type::T_LIST, Type::T_KEYWORD])
    1821             && \in_array(Type::T_LIST, $allowedTypes)) {
     1866        if ($this->valueList($out) && $this->matchChar($closingParen) &&
     1867            \in_array($out[0], [Type::T_LIST, Type::T_KEYWORD]) &&
     1868            \in_array(Type::T_LIST, $allowedTypes)
     1869        ) {
    18221870            if ($out[0] !== Type::T_LIST || ! empty($out['enclosing'])) {
    18231871                $out = [Type::T_LIST, '', [$out]];
    18241872            }
     1873
    18251874            switch ($closingParen) {
    18261875                case ")":
    18271876                    $out['enclosing'] = 'parent'; // parenthesis list
    18281877                    break;
     1878
    18291879                case "]":
    18301880                    $out['enclosing'] = 'bracket'; // bracketed list
    18311881                    break;
    18321882            }
     1883
    18331884            return true;
    18341885        }
     
    20072058            if ($follow_white) {
    20082059                $out = [Type::T_KEYWORD, $char];
     2060
    20092061                return  true;
    20102062            }
     
    20222074                return true;
    20232075            }
     2076
    20242077            $this->count++;
     2078
    20252079            if ($this->keyword($keyword)) {
    20262080                $out = [Type::T_KEYWORD, "#" . $keyword];
    2027                 return true;
    2028             }
     2081
     2082                return true;
     2083            }
     2084
    20292085            $this->count--;
    20302086        }
     
    22732329
    22742330                $arg[2] = true;
     2331
    22752332                $this->seek($sss);
    22762333            } else {
     
    23502407            if (\in_array(\strlen($m[2]), [3,4,6,8])) {
    23512408                $out = [Type::T_KEYWORD, $m[0]];
    2352                 return true;
    2353             }
    2354 
    2355             $this->seek($s);
     2409
     2410                return true;
     2411            }
     2412
     2413            $this->seek($s);
     2414
    23562415            return false;
    23572416        }
     
    24332492                    $content[] = $m[2] . "\\";
    24342493                } elseif ($this->literal("\r\n", 2, false) ||
    2435                   $this->matchChar("\r", false) ||
    2436                   $this->matchChar("\n", false) ||
    2437                   $this->matchChar("\f", false)
     2494                    $this->matchChar("\r", false) ||
     2495                    $this->matchChar("\n", false) ||
     2496                    $this->matchChar("\f", false)
    24382497                ) {
    24392498                    // this is a continuation escaping, to be ignored
     
    25212580     * Parse an unbounded string stopped by $end
    25222581     *
    2523      * @param string $end
    2524      * @param array  $out
    2525      * @param string $nestingOpen
    2526      * @param string $nestingClose
    2527      * @param bool $trimEnd
     2582     * @param string  $end
     2583     * @param array   $out
     2584     * @param string  $nestingOpen
     2585     * @param string  $nestingClose
     2586     * @param boolean $trimEnd
    25282587     *
    25292588     * @return boolean
     
    25342593        $this->eatWhiteDefault = false;
    25352594
    2536         if ($nestingOpen && !$nestingClose) {
     2595        if ($nestingOpen && ! $nestingClose) {
    25372596            $nestingClose = $end;
    25382597        }
     
    26882747
    26892748        // match comment hack
    2690         if (preg_match(
    2691             static::$whitePattern,
    2692             $this->buffer,
    2693             $m,
    2694             null,
    2695             $this->count
    2696         )) {
     2749        if (preg_match(static::$whitePattern, $this->buffer, $m, null, $this->count)) {
    26972750            if (! empty($m[0])) {
    26982751                $parts[] = $m[0];
     
    29603013                    ) {
    29613014                        if ($this->matchChar('(', true) &&
    2962                           ($this->selectors($subs, reset($nameParts)) || true) &&
    2963                           $this->matchChar(')')
     3015                            ($this->selectors($subs, reset($nameParts)) || true) &&
     3016                            $this->matchChar(')')
    29643017                        ) {
    29653018                            $parts[] = '(';
     
    29873040                    } else {
    29883041                        if ($this->matchChar('(') &&
    2989                           ($this->openString(')', $str, '(') || true) &&
    2990                           $this->matchChar(')')
     3042                            ($this->openString(')', $str, '(') || true) &&
     3043                            $this->matchChar(')')
    29913044                        ) {
    29923045                            $parts[] = '(';
     
    32643317
    32653318    /**
    3266      * @deprecated
    3267      *
    3268      * {@internal
    3269      *     advance counter to next occurrence of $what
    3270      *     $until - don't include $what in advance
    3271      *     $allowNewline, if string, will be used as valid char set
    3272      * }}
    3273      */
    3274     protected function to($what, &$out, $until = false, $allowNewline = false)
    3275     {
    3276         if (\is_string($allowNewline)) {
    3277             $validChars = $allowNewline;
    3278         } else {
    3279             $validChars = $allowNewline ? '.' : "[^\n]";
    3280         }
    3281 
    3282         $m = null;
    3283 
    3284         if (! $this->match('(' . $validChars . '*?)' . $this->pregQuote($what), $m, ! $until)) {
    3285             return false;
    3286         }
    3287 
    3288         if ($until) {
    3289             $this->count -= \strlen($what); // give back $what
    3290         }
    3291 
    3292         $out = $m[1];
    3293 
    3294         return true;
    3295     }
    3296 
    3297     /**
    3298      * @deprecated
    3299      */
    3300     protected function show()
    3301     {
    3302         if ($this->peek("(.*?)(\n|$)", $m, $this->count)) {
    3303             return $m[1];
    3304         }
    3305 
    3306         return '';
    3307     }
    3308 
    3309     /**
    33103319     * Quote regular expression
    33113320     *
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/SourceMap/SourceMapGenerator.php

    r124748 r124750  
    250250
    251251        ksort($groupedMap);
     252
    252253        $lastGeneratedLine = $lastOriginalIndex = $lastOriginalLine = $lastOriginalColumn = 0;
    253254
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Version.php

    r124748 r124750  
    1919class Version
    2020{
    21     const VERSION = 'v1.0.9';
     21    const VERSION = '1.1.0';
    2222}
  • _plugins_/scssphp/tags/v2.4.1/paquet.xml

    r124749 r124750  
    22        prefix="scssphp"
    33        categorie="outil"
    4         version="2.4.0"
     4        version="2.4.1"
    55        etat="stable"
    66        compatibilite="[3.1.0;3.3.*]"
     
    2222        <pipeline nom="formulaire_admin" />
    2323
    24         <procure nom="scssphp" version="1.0.9" />
     24        <procure nom="scssphp" version="1.1.0" />
    2525
    2626        <necessite nom="php" compatibilite="[5.6.0;[" />
Note: See TracChangeset for help on using the changeset viewer.