From 871771c7bcc2b8fa38d9312d868277d829ff4809 Mon Sep 17 00:00:00 2001 From: mhbapcc <33956217+mhbapcc@users.noreply.github.com> Date: Fri, 26 Jun 2020 11:26:51 +0200 Subject: [PATCH 1/3] Create .gitkeep --- cache/.gitkeep | 1 + 1 file changed, 1 insertion(+) create mode 100644 cache/.gitkeep diff --git a/cache/.gitkeep b/cache/.gitkeep new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/cache/.gitkeep @@ -0,0 +1 @@ + From 30948d2c74ff6471f8b2c0dbaa280379448aaa4c Mon Sep 17 00:00:00 2001 From: mhbapcc <33956217+mhbapcc@users.noreply.github.com> Date: Fri, 3 Jul 2020 13:25:55 +0200 Subject: [PATCH 2/3] Updated scssphp --- scssphp/bin/pscss | 46 +- scssphp/scss.inc.php | 10 +- scssphp/src/Base/Range.php | 6 +- scssphp/src/Block.php | 13 +- scssphp/src/Cache.php | 239 + scssphp/src/Colors.php | 70 +- scssphp/src/Compiler.php | 4154 ++++++++++++++---- scssphp/src/Compiler/Environment.php | 15 +- scssphp/src/Exception/CompilerException.php | 6 +- scssphp/src/Exception/ParserException.php | 6 +- scssphp/src/Exception/RangeException.php | 6 +- scssphp/src/Exception/ServerException.php | 6 +- scssphp/src/Formatter.php | 121 +- scssphp/src/Formatter/Compact.php | 8 +- scssphp/src/Formatter/Compressed.php | 29 +- scssphp/src/Formatter/Crunched.php | 29 +- scssphp/src/Formatter/Debug.php | 10 +- scssphp/src/Formatter/Expanded.php | 12 +- scssphp/src/Formatter/Nested.php | 198 +- scssphp/src/Formatter/OutputBlock.php | 8 +- scssphp/src/Node.php | 6 +- scssphp/src/Node/Number.php | 134 +- scssphp/src/Parser.php | 1860 ++++++-- scssphp/src/SourceMap/Base64.php | 184 + scssphp/src/SourceMap/Base64VLQ.php | 150 + scssphp/src/SourceMap/SourceMapGenerator.php | 89 +- scssphp/src/Type.php | 7 +- scssphp/src/Util.php | 16 +- scssphp/src/Version.php | 8 +- 29 files changed, 5852 insertions(+), 1594 deletions(-) create mode 100644 scssphp/src/Cache.php create mode 100644 scssphp/src/SourceMap/Base64.php create mode 100644 scssphp/src/SourceMap/Base64VLQ.php diff --git a/scssphp/bin/pscss b/scssphp/bin/pscss index be1cb51..56bf48f 100755 --- a/scssphp/bin/pscss +++ b/scssphp/bin/pscss @@ -3,24 +3,24 @@ /** * SCSSPHP * - * @copyright 2012-2015 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ error_reporting(E_ALL); -if (version_compare(PHP_VERSION, '5.4') < 0) { - die('Requires PHP 5.4 or above'); +if (version_compare(PHP_VERSION, '5.6') < 0) { + die('Requires PHP 5.6 or above'); } include __DIR__ . '/../scss.inc.php'; -use Leafo\ScssPhp\Compiler; -use Leafo\ScssPhp\Parser; -use Leafo\ScssPhp\Version; +use ScssPhp\ScssPhp\Compiler; +use ScssPhp\ScssPhp\Parser; +use ScssPhp\ScssPhp\Version; $style = null; $loadPaths = null; @@ -62,7 +62,7 @@ function parseArgument(&$i, $options) { } for ($i = 1; $i < $argc; $i++) { - if ($argv[$i] === '-h' || $argv[$i] === '--help') { + if ($argv[$i] === '-?' || $argv[$i] === '-h' || $argv[$i] === '--help') { $exe = $argv[0]; $HELP = <<setFormatter('Leafo\\ScssPhp\\Formatter\\' . ucfirst($style)); + $scss->setFormatter('ScssPhp\\ScssPhp\\Formatter\\' . ucfirst($style)); } if ($sourceMap) { - $scss->setSourceMap(Compiler::SOURCE_MAP_FILE); + $scss->setSourceMap(Compiler::SOURCE_MAP_INLINE); } if ($encoding) { diff --git a/scssphp/scss.inc.php b/scssphp/scss.inc.php index 13c84bf..e4ec7f1 100755 --- a/scssphp/scss.inc.php +++ b/scssphp/scss.inc.php @@ -1,11 +1,12 @@ + */ +class Cache +{ + const CACHE_VERSION = 1; + + // directory used for storing data + public static $cacheDir = false; + + // prefix for the storing data + public static $prefix = 'scssphp_'; + + // force a refresh : 'once' for refreshing the first hit on a cache only, true to never use the cache in this hit + public static $forceRefresh = false; + + // specifies the number of seconds after which data cached will be seen as 'garbage' and potentially cleaned up + public static $gcLifetime = 604800; + + // array of already refreshed cache if $forceRefresh==='once' + protected static $refreshed = []; + + /** + * Constructor + * + * @param array $options + */ + public function __construct($options) + { + // check $cacheDir + if (isset($options['cacheDir'])) { + self::$cacheDir = $options['cacheDir']; + } + + if (empty(self::$cacheDir)) { + throw new Exception('cacheDir not set'); + } + + if (isset($options['prefix'])) { + self::$prefix = $options['prefix']; + } + + if (empty(self::$prefix)) { + throw new Exception('prefix not set'); + } + + if (isset($options['forceRefresh'])) { + self::$forceRefresh = $options['forceRefresh']; + } + + self::checkCacheDir(); + } + + /** + * Get the cached result of $operation on $what, + * which is known as dependant from the content of $options + * + * @param string $operation parse, compile... + * @param mixed $what content key (e.g., filename to be treated) + * @param array $options any option that affect the operation result on the content + * @param integer $lastModified last modified timestamp + * + * @return mixed + * + * @throws \Exception + */ + public function getCache($operation, $what, $options = [], $lastModified = null) + { + $fileCache = self::$cacheDir . self::cacheName($operation, $what, $options); + + if (((self::$forceRefresh === false) || (self::$forceRefresh === 'once' && + isset(self::$refreshed[$fileCache]))) && file_exists($fileCache) + ) { + $cacheTime = filemtime($fileCache); + + if ((\is_null($lastModified) || $cacheTime > $lastModified) && + $cacheTime + self::$gcLifetime > time() + ) { + $c = file_get_contents($fileCache); + $c = unserialize($c); + + if (\is_array($c) && isset($c['value'])) { + return $c['value']; + } + } + } + + return null; + } + + /** + * Put in cache the result of $operation on $what, + * which is known as dependant from the content of $options + * + * @param string $operation + * @param mixed $what + * @param mixed $value + * @param array $options + */ + public function setCache($operation, $what, $value, $options = []) + { + $fileCache = self::$cacheDir . self::cacheName($operation, $what, $options); + + $c = ['value' => $value]; + $c = serialize($c); + + file_put_contents($fileCache, $c); + + if (self::$forceRefresh === 'once') { + self::$refreshed[$fileCache] = true; + } + } + + /** + * Get the cache name for the caching of $operation on $what, + * which is known as dependant from the content of $options + * + * @param string $operation + * @param mixed $what + * @param array $options + * + * @return string + */ + private static function cacheName($operation, $what, $options = []) + { + $t = [ + 'version' => self::CACHE_VERSION, + 'operation' => $operation, + 'what' => $what, + 'options' => $options + ]; + + $t = self::$prefix + . sha1(json_encode($t)) + . ".$operation" + . ".scsscache"; + + return $t; + } + + /** + * Check that the cache dir exists and is writeable + * + * @throws \Exception + */ + public static function checkCacheDir() + { + self::$cacheDir = str_replace('\\', '/', self::$cacheDir); + self::$cacheDir = rtrim(self::$cacheDir, '/') . '/'; + + if (! is_dir(self::$cacheDir)) { + if (! mkdir(self::$cacheDir)) { + throw new Exception('Cache directory couldn\'t be created: ' . self::$cacheDir); + } + } + + if (! is_writable(self::$cacheDir)) { + throw new Exception('Cache directory isn\'t writable: ' . self::$cacheDir); + } + } + + /** + * Delete unused cached files + */ + public static function cleanCache() + { + static $clean = false; + + if ($clean || empty(self::$cacheDir)) { + return; + } + + $clean = true; + + // only remove files with extensions created by SCSSPHP Cache + // css files removed based on the list files + $removeTypes = ['scsscache' => 1]; + + $files = scandir(self::$cacheDir); + + if (! $files) { + return; + } + + $checkTime = time() - self::$gcLifetime; + + foreach ($files as $file) { + // don't delete if the file wasn't created with SCSSPHP Cache + if (strpos($file, self::$prefix) !== 0) { + continue; + } + + $parts = explode('.', $file); + $type = array_pop($parts); + + if (! isset($removeTypes[$type])) { + continue; + } + + $fullPath = self::$cacheDir . $file; + $mtime = filemtime($fullPath); + + // don't delete if it's a relatively new file + if ($mtime > $checkTime) { + continue; + } + + unlink($fullPath); + } + } +} diff --git a/scssphp/src/Colors.php b/scssphp/src/Colors.php index 2314ea5..c3ca1bf 100755 --- a/scssphp/src/Colors.php +++ b/scssphp/src/Colors.php @@ -2,14 +2,14 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp; +namespace ScssPhp\ScssPhp; /** * CSS Colors @@ -25,7 +25,7 @@ class Colors * * @var array */ - public static $cssColors = [ + protected static $cssColors = [ 'aliceblue' => '240,248,255', 'antiquewhite' => '250,235,215', 'aqua' => '0,255,255', @@ -176,4 +176,66 @@ class Colors 'yellow' => '255,255,0', 'yellowgreen' => '154,205,50', ]; + + /** + * Convert named color in a [r,g,b[,a]] array + * + * @param string $colorName + * + * @return array|null + */ + public static function colorNameToRGBa($colorName) + { + if (\is_string($colorName) && isset(static::$cssColors[$colorName])) { + $rgba = explode(',', static::$cssColors[$colorName]); + + // only case with opacity is transparent, with opacity=0, so we can intval on opacity also + $rgba = array_map('intval', $rgba); + + return $rgba; + } + + return null; + } + + /** + * Reverse conversion : from RGBA to a color name if possible + * + * @param integer $r + * @param integer $g + * @param integer $b + * @param integer $a + * + * @return string|null + */ + public static function RGBaToColorName($r, $g, $b, $a = 1) + { + static $reverseColorTable = null; + + if (! is_numeric($r) || ! is_numeric($g) || ! is_numeric($b) || ! is_numeric($a)) { + return null; + } + + if ($a < 1) { + return null; + } + + if (\is_null($reverseColorTable)) { + $reverseColorTable = []; + + foreach (static::$cssColors as $name => $rgb_str) { + $rgb_str = explode(',', $rgb_str); + + if (\count($rgb_str) == 3) { + $reverseColorTable[\intval($rgb_str[0])][\intval($rgb_str[1])][\intval($rgb_str[2])] = $name; + } + } + } + + if (isset($reverseColorTable[\intval($r)][\intval($g)][\intval($b)])) { + return $reverseColorTable[\intval($r)][\intval($g)][\intval($b)]; + } + + return null; + } } diff --git a/scssphp/src/Compiler.php b/scssphp/src/Compiler.php index 698d4d8..d2ded94 100755 --- a/scssphp/src/Compiler.php +++ b/scssphp/src/Compiler.php @@ -2,26 +2,27 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp; - -use Leafo\ScssPhp\Base\Range; -use Leafo\ScssPhp\Block; -use Leafo\ScssPhp\Colors; -use Leafo\ScssPhp\Compiler\Environment; -use Leafo\ScssPhp\Exception\CompilerException; -use Leafo\ScssPhp\Formatter\OutputBlock; -use Leafo\ScssPhp\Node; -use Leafo\ScssPhp\SourceMap\SourceMapGenerator; -use Leafo\ScssPhp\Type; -use Leafo\ScssPhp\Parser; -use Leafo\ScssPhp\Util; +namespace ScssPhp\ScssPhp; + +use ScssPhp\ScssPhp\Base\Range; +use ScssPhp\ScssPhp\Block; +use ScssPhp\ScssPhp\Cache; +use ScssPhp\ScssPhp\Colors; +use ScssPhp\ScssPhp\Compiler\Environment; +use ScssPhp\ScssPhp\Exception\CompilerException; +use ScssPhp\ScssPhp\Formatter\OutputBlock; +use ScssPhp\ScssPhp\Node; +use ScssPhp\ScssPhp\SourceMap\SourceMapGenerator; +use ScssPhp\ScssPhp\Type; +use ScssPhp\ScssPhp\Parser; +use ScssPhp\ScssPhp\Util; /** * The scss compiler and parser. @@ -72,7 +73,7 @@ class Compiler /** * @var array */ - static protected $operatorNames = [ + protected static $operatorNames = [ '+' => 'add', '-' => 'sub', '*' => 'mul', @@ -92,23 +93,25 @@ class Compiler /** * @var array */ - static protected $namespaces = [ + protected static $namespaces = [ 'special' => '%', 'mixin' => '@', 'function' => '^', ]; - static public $true = [Type::T_KEYWORD, 'true']; - static public $false = [Type::T_KEYWORD, 'false']; - static public $null = [Type::T_NULL]; - static public $nullString = [Type::T_STRING, '', []]; - static public $defaultValue = [Type::T_KEYWORD, '']; - static public $selfSelector = [Type::T_SELF]; - static public $emptyList = [Type::T_LIST, '', []]; - static public $emptyMap = [Type::T_MAP, [], []]; - static public $emptyString = [Type::T_STRING, '"', []]; - static public $with = [Type::T_KEYWORD, 'with']; - static public $without = [Type::T_KEYWORD, 'without']; + public static $true = [Type::T_KEYWORD, 'true']; + public static $false = [Type::T_KEYWORD, 'false']; + public static $NaN = [Type::T_KEYWORD, 'NaN']; + public static $Infinity = [Type::T_KEYWORD, 'Infinity']; + public static $null = [Type::T_NULL]; + public static $nullString = [Type::T_STRING, '', []]; + public static $defaultValue = [Type::T_KEYWORD, '']; + public static $selfSelector = [Type::T_SELF]; + public static $emptyList = [Type::T_LIST, '', []]; + public static $emptyMap = [Type::T_MAP, [], []]; + public static $emptyString = [Type::T_STRING, '"', []]; + public static $with = [Type::T_KEYWORD, 'with']; + public static $without = [Type::T_KEYWORD, 'without']; protected $importPaths = ['']; protected $importCache = []; @@ -129,15 +132,15 @@ class Compiler protected $sourceMapOptions = []; /** - * @var string|\Leafo\ScssPhp\Formatter + * @var string|\ScssPhp\ScssPhp\Formatter */ - protected $formatter = 'Leafo\ScssPhp\Formatter\Nested'; + protected $formatter = 'ScssPhp\ScssPhp\Formatter\Nested'; protected $rootEnv; protected $rootBlock; /** - * @var \Leafo\ScssPhp\Compiler\Environment + * @var \ScssPhp\ScssPhp\Compiler\Environment */ protected $env; protected $scope; @@ -145,26 +148,68 @@ class Compiler protected $charsetSeen; protected $sourceNames; - private $indentLevel; - private $commentsSeen; - private $extends; - private $extendsMap; - private $parsedFiles; - private $parser; - private $sourceIndex; - private $sourceLine; - private $sourceColumn; - private $stderr; - private $shouldEvaluate; - private $ignoreErrors; + protected $cache; + + protected $indentLevel; + protected $extends; + protected $extendsMap; + protected $parsedFiles; + protected $parser; + protected $sourceIndex; + protected $sourceLine; + protected $sourceColumn; + protected $stderr; + protected $shouldEvaluate; + protected $ignoreErrors; + protected $ignoreCallStackMessage = false; + + protected $callStack = []; /** * Constructor + * + * @param array|null $cacheOptions */ - public function __construct() + public function __construct($cacheOptions = null) { $this->parsedFiles = []; $this->sourceNames = []; + + if ($cacheOptions) { + $this->cache = new Cache($cacheOptions); + } + + $this->stderr = fopen('php://stderr', 'w'); + } + + /** + * Get compiler options + * + * @return array + */ + public function getCompileOptions() + { + $options = [ + 'importPaths' => $this->importPaths, + 'registeredVars' => $this->registeredVars, + 'registeredFeatures' => $this->registeredFeatures, + 'encoding' => $this->encoding, + 'sourceMap' => serialize($this->sourceMap), + 'sourceMapOptions' => $this->sourceMapOptions, + 'formatter' => $this->formatter, + ]; + + return $options; + } + + /** + * Set an alternative error output stream, for testing purpose only + * + * @param resource $handle + */ + public function setErrorOuput($handle) + { + $this->stderr = $handle; } /** @@ -179,8 +224,28 @@ public function __construct() */ public function compile($code, $path = null) { + if ($this->cache) { + $cacheKey = ($path ? $path : "(stdin)") . ":" . md5($code); + $compileOptions = $this->getCompileOptions(); + $cache = $this->cache->getCache("compile", $cacheKey, $compileOptions); + + if (\is_array($cache) && isset($cache['dependencies']) && isset($cache['out'])) { + // check if any dependency file changed before accepting the cache + foreach ($cache['dependencies'] as $file => $mtime) { + if (! is_file($file) || filemtime($file) !== $mtime) { + unset($cache); + break; + } + } + + if (isset($cache)) { + return $cache['out']; + } + } + } + + $this->indentLevel = -1; - $this->commentsSeen = []; $this->extends = []; $this->extendsMap = []; $this->sourceIndex = null; @@ -191,10 +256,10 @@ public function compile($code, $path = null) $this->storeEnv = null; $this->charsetSeen = null; $this->shouldEvaluate = null; - $this->stderr = fopen('php://stderr', 'w'); + $this->ignoreCallStackMessage = false; $this->parser = $this->parserFactory($path); - $tree = $this->parser->parse($code); + $tree = $this->parser->parse($code); $this->parser = null; $this->formatter = new $this->formatter(); @@ -208,7 +273,7 @@ public function compile($code, $path = null) $sourceMapGenerator = null; if ($this->sourceMap) { - if (is_object($this->sourceMap) && $this->sourceMap instanceof SourceMapGenerator) { + if (\is_object($this->sourceMap) && $this->sourceMap instanceof SourceMapGenerator) { $sourceMapGenerator = $this->sourceMap; $this->sourceMap = self::SOURCE_MAP_FILE; } elseif ($this->sourceMap !== self::SOURCE_MAP_NONE) { @@ -235,6 +300,15 @@ public function compile($code, $path = null) $out .= sprintf('/*# sourceMappingURL=%s */', $sourceMapUrl); } + if ($this->cache && isset($cacheKey) && isset($compileOptions)) { + $v = [ + 'dependencies' => $this->getParsedFiles(), + 'out' => &$out, + ]; + + $this->cache->setCache("compile", $cacheKey, $v, $compileOptions); + } + return $out; } @@ -243,11 +317,22 @@ public function compile($code, $path = null) * * @param string $path * - * @return \Leafo\ScssPhp\Parser + * @return \ScssPhp\ScssPhp\Parser */ protected function parserFactory($path) { - $parser = new Parser($path, count($this->sourceNames), $this->encoding); + // https://sass-lang.com/documentation/at-rules/import + // CSS files imported by Sass don’t allow any special Sass features. + // In order to make sure authors don’t accidentally write Sass in their CSS, + // all Sass features that aren’t also valid CSS will produce errors. + // Otherwise, the CSS will be rendered as-is. It can even be extended! + $cssOnly = false; + + if (substr($path, '-4') === '.css') { + $cssOnly = true; + } + + $parser = new Parser($path, \count($this->sourceNames), $this->encoding, $this->cache, $cssOnly); $this->sourceNames[] = $path; $this->addParsedFile($path); @@ -266,7 +351,7 @@ protected function parserFactory($path) protected function isSelfExtend($target, $origin) { foreach ($origin as $sel) { - if (in_array($target, $sel)) { + if (\in_array($target, $sel)) { return true; } } @@ -277,17 +362,13 @@ protected function isSelfExtend($target, $origin) /** * Push extends * - * @param array $target - * @param array $origin - * @param \stdClass $block + * @param array $target + * @param array $origin + * @param array|null $block */ protected function pushExtends($target, $origin, $block) { - if ($this->isSelfExtend($target, $origin)) { - return; - } - - $i = count($this->extends); + $i = \count($this->extends); $this->extends[] = [$target, $origin, $block]; foreach ($target as $part) { @@ -305,20 +386,27 @@ protected function pushExtends($target, $origin, $block) * @param string $type * @param array $selectors * - * @return \Leafo\ScssPhp\Formatter\OutputBlock + * @return \ScssPhp\ScssPhp\Formatter\OutputBlock */ protected function makeOutputBlock($type, $selectors = null) { - $out = new OutputBlock; - $out->type = $type; - $out->lines = []; - $out->children = []; - $out->parent = $this->scope; - $out->selectors = $selectors; - $out->depth = $this->env->depth; - $out->sourceName = $this->env->block->sourceName; - $out->sourceLine = $this->env->block->sourceLine; - $out->sourceColumn = $this->env->block->sourceColumn; + $out = new OutputBlock(); + $out->type = $type; + $out->lines = []; + $out->children = []; + $out->parent = $this->scope; + $out->selectors = $selectors; + $out->depth = $this->env->depth; + + if ($this->env->block instanceof Block) { + $out->sourceName = $this->env->block->sourceName; + $out->sourceLine = $this->env->block->sourceLine; + $out->sourceColumn = $this->env->block->sourceColumn; + } else { + $out->sourceName = null; + $out->sourceLine = null; + $out->sourceColumn = null; + } return $out; } @@ -326,7 +414,7 @@ protected function makeOutputBlock($type, $selectors = null) /** * Compile root * - * @param \Leafo\ScssPhp\Block $rootBlock + * @param \ScssPhp\ScssPhp\Block $rootBlock */ protected function compileRoot(Block $rootBlock) { @@ -365,8 +453,8 @@ protected function missingSelectors() /** * Flatten selectors * - * @param \Leafo\ScssPhp\Formatter\OutputBlock $block - * @param string $parentKey + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block + * @param string $parentKey */ protected function flattenSelectors(OutputBlock $block, $parentKey = null) { @@ -376,7 +464,7 @@ protected function flattenSelectors(OutputBlock $block, $parentKey = null) foreach ($block->selectors as $s) { $selectors[] = $s; - if (! is_array($s)) { + if (! \is_array($s)) { continue; } @@ -409,7 +497,7 @@ protected function flattenSelectors(OutputBlock $block, $parentKey = null) $block->selectors[] = $this->compileSelector($selector); } - if ($placeholderSelector && 0 === count($block->selectors) && null !== $parentKey) { + if ($placeholderSelector && 0 === \count($block->selectors) && null !== $parentKey) { unset($block->parent->children[$parentKey]); return; @@ -421,6 +509,40 @@ protected function flattenSelectors(OutputBlock $block, $parentKey = null) } } + /** + * Glue parts of :not( or :nth-child( ... that are in general splitted in selectors parts + * + * @param array $parts + * + * @return array + */ + protected function glueFunctionSelectors($parts) + { + $new = []; + + foreach ($parts as $part) { + if (\is_array($part)) { + $part = $this->glueFunctionSelectors($part); + $new[] = $part; + } else { + // a selector part finishing with a ) is the last part of a :not( or :nth-child( + // and need to be joined to this + if (\count($new) && \is_string($new[\count($new) - 1]) && + \strlen($part) && substr($part, -1) === ')' && strpos($part, '(') === false + ) { + while (\count($new)>1 && substr($new[\count($new) - 1], -1) !== '(') { + $part = array_pop($new) . $part; + } + $new[\count($new) - 1] .= $part; + } else { + $new[] = $part; + } + } + } + + return $new; + } + /** * Match extends * @@ -431,32 +553,63 @@ protected function flattenSelectors(OutputBlock $block, $parentKey = null) */ protected function matchExtends($selector, &$out, $from = 0, $initial = true) { + static $partsPile = []; + $selector = $this->glueFunctionSelectors($selector); + + if (\count($selector) == 1 && \in_array(reset($selector), $partsPile)) { + return; + } + + $outRecurs = []; + foreach ($selector as $i => $part) { if ($i < $from) { continue; } - if ($this->matchExtendsSingle($part, $origin)) { - $after = array_slice($selector, $i + 1); - $before = array_slice($selector, 0, $i); + // check that we are not building an infinite loop of extensions + // if the new part is just including a previous part don't try to extend anymore + if (\count($part) > 1) { + foreach ($partsPile as $previousPart) { + if (! \count(array_diff($previousPart, $part))) { + continue 2; + } + } + } + + $partsPile[] = $part; + if ($this->matchExtendsSingle($part, $origin, $initial)) { + $after = \array_slice($selector, $i + 1); + $before = \array_slice($selector, 0, $i); list($before, $nonBreakableBefore) = $this->extractRelationshipFromFragment($before); foreach ($origin as $new) { $k = 0; // remove shared parts - if ($initial) { + if (\count($new) > 1) { while ($k < $i && isset($new[$k]) && $selector[$k] === $new[$k]) { $k++; } } + if (\count($nonBreakableBefore) and $k == \count($new)) { + $k--; + } + $replacement = []; - $tempReplacement = $k > 0 ? array_slice($new, $k) : $new; + $tempReplacement = $k > 0 ? \array_slice($new, $k) : $new; + + for ($l = \count($tempReplacement) - 1; $l >= 0; $l--) { + $slice = []; + + foreach ($tempReplacement[$l] as $chunk) { + if (! \in_array($chunk, $slice)) { + $slice[] = $chunk; + } + } - for ($l = count($tempReplacement) - 1; $l >= 0; $l--) { - $slice = $tempReplacement[$l]; array_unshift($replacement, $slice); if (! $this->isImmediateRelationshipCombinator(end($slice))) { @@ -464,7 +617,7 @@ protected function matchExtends($selector, &$out, $from = 0, $initial = true) } } - $afterBefore = $l != 0 ? array_slice($tempReplacement, 0, $l) : []; + $afterBefore = $l != 0 ? \array_slice($tempReplacement, 0, $l) : []; // Merge shared direct relationships. $mergedBefore = $this->mergeDirectRelationships($afterBefore, $nonBreakableBefore); @@ -480,56 +633,134 @@ protected function matchExtends($selector, &$out, $from = 0, $initial = true) continue; } - $out[] = $result; + $this->pushOrMergeExtentedSelector($out, $result); // recursively check for more matches - $this->matchExtends($result, $out, count($before) + count($mergedBefore), false); + $startRecurseFrom = \count($before) + min(\count($nonBreakableBefore), \count($mergedBefore)); + + if (\count($origin) > 1) { + $this->matchExtends($result, $out, $startRecurseFrom, false); + } else { + $this->matchExtends($result, $outRecurs, $startRecurseFrom, false); + } // selector sequence merging - if (! empty($before) && count($new) > 1) { - $sharedParts = $k > 0 ? array_slice($before, 0, $k) : []; - $postSharedParts = $k > 0 ? array_slice($before, $k) : $before; + if (! empty($before) && \count($new) > 1) { + $preSharedParts = $k > 0 ? \array_slice($before, 0, $k) : []; + $postSharedParts = $k > 0 ? \array_slice($before, $k) : $before; - list($injectBetweenSharedParts, $nonBreakable2) = $this->extractRelationshipFromFragment($afterBefore); + list($betweenSharedParts, $nonBreakabl2) = $this->extractRelationshipFromFragment($afterBefore); $result2 = array_merge( - $sharedParts, - $injectBetweenSharedParts, + $preSharedParts, + $betweenSharedParts, $postSharedParts, - $nonBreakable2, + $nonBreakabl2, $nonBreakableBefore, $replacement, $after ); - $out[] = $result2; + $this->pushOrMergeExtentedSelector($out, $result2); + } + } + } + array_pop($partsPile); + } + + while (\count($outRecurs)) { + $result = array_shift($outRecurs); + $this->pushOrMergeExtentedSelector($out, $result); + } + } + + /** + * Test a part for being a pseudo selector + * + * @param string $part + * @param array $matches + * + * @return boolean + */ + protected function isPseudoSelector($part, &$matches) + { + if (strpos($part, ":") === 0 + && preg_match(",^::?([\w-]+)\((.+)\)$,", $part, $matches) + ) { + return true; + } + + return false; + } + + /** + * Push extended selector except if + * - this is a pseudo selector + * - same as previous + * - in a white list + * in this case we merge the pseudo selector content + * + * @param array $out + * @param array $extended + */ + protected function pushOrMergeExtentedSelector(&$out, $extended) + { + if (\count($out) && \count($extended) === 1 && \count(reset($extended)) === 1) { + $single = reset($extended); + $part = reset($single); + + if ($this->isPseudoSelector($part, $matchesExtended) && + \in_array($matchesExtended[1], [ 'slotted' ]) + ) { + $prev = end($out); + $prev = $this->glueFunctionSelectors($prev); + + if (\count($prev) === 1 && \count(reset($prev)) === 1) { + $single = reset($prev); + $part = reset($single); + + if ($this->isPseudoSelector($part, $matchesPrev) && + $matchesPrev[1] === $matchesExtended[1] + ) { + $extended = explode($matchesExtended[1] . '(', $matchesExtended[0], 2); + $extended[1] = $matchesPrev[2] . ", " . $extended[1]; + $extended = implode($matchesExtended[1] . '(', $extended); + $extended = [ [ $extended ]]; + array_pop($out); } } } } + $out[] = $extended; } /** * Match extends single * - * @param array $rawSingle - * @param array $outOrigin + * @param array $rawSingle + * @param array $outOrigin + * @param boolean $initial * * @return boolean */ - protected function matchExtendsSingle($rawSingle, &$outOrigin) + protected function matchExtendsSingle($rawSingle, &$outOrigin, $initial = true) { $counts = []; $single = []; + // simple usual cases, no need to do the whole trick + if (\in_array($rawSingle, [['>'],['+'],['~']])) { + return false; + } + foreach ($rawSingle as $part) { // matches Number - if (! is_string($part)) { + if (! \is_string($part)) { return false; } - if (! preg_match('/^[\[.:#%]/', $part) && count($single)) { - $single[count($single) - 1] .= $part; + if (! preg_match('/^[\[.:#%]/', $part) && \count($single)) { + $single[\count($single) - 1] .= $part; } else { $single[] = $part; } @@ -537,27 +768,59 @@ protected function matchExtendsSingle($rawSingle, &$outOrigin) $extendingDecoratedTag = false; - if (count($single) > 1) { + if (\count($single) > 1) { $matches = null; $extendingDecoratedTag = preg_match('/^[a-z0-9]+$/i', $single[0], $matches) ? $matches[0] : false; } - foreach ($single as $part) { + $outOrigin = []; + $found = false; + + foreach ($single as $k => $part) { if (isset($this->extendsMap[$part])) { foreach ($this->extendsMap[$part] as $idx) { $counts[$idx] = isset($counts[$idx]) ? $counts[$idx] + 1 : 1; } } - } - $outOrigin = []; - $found = false; + if ($initial && + $this->isPseudoSelector($part, $matches) && + ! \in_array($matches[1], [ 'not' ]) + ) { + $buffer = $matches[2]; + $parser = $this->parserFactory(__METHOD__); + + if ($parser->parseSelector($buffer, $subSelectors)) { + foreach ($subSelectors as $ksub => $subSelector) { + $subExtended = []; + $this->matchExtends($subSelector, $subExtended, 0, false); + + if ($subExtended) { + $subSelectorsExtended = $subSelectors; + $subSelectorsExtended[$ksub] = $subExtended; + + foreach ($subSelectorsExtended as $ksse => $sse) { + $subSelectorsExtended[$ksse] = $this->collapseSelectors($sse); + } + + $subSelectorsExtended = implode(', ', $subSelectorsExtended); + $singleExtended = $single; + $singleExtended[$k] = str_replace("(".$buffer.")", "($subSelectorsExtended)", $part); + $outOrigin[] = [ $singleExtended ]; + $found = true; + } + } + } + } + } foreach ($counts as $idx => $count) { list($target, $origin, /* $block */) = $this->extends[$idx]; + $origin = $this->glueFunctionSelectors($origin); + // check count - if ($count !== count($target)) { + if ($count !== \count($target)) { continue; } @@ -567,7 +830,7 @@ protected function matchExtendsSingle($rawSingle, &$outOrigin) foreach ($origin as $j => $new) { // prevent infinite loop when target extends itself - if ($this->isSelfExtend($single, $origin)) { + if ($this->isSelfExtend($single, $origin) and !$initial) { return false; } @@ -583,8 +846,8 @@ protected function matchExtendsSingle($rawSingle, &$outOrigin) $combined = $this->combineSelectorSingle($replacement, $rem); - if (count(array_diff($combined, $origin[$j][count($origin[$j]) - 1]))) { - $origin[$j][count($origin[$j]) - 1] = $combined; + if (\count(array_diff($combined, $origin[$j][\count($origin[$j]) - 1]))) { + $origin[$j][\count($origin[$j]) - 1] = $combined; } } @@ -596,7 +859,6 @@ protected function matchExtendsSingle($rawSingle, &$outOrigin) return $found; } - /** * Extract a relationship from the fragment. * @@ -606,18 +868,20 @@ protected function matchExtendsSingle($rawSingle, &$outOrigin) * the rest. * * @param array $fragment The selector fragment maybe ending with a direction relationship combinator. + * * @return array The selector without the relationship fragment if any, the relationship fragment. */ protected function extractRelationshipFromFragment(array $fragment) { $parents = []; $children = []; - $j = $i = count($fragment); + + $j = $i = \count($fragment); for (;;) { - $children = $j != $i ? array_slice($fragment, $j, $i - $j) : []; - $parents = array_slice($fragment, 0, $j); - $slice = end($parents); + $children = $j != $i ? \array_slice($fragment, $j, $i - $j) : []; + $parents = \array_slice($fragment, 0, $j); + $slice = end($parents); if (empty($slice) || ! $this->isImmediateRelationshipCombinator($slice[0])) { break; @@ -639,49 +903,68 @@ protected function extractRelationshipFromFragment(array $fragment) */ protected function combineSelectorSingle($base, $other) { - $tag = []; - $out = []; - $wasTag = true; + $tag = []; + $out = []; + $wasTag = false; + $pseudo = []; - foreach ([$base, $other] as $single) { + while (\count($other) && strpos(end($other), ':')===0) { + array_unshift($pseudo, array_pop($other)); + } + + foreach ([array_reverse($base), array_reverse($other)] as $single) { + $rang = count($single); foreach ($single as $part) { - if (preg_match('/^[\[.:#]/', $part)) { + if (preg_match('/^[\[:]/', $part)) { $out[] = $part; $wasTag = false; - } elseif (preg_match('/^[^_-]/', $part)) { + } elseif (preg_match('/^[\.#]/', $part)) { + array_unshift($out, $part); + $wasTag = false; + } elseif (preg_match('/^[^_-]/', $part) and $rang==1) { $tag[] = $part; $wasTag = true; } elseif ($wasTag) { - $tag[count($tag) - 1] .= $part; + $tag[\count($tag) - 1] .= $part; } else { - $out[count($out) - 1] .= $part; + array_unshift($out, $part); } + $rang--; } } - if (count($tag)) { + if (\count($tag)) { array_unshift($out, $tag[0]); } + while (\count($pseudo)) { + $out[] = array_shift($pseudo); + } + return $out; } /** * Compile media * - * @param \Leafo\ScssPhp\Block $media + * @param \ScssPhp\ScssPhp\Block $media */ protected function compileMedia(Block $media) { $this->pushEnv($media); - $mediaQuery = $this->compileMediaQuery($this->multiplyMedia($this->env)); - - if (! empty($mediaQuery)) { - $this->scope = $this->makeOutputBlock(Type::T_MEDIA, [$mediaQuery]); + $mediaQueries = $this->compileMediaQuery($this->multiplyMedia($this->env)); + if (! empty($mediaQueries) && $mediaQueries) { + $previousScope = $this->scope; $parentScope = $this->mediaParent($this->scope); - $parentScope->children[] = $this->scope; + + foreach ($mediaQueries as $mediaQuery) { + $this->scope = $this->makeOutputBlock(Type::T_MEDIA, [$mediaQuery]); + + $parentScope->children[] = $this->scope; + $parentScope = $this->scope; + } // top level properties in a media cause it to be wrapped $needsWrap = false; @@ -700,7 +983,7 @@ protected function compileMedia(Block $media) } if ($needsWrap) { - $wrapped = new Block; + $wrapped = new Block(); $wrapped->sourceName = $media->sourceName; $wrapped->sourceIndex = $media->sourceIndex; $wrapped->sourceLine = $media->sourceLine; @@ -711,11 +994,35 @@ protected function compileMedia(Block $media) $wrapped->children = $media->children; $media->children = [[Type::T_BLOCK, $wrapped]]; + + if (isset($this->lineNumberStyle)) { + $annotation = $this->makeOutputBlock(Type::T_COMMENT); + $annotation->depth = 0; + + $file = $this->sourceNames[$media->sourceIndex]; + $line = $media->sourceLine; + + switch ($this->lineNumberStyle) { + case static::LINE_COMMENTS: + $annotation->lines[] = '/* line ' . $line + . ($file ? ', ' . $file : '') + . ' */'; + break; + + case static::DEBUG_INFO: + $annotation->lines[] = '@media -sass-debug-info{' + . ($file ? 'filename{font-family:"' . $file . '"}' : '') + . 'line{font-family:' . $line . '}}'; + break; + } + + $this->scope->children[] = $annotation; + } } $this->compileChildrenNoReturn($media->children, $this->scope); - $this->scope = $this->scope->parent; + $this->scope = $previousScope; } $this->popEnv(); @@ -724,9 +1031,9 @@ protected function compileMedia(Block $media) /** * Media parent * - * @param \Leafo\ScssPhp\Formatter\OutputBlock $scope + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope * - * @return \Leafo\ScssPhp\Formatter\OutputBlock + * @return \ScssPhp\ScssPhp\Formatter\OutputBlock */ protected function mediaParent(OutputBlock $scope) { @@ -744,37 +1051,48 @@ protected function mediaParent(OutputBlock $scope) /** * Compile directive * - * @param \Leafo\ScssPhp\Block $block + * @param \ScssPhp\ScssPhp\Block|array $block + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out */ - protected function compileDirective(Block $block) + protected function compileDirective($directive, OutputBlock $out) { - $s = '@' . $block->name; + if (\is_array($directive)) { + $s = '@' . $directive[0]; - if (! empty($block->value)) { - $s .= ' ' . $this->compileValue($block->value); - } + if (! empty($directive[1])) { + $s .= ' ' . $this->compileValue($directive[1]); + } - if ($block->name === 'keyframes' || substr($block->name, -10) === '-keyframes') { - $this->compileKeyframeBlock($block, [$s]); + $this->appendRootDirective($s . ';', $out); } else { - $this->compileNestedBlock($block, [$s]); + $s = '@' . $directive->name; + + if (! empty($directive->value)) { + $s .= ' ' . $this->compileValue($directive->value); + } + + if ($directive->name === 'keyframes' || substr($directive->name, -10) === '-keyframes') { + $this->compileKeyframeBlock($directive, [$s]); + } else { + $this->compileNestedBlock($directive, [$s]); + } } } /** * Compile at-root * - * @param \Leafo\ScssPhp\Block $block + * @param \ScssPhp\ScssPhp\Block $block */ protected function compileAtRoot(Block $block) { $env = $this->pushEnv($block); $envs = $this->compactEnv($env); - $without = isset($block->with) ? $this->compileWith($block->with) : static::WITH_RULE; + list($with, $without) = $this->compileWith(isset($block->with) ? $block->with : null); // wrap inline selector if ($block->selector) { - $wrapped = new Block; + $wrapped = new Block(); $wrapped->sourceName = $block->sourceName; $wrapped->sourceIndex = $block->sourceIndex; $wrapped->sourceLine = $block->sourceLine; @@ -783,18 +1101,29 @@ protected function compileAtRoot(Block $block) $wrapped->comments = []; $wrapped->parent = $block; $wrapped->children = $block->children; + $wrapped->selfParent = $block->selfParent; $block->children = [[Type::T_BLOCK, $wrapped]]; + $block->selector = null; + } + + $selfParent = $block->selfParent; + + if (! $block->selfParent->selectors && isset($block->parent) && $block->parent && + isset($block->parent->selectors) && $block->parent->selectors + ) { + $selfParent = $block->parent; } - $this->env = $this->filterWithout($envs, $without); - $newBlock = $this->spliceTree($envs, $block, $without); + $this->env = $this->filterWithWithout($envs, $with, $without); $saveScope = $this->scope; - $this->scope = $this->rootBlock; + $this->scope = $this->filterScopeWithWithout($saveScope, $with, $without); - $this->compileChild($newBlock, $this->scope); + // propagate selfParent to the children where they still can be useful + $this->compileChildrenNoReturn($block->children, $this->scope, $selfParent); + $this->scope = $this->completeScope($this->scope, $saveScope); $this->scope = $saveScope; $this->env = $this->extractEnv($envs); @@ -802,152 +1131,190 @@ protected function compileAtRoot(Block $block) } /** - * Splice parse tree + * Filter at-root scope depending of with/without option * - * @param array $envs - * @param \Leafo\ScssPhp\Block $block - * @param integer $without + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope + * @param array $with + * @param array $without * - * @return array + * @return mixed */ - private function spliceTree($envs, Block $block, $without) + protected function filterScopeWithWithout($scope, $with, $without) { - $newBlock = null; + $filteredScopes = []; + $childStash = []; - foreach ($envs as $e) { - if (! isset($e->block)) { - continue; - } + if ($scope->type === TYPE::T_ROOT) { + return $scope; + } - if ($e->block === $block) { - continue; + // start from the root + while ($scope->parent && $scope->parent->type !== TYPE::T_ROOT) { + array_unshift($childStash, $scope); + $scope = $scope->parent; + } + + for (;;) { + if (! $scope) { + break; } - if (isset($e->block->type) && $e->block->type === Type::T_AT_ROOT) { - continue; + if ($this->isWith($scope, $with, $without)) { + $s = clone $scope; + $s->children = []; + $s->lines = []; + $s->parent = null; + + if ($s->type !== Type::T_MEDIA && $s->type !== Type::T_DIRECTIVE) { + $s->selectors = []; + } + + $filteredScopes[] = $s; } - if ($e->block && $this->isWithout($without, $e->block)) { - continue; + if (\count($childStash)) { + $scope = array_shift($childStash); + } elseif ($scope->children) { + $scope = end($scope->children); + } else { + $scope = null; } + } - $b = new Block; - $b->sourceName = $e->block->sourceName; - $b->sourceIndex = $e->block->sourceIndex; - $b->sourceLine = $e->block->sourceLine; - $b->sourceColumn = $e->block->sourceColumn; - $b->selectors = []; - $b->comments = $e->block->comments; - $b->parent = null; + if (! \count($filteredScopes)) { + return $this->rootBlock; + } - if ($newBlock) { - $type = isset($newBlock->type) ? $newBlock->type : Type::T_BLOCK; + $newScope = array_shift($filteredScopes); + $newScope->parent = $this->rootBlock; - $b->children = [[$type, $newBlock]]; + $this->rootBlock->children[] = $newScope; - $newBlock->parent = $b; - } elseif (count($block->children)) { - foreach ($block->children as $child) { - if ($child[0] === Type::T_BLOCK) { - $child[1]->parent = $b; - } - } + $p = &$newScope; - $b->children = $block->children; - } + while (\count($filteredScopes)) { + $s = array_shift($filteredScopes); + $s->parent = $p; + $p->children[] = $s; + $newScope = &$p->children[0]; + $p = &$p->children[0]; + } - if (isset($e->block->type)) { - $b->type = $e->block->type; - } + return $newScope; + } - if (isset($e->block->name)) { - $b->name = $e->block->name; - } + /** + * found missing selector from a at-root compilation in the previous scope + * (if at-root is just enclosing a property, the selector is in the parent tree) + * + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $previousScope + * + * @return mixed + */ + protected function completeScope($scope, $previousScope) + { + if (! $scope->type && (! $scope->selectors || ! \count($scope->selectors)) && \count($scope->lines)) { + $scope->selectors = $this->findScopeSelectors($previousScope, $scope->depth); + } - if (isset($e->block->queryList)) { - $b->queryList = $e->block->queryList; + if ($scope->children) { + foreach ($scope->children as $k => $c) { + $scope->children[$k] = $this->completeScope($c, $previousScope); } + } - if (isset($e->block->value)) { - $b->value = $e->block->value; - } + return $scope; + } - $newBlock = $b; + /** + * Find a selector by the depth node in the scope + * + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope + * @param integer $depth + * + * @return array + */ + protected function findScopeSelectors($scope, $depth) + { + if ($scope->depth === $depth && $scope->selectors) { + return $scope->selectors; } - $type = isset($newBlock->type) ? $newBlock->type : Type::T_BLOCK; + if ($scope->children) { + foreach (array_reverse($scope->children) as $c) { + if ($s = $this->findScopeSelectors($c, $depth)) { + return $s; + } + } + } - return [$type, $newBlock]; + return []; } /** - * Compile @at-root's with: inclusion / without: exclusion into filter flags + * Compile @at-root's with: inclusion / without: exclusion into 2 lists uses to filter scope/env later * - * @param array $with + * @param array $withCondition * - * @return integer + * @return array */ - private function compileWith($with) + protected function compileWith($withCondition) { - static $mapping = [ - 'rule' => self::WITH_RULE, - 'media' => self::WITH_MEDIA, - 'supports' => self::WITH_SUPPORTS, - 'all' => self::WITH_ALL, - ]; - - // exclude selectors by default - $without = static::WITH_RULE; + // just compile what we have in 2 lists + $with = []; + $without = ['rule' => true]; - if ($this->libMapHasKey([$with, static::$with])) { - $without = static::WITH_ALL; + if ($withCondition) { + if ($this->libMapHasKey([$withCondition, static::$with])) { + $without = []; // cancel the default + $list = $this->coerceList($this->libMapGet([$withCondition, static::$with])); - $list = $this->coerceList($this->libMapGet([$with, static::$with])); - - foreach ($list[2] as $item) { - $keyword = $this->compileStringContent($this->coerceString($item)); + foreach ($list[2] as $item) { + $keyword = $this->compileStringContent($this->coerceString($item)); - if (array_key_exists($keyword, $mapping)) { - $without &= ~($mapping[$keyword]); + $with[$keyword] = true; } } - } - - if ($this->libMapHasKey([$with, static::$without])) { - $without = 0; - $list = $this->coerceList($this->libMapGet([$with, static::$without])); + if ($this->libMapHasKey([$withCondition, static::$without])) { + $without = []; // cancel the default + $list = $this->coerceList($this->libMapGet([$withCondition, static::$without])); - foreach ($list[2] as $item) { - $keyword = $this->compileStringContent($this->coerceString($item)); + foreach ($list[2] as $item) { + $keyword = $this->compileStringContent($this->coerceString($item)); - if (array_key_exists($keyword, $mapping)) { - $without |= $mapping[$keyword]; + $without[$keyword] = true; } } } - return $without; + return [$with, $without]; } /** * Filter env stack * - * @param array $envs - * @param integer $without + * @param array $envs + * @param array $with + * @param array $without * - * @return \Leafo\ScssPhp\Compiler\Environment + * @return \ScssPhp\ScssPhp\Compiler\Environment */ - private function filterWithout($envs, $without) + protected function filterWithWithout($envs, $with, $without) { $filtered = []; foreach ($envs as $e) { - if ($e->block && $this->isWithout($without, $e->block)) { - continue; - } + if ($e->block && ! $this->isWith($e->block, $with, $without)) { + $ec = clone $e; + $ec->block = null; + $ec->selectors = []; - $filtered[] = $e; + $filtered[] = $ec; + } else { + $filtered[] = $e; + } } return $this->extractEnv($filtered); @@ -956,31 +1323,76 @@ private function filterWithout($envs, $without) /** * Filter WITH rules * - * @param integer $without - * @param \Leafo\ScssPhp\Block $block + * @param \ScssPhp\ScssPhp\Block|\ScssPhp\ScssPhp\Formatter\OutputBlock $block + * @param array $with + * @param array $without * * @return boolean */ - private function isWithout($without, Block $block) + protected function isWith($block, $with, $without) { - if ((($without & static::WITH_RULE) && isset($block->selectors)) || - (($without & static::WITH_MEDIA) && - isset($block->type) && $block->type === Type::T_MEDIA) || - (($without & static::WITH_SUPPORTS) && - isset($block->type) && $block->type === Type::T_DIRECTIVE && - isset($block->name) && $block->name === 'supports') - ) { - return true; + if (isset($block->type)) { + if ($block->type === Type::T_MEDIA) { + return $this->testWithWithout('media', $with, $without); + } + + if ($block->type === Type::T_DIRECTIVE) { + if (isset($block->name)) { + return $this->testWithWithout($block->name, $with, $without); + } elseif (isset($block->selectors) && preg_match(',@(\w+),ims', json_encode($block->selectors), $m)) { + return $this->testWithWithout($m[1], $with, $without); + } else { + return $this->testWithWithout('???', $with, $without); + } + } + } elseif (isset($block->selectors)) { + // a selector starting with number is a keyframe rule + if (\count($block->selectors)) { + $s = reset($block->selectors); + + while (\is_array($s)) { + $s = reset($s); + } + + if (\is_object($s) && $s instanceof Node\Number) { + return $this->testWithWithout('keyframes', $with, $without); + } + } + + return $this->testWithWithout('rule', $with, $without); } - return false; + return true; + } + + /** + * Test a single type of block against with/without lists + * + * @param string $what + * @param array $with + * @param array $without + * + * @return boolean + * true if the block should be kept, false to reject + */ + protected function testWithWithout($what, $with, $without) + { + + // if without, reject only if in the list (or 'all' is in the list) + if (\count($without)) { + return (isset($without[$what]) || isset($without['all'])) ? false : true; + } + + // otherwise reject all what is not in the with list + return (isset($with[$what]) || isset($with['all'])) ? true : false; } + /** * Compile keyframe block * - * @param \Leafo\ScssPhp\Block $block - * @param array $selectors + * @param \ScssPhp\ScssPhp\Block $block + * @param array $selectors */ protected function compileKeyframeBlock(Block $block, $selectors) { @@ -1005,18 +1417,81 @@ protected function compileKeyframeBlock(Block $block, $selectors) } /** - * Compile nested block + * Compile nested properties lines * - * @param \Leafo\ScssPhp\Block $block - * @param array $selectors + * @param \ScssPhp\ScssPhp\Block $block + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out */ - protected function compileNestedBlock(Block $block, $selectors) + protected function compileNestedPropertiesBlock(Block $block, OutputBlock $out) + { + $prefix = $this->compileValue($block->prefix) . '-'; + + $nested = $this->makeOutputBlock($block->type); + $nested->parent = $out; + + if ($block->hasValue) { + $nested->depth = $out->depth + 1; + } + + $out->children[] = $nested; + + foreach ($block->children as $child) { + switch ($child[0]) { + case Type::T_ASSIGN: + array_unshift($child[1][2], $prefix); + break; + + case Type::T_NESTED_PROPERTY: + array_unshift($child[1]->prefix[2], $prefix); + break; + } + + $this->compileChild($child, $nested); + } + } + + /** + * Compile nested block + * + * @param \ScssPhp\ScssPhp\Block $block + * @param array $selectors + */ + protected function compileNestedBlock(Block $block, $selectors) { $this->pushEnv($block); $this->scope = $this->makeOutputBlock($block->type, $selectors); $this->scope->parent->children[] = $this->scope; + // wrap assign children in a block + // except for @font-face + if ($block->type !== Type::T_DIRECTIVE || $block->name !== "font-face") { + // need wrapping? + $needWrapping = false; + + foreach ($block->children as $child) { + if ($child[0] === Type::T_ASSIGN) { + $needWrapping = true; + break; + } + } + + if ($needWrapping) { + $wrapped = new Block(); + $wrapped->sourceName = $block->sourceName; + $wrapped->sourceIndex = $block->sourceIndex; + $wrapped->sourceLine = $block->sourceLine; + $wrapped->sourceColumn = $block->sourceColumn; + $wrapped->selectors = []; + $wrapped->comments = []; + $wrapped->parent = $block; + $wrapped->children = $block->children; + $wrapped->selfParent = $block->selfParent; + + $block->children = [[Type::T_BLOCK, $wrapped]]; + } + } + $this->compileChildrenNoReturn($block->children, $this->scope); $this->scope = $this->scope->parent; @@ -1040,7 +1515,7 @@ protected function compileNestedBlock(Block $block, $selectors) * * @see Compiler::compileChild() * - * @param \Leafo\ScssPhp\Block $block + * @param \ScssPhp\ScssPhp\Block $block */ protected function compileBlock(Block $block) { @@ -1049,7 +1524,7 @@ protected function compileBlock(Block $block) $out = $this->makeOutputBlock(null); - if (isset($this->lineNumberStyle) && count($env->selectors) && count($block->children)) { + if (isset($this->lineNumberStyle) && \count($env->selectors) && \count($block->children)) { $annotation = $this->makeOutputBlock(Type::T_COMMENT); $annotation->depth = 0; @@ -1075,17 +1550,65 @@ protected function compileBlock(Block $block) $this->scope->children[] = $out; - if (count($block->children)) { - $out->selectors = $this->multiplySelectors($env); + if (\count($block->children)) { + $out->selectors = $this->multiplySelectors($env, $block->selfParent); - $this->compileChildrenNoReturn($block->children, $out); - } + // propagate selfParent to the children where they still can be useful + $selfParentSelectors = null; + + if (isset($block->selfParent->selectors)) { + $selfParentSelectors = $block->selfParent->selectors; + $block->selfParent->selectors = $out->selectors; + } + + $this->compileChildrenNoReturn($block->children, $out, $block->selfParent); - $this->formatter->stripSemicolon($out->lines); + // and revert for the following children of the same block + if ($selfParentSelectors) { + $block->selfParent->selectors = $selfParentSelectors; + } + } $this->popEnv(); } + + /** + * Compile the value of a comment that can have interpolation + * + * @param array $value + * @param boolean $pushEnv + * + * @return array|mixed|string + */ + protected function compileCommentValue($value, $pushEnv = false) + { + $c = $value[1]; + + if (isset($value[2])) { + if ($pushEnv) { + $this->pushEnv(); + } + + $ignoreCallStackMessage = $this->ignoreCallStackMessage; + $this->ignoreCallStackMessage = true; + + try { + $c = $this->compileValue($value[2]); + } catch (\Exception $e) { + // ignore error in comment compilation which are only interpolation + } + + $this->ignoreCallStackMessage = $ignoreCallStackMessage; + + if ($pushEnv) { + $this->popEnv(); + } + } + + return $c; + } + /** * Compile root level comment * @@ -1094,7 +1617,8 @@ protected function compileBlock(Block $block) protected function compileComment($block) { $out = $this->makeOutputBlock(Type::T_COMMENT); - $out->lines[] = $block[1]; + $out->lines[] = $this->compileCommentValue($block, true); + $this->scope->children[] = $out; } @@ -1113,8 +1637,9 @@ protected function evalSelectors($selectors) // after evaluating interpolates, we might need a second pass if ($this->shouldEvaluate) { - $buffer = $this->collapseSelectors($selectors); - $parser = $this->parserFactory(__METHOD__); + $selectors = $this->revertSelfSelector($selectors); + $buffer = $this->collapseSelectors($selectors); + $parser = $this->parserFactory(__METHOD__); if ($parser->parseSelector($buffer, $newSelectors)) { $selectors = array_map([$this, 'evalSelector'], $newSelectors); @@ -1146,14 +1671,14 @@ protected function evalSelector($selector) protected function evalSelectorPart($part) { foreach ($part as &$p) { - if (is_array($p) && ($p[0] === Type::T_INTERPOLATE || $p[0] === Type::T_STRING)) { + if (\is_array($p) && ($p[0] === Type::T_INTERPOLATE || $p[0] === Type::T_STRING)) { $p = $this->compileValue($p); // force re-evaluation if (strpos($p, '&') !== false || strpos($p, ',') !== false) { $this->shouldEvaluate = true; } - } elseif (is_string($p) && strlen($p) >= 2 && + } elseif (\is_string($p) && \strlen($p) >= 2 && ($first = $p[0]) && ($first === '"' || $first === "'") && substr($p, -1) === $first ) { @@ -1167,28 +1692,89 @@ protected function evalSelectorPart($part) /** * Collapse selectors * - * @param array $selectors + * @param array $selectors + * @param boolean $selectorFormat + * if false return a collapsed string + * if true return an array description of a structured selector * * @return string */ - protected function collapseSelectors($selectors) + protected function collapseSelectors($selectors, $selectorFormat = false) { $parts = []; foreach ($selectors as $selector) { - $output = ''; + $output = []; + $glueNext = false; - array_walk_recursive( - $selector, - function ($value, $key) use (&$output) { - $output .= $value; + foreach ($selector as $node) { + $compound = ''; + + array_walk_recursive( + $node, + function ($value, $key) use (&$compound) { + $compound .= $value; + } + ); + + if ($selectorFormat && $this->isImmediateRelationshipCombinator($compound)) { + if (\count($output)) { + $output[\count($output) - 1] .= ' ' . $compound; + } else { + $output[] = $compound; + } + + $glueNext = true; + } elseif ($glueNext) { + $output[\count($output) - 1] .= ' ' . $compound; + $glueNext = false; + } else { + $output[] = $compound; } - ); + } + + if ($selectorFormat) { + foreach ($output as &$o) { + $o = [Type::T_STRING, '', [$o]]; + } + + $output = [Type::T_LIST, ' ', $output]; + } else { + $output = implode(' ', $output); + } $parts[] = $output; } - return implode(', ', $parts); + if ($selectorFormat) { + $parts = [Type::T_LIST, ',', $parts]; + } else { + $parts = implode(', ', $parts); + } + + return $parts; + } + + /** + * Parse down the selector and revert [self] to "&" before a reparsing + * + * @param array $selectors + * + * @return array + */ + protected function revertSelfSelector($selectors) + { + foreach ($selectors as &$part) { + if (\is_array($part)) { + if ($part === [Type::T_SELF]) { + $part = '&'; + } else { + $part = $this->revertSelfSelector($part); + } + } + } + + return $selectors; } /** @@ -1204,17 +1790,17 @@ protected function flattenSelectorSingle($single) foreach ($single as $part) { if (empty($joined) || - ! is_string($part) || + ! \is_string($part) || preg_match('/[\[.:#%]/', $part) ) { $joined[] = $part; continue; } - if (is_array(end($joined))) { + if (\is_array(end($joined))) { $joined[] = $part; } else { - $joined[count($joined) - 1] .= $part; + $joined[\count($joined) - 1] .= $part; } } @@ -1230,7 +1816,7 @@ protected function flattenSelectorSingle($single) */ protected function compileSelector($selector) { - if (! is_array($selector)) { + if (! \is_array($selector)) { return $selector; // media and the like } @@ -1253,7 +1839,7 @@ protected function compileSelector($selector) protected function compileSelectorPart($piece) { foreach ($piece as &$p) { - if (! is_array($p)) { + if (! \is_array($p)) { continue; } @@ -1280,13 +1866,13 @@ protected function compileSelectorPart($piece) */ protected function hasSelectorPlaceholder($selector) { - if (! is_array($selector)) { + if (! \is_array($selector)) { return false; } foreach ($selector as $parts) { foreach ($parts as $part) { - if (strlen($part) && '%' === $part[0]) { + if (\strlen($part) && '%' === $part[0]) { return true; } } @@ -1295,44 +1881,160 @@ protected function hasSelectorPlaceholder($selector) return false; } + protected function pushCallStack($name = '') + { + $this->callStack[] = [ + 'n' => $name, + Parser::SOURCE_INDEX => $this->sourceIndex, + Parser::SOURCE_LINE => $this->sourceLine, + Parser::SOURCE_COLUMN => $this->sourceColumn + ]; + + // infinite calling loop + if (\count($this->callStack) > 25000) { + // not displayed but you can var_dump it to deep debug + $msg = $this->callStackMessage(true, 100); + $msg = "Infinite calling loop"; + + $this->throwError($msg); + } + } + + protected function popCallStack() + { + array_pop($this->callStack); + } + /** * Compile children and return result * - * @param array $stms - * @param \Leafo\ScssPhp\Formatter\OutputBlock $out + * @param array $stms + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out + * @param string $traceName * - * @return array + * @return array|null */ - protected function compileChildren($stms, OutputBlock $out) + protected function compileChildren($stms, OutputBlock $out, $traceName = '') { + $this->pushCallStack($traceName); + foreach ($stms as $stm) { $ret = $this->compileChild($stm, $out); if (isset($ret)) { + $this->popCallStack(); + return $ret; } } + + $this->popCallStack(); + + return null; } /** * Compile children and throw exception if unexpected @return * - * @param array $stms - * @param \Leafo\ScssPhp\Formatter\OutputBlock $out + * @param array $stms + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out + * @param \ScssPhp\ScssPhp\Block $selfParent + * @param string $traceName * * @throws \Exception */ - protected function compileChildrenNoReturn($stms, OutputBlock $out) + protected function compileChildrenNoReturn($stms, OutputBlock $out, $selfParent = null, $traceName = '') { + $this->pushCallStack($traceName); + foreach ($stms as $stm) { - $ret = $this->compileChild($stm, $out); + if ($selfParent && isset($stm[1]) && \is_object($stm[1]) && $stm[1] instanceof Block) { + $stm[1]->selfParent = $selfParent; + $ret = $this->compileChild($stm, $out); + $stm[1]->selfParent = null; + } elseif ($selfParent && \in_array($stm[0], [TYPE::T_INCLUDE, TYPE::T_EXTEND])) { + $stm['selfParent'] = $selfParent; + $ret = $this->compileChild($stm, $out); + unset($stm['selfParent']); + } else { + $ret = $this->compileChild($stm, $out); + } if (isset($ret)) { $this->throwError('@return may only be used within a function'); + $this->popCallStack(); return; } } + + $this->popCallStack(); + } + + + /** + * evaluate media query : compile internal value keeping the structure inchanged + * + * @param array $queryList + * + * @return array + */ + protected function evaluateMediaQuery($queryList) + { + static $parser = null; + + $outQueryList = []; + + foreach ($queryList as $kql => $query) { + $shouldReparse = false; + + foreach ($query as $kq => $q) { + for ($i = 1; $i < \count($q); $i++) { + $value = $this->compileValue($q[$i]); + + // the parser had no mean to know if media type or expression if it was an interpolation + // so you need to reparse if the T_MEDIA_TYPE looks like anything else a media type + if ($q[0] == Type::T_MEDIA_TYPE && + (strpos($value, '(') !== false || + strpos($value, ')') !== false || + strpos($value, ':') !== false || + strpos($value, ',') !== false) + ) { + $shouldReparse = true; + } + + $queryList[$kql][$kq][$i] = [Type::T_KEYWORD, $value]; + } + } + + if ($shouldReparse) { + if (\is_null($parser)) { + $parser = $this->parserFactory(__METHOD__); + } + + $queryString = $this->compileMediaQuery([$queryList[$kql]]); + $queryString = reset($queryString); + + if (strpos($queryString, '@media ') === 0) { + $queryString = substr($queryString, 7); + $queries = []; + + if ($parser->parseMediaQueryList($queryString, $queries)) { + $queries = $this->evaluateMediaQuery($queries[2]); + + while (\count($queries)) { + $outQueryList[] = array_shift($queries); + } + + continue; + } + } + } + + $outQueryList[] = $queryList[$kql]; + } + + return $outQueryList; } /** @@ -1340,31 +2042,76 @@ protected function compileChildrenNoReturn($stms, OutputBlock $out) * * @param array $queryList * - * @return string + * @return array */ protected function compileMediaQuery($queryList) { - $out = '@media'; - $first = true; + $start = '@media '; + $default = trim($start); + $out = []; + $current = ""; foreach ($queryList as $query) { $type = null; $parts = []; + $mediaTypeOnly = true; + + foreach ($query as $q) { + if ($q[0] !== Type::T_MEDIA_TYPE) { + $mediaTypeOnly = false; + break; + } + } + foreach ($query as $q) { switch ($q[0]) { case Type::T_MEDIA_TYPE: - if ($type) { - $type = $this->mergeMediaTypes( - $type, - array_map([$this, 'compileValue'], array_slice($q, 1)) - ); + $newType = array_map([$this, 'compileValue'], \array_slice($q, 1)); - if (empty($type)) { // merge failed - return null; + // combining not and anything else than media type is too risky and should be avoided + if (! $mediaTypeOnly) { + if (\in_array(Type::T_NOT, $newType) || ($type && \in_array(Type::T_NOT, $type) )) { + if ($type) { + array_unshift($parts, implode(' ', array_filter($type))); + } + + if (! empty($parts)) { + if (\strlen($current)) { + $current .= $this->formatter->tagSeparator; + } + + $current .= implode(' and ', $parts); + } + + if ($current) { + $out[] = $start . $current; + } + + $current = ""; + $type = null; + $parts = []; + } + } + + if ($newType === ['all'] && $default) { + $default = $start . 'all'; + } + + // all can be safely ignored and mixed with whatever else + if ($newType !== ['all']) { + if ($type) { + $type = $this->mergeMediaTypes($type, $newType); + + if (empty($type)) { + // merge failed : ignore this query that is not valid, skip to the next one + $parts = []; + $default = ''; // if everything fail, no @media at all + continue 3; + } + } else { + $type = $newType; } - } else { - $type = array_map([$this, 'compileValue'], array_slice($q, 1)); } break; @@ -1393,20 +2140,34 @@ protected function compileMediaQuery($queryList) } if (! empty($parts)) { - if ($first) { - $first = false; - $out .= ' '; - } else { - $out .= $this->formatter->tagSeparator; + if (\strlen($current)) { + $current .= $this->formatter->tagSeparator; } - $out .= implode(' and ', $parts); + $current .= implode(' and ', $parts); } } + if ($current) { + $out[] = $start . $current; + } + + // no @media type except all, and no conflict? + if (! $out && $default) { + $out[] = $default; + } + return $out; } + /** + * Merge direct relationships between selectors + * + * @param array $selectors1 + * @param array $selectors2 + * + * @return array + */ protected function mergeDirectRelationships($selectors1, $selectors2) { if (empty($selectors1) || empty($selectors2)) { @@ -1416,7 +2177,7 @@ protected function mergeDirectRelationships($selectors1, $selectors2) $part1 = end($selectors1); $part2 = end($selectors2); - if (! $this->isImmediateRelationshipCombinator($part1[0]) || $part1 !== $part2) { + if (! $this->isImmediateRelationshipCombinator($part1[0]) && $part1 !== $part2) { return array_merge($selectors1, $selectors2); } @@ -1426,13 +2187,18 @@ protected function mergeDirectRelationships($selectors1, $selectors2) $part1 = array_pop($selectors1); $part2 = array_pop($selectors2); - if ($this->isImmediateRelationshipCombinator($part1[0]) && $part1 !== $part2) { - $merged = array_merge($selectors1, [$part1], $selectors2, [$part2], $merged); + if (! $this->isImmediateRelationshipCombinator($part1[0]) && $part1 !== $part2) { + if ($this->isImmediateRelationshipCombinator(reset($merged)[0])) { + array_unshift($merged, [$part1[0] . $part2[0]]); + $merged = array_merge($selectors1, $selectors2, $merged); + } else { + $merged = array_merge($selectors1, [$part1], $selectors2, [$part2], $merged); + } + break; } array_unshift($merged, $part1); - array_unshift($merged, [array_pop($selectors1)[0] . array_pop($selectors2)[0]]); } while (! empty($selectors1) && ! empty($selectors2)); return $merged; @@ -1456,23 +2222,19 @@ protected function mergeMediaTypes($type1, $type2) return $type1; } - $m1 = ''; - $t1 = ''; - - if (count($type1) > 1) { - $m1= strtolower($type1[0]); - $t1= strtolower($type1[1]); + if (\count($type1) > 1) { + $m1 = strtolower($type1[0]); + $t1 = strtolower($type1[1]); } else { + $m1 = ''; $t1 = strtolower($type1[0]); } - $m2 = ''; - $t2 = ''; - - if (count($type2) > 1) { + if (\count($type2) > 1) { $m2 = strtolower($type2[0]); $t2 = strtolower($type2[1]); } else { + $m2 = ''; $t2 = strtolower($type2[0]); } @@ -1507,19 +2269,19 @@ protected function mergeMediaTypes($type1, $type2) /** * Compile import; returns true if the value was something that could be imported * - * @param array $rawPath - * @param array $out - * @param boolean $once + * @param array $rawPath + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out + * @param boolean $once * * @return boolean */ - protected function compileImport($rawPath, $out, $once = false) + protected function compileImport($rawPath, OutputBlock $out, $once = false) { if ($rawPath[0] === Type::T_STRING) { $path = $this->compileStringContent($rawPath); if ($path = $this->findImport($path)) { - if (! $once || ! in_array($path, $this->importedFiles)) { + if (! $once || ! \in_array($path, $this->importedFiles)) { $this->importFile($path, $out); $this->importedFiles[] = $path; } @@ -1527,68 +2289,171 @@ protected function compileImport($rawPath, $out, $once = false) return true; } + $this->appendRootDirective('@import ' . $this->compileValue($rawPath). ';', $out); + return false; } if ($rawPath[0] === Type::T_LIST) { // handle a list of strings - if (count($rawPath[2]) === 0) { + if (\count($rawPath[2]) === 0) { return false; } foreach ($rawPath[2] as $path) { if ($path[0] !== Type::T_STRING) { + $this->appendRootDirective('@import ' . $this->compileValue($rawPath) . ';', $out); + return false; } } foreach ($rawPath[2] as $path) { - $this->compileImport($path, $out); + $this->compileImport($path, $out, $once); } return true; } + $this->appendRootDirective('@import ' . $this->compileValue($rawPath) . ';', $out); + return false; } + + /** + * Append a root directive like @import or @charset as near as the possible from the source code + * (keeping before comments, @import and @charset coming before in the source code) + * + * @param string $line + * @param @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out + * @param array $allowed + */ + protected function appendRootDirective($line, $out, $allowed = [Type::T_COMMENT]) + { + $root = $out; + + while ($root->parent) { + $root = $root->parent; + } + + $i = 0; + + while ($i < \count($root->children)) { + if (! isset($root->children[$i]->type) || ! \in_array($root->children[$i]->type, $allowed)) { + break; + } + + $i++; + } + + // remove incompatible children from the bottom of the list + $saveChildren = []; + + while ($i < \count($root->children)) { + $saveChildren[] = array_pop($root->children); + } + + // insert the directive as a comment + $child = $this->makeOutputBlock(Type::T_COMMENT); + $child->lines[] = $line; + $child->sourceName = $this->sourceNames[$this->sourceIndex]; + $child->sourceLine = $this->sourceLine; + $child->sourceColumn = $this->sourceColumn; + + $root->children[] = $child; + + // repush children + while (\count($saveChildren)) { + $root->children[] = array_pop($saveChildren); + } + } + + /** + * Append lines to the current output block: + * directly to the block or through a child if necessary + * + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out + * @param string $type + * @param string|mixed $line + */ + protected function appendOutputLine(OutputBlock $out, $type, $line) + { + $outWrite = &$out; + + if ($type === Type::T_COMMENT) { + $parent = $out->parent; + + if (end($parent->children) !== $out) { + $outWrite = &$parent->children[\count($parent->children) - 1]; + } + } + + // check if it's a flat output or not + if (\count($out->children)) { + $lastChild = &$out->children[\count($out->children) - 1]; + + if ($lastChild->depth === $out->depth && + \is_null($lastChild->selectors) && + ! \count($lastChild->children) + ) { + $outWrite = $lastChild; + } else { + $nextLines = $this->makeOutputBlock($type); + $nextLines->parent = $out; + $nextLines->depth = $out->depth; + + $out->children[] = $nextLines; + $outWrite = &$nextLines; + } + } + + $outWrite->lines[] = $line; + } + /** * Compile child; returns a value to halt execution * - * @param array $child - * @param \Leafo\ScssPhp\Formatter\OutputBlock $out + * @param array $child + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out * * @return array */ protected function compileChild($child, OutputBlock $out) { - $this->sourceIndex = isset($child[Parser::SOURCE_INDEX]) ? $child[Parser::SOURCE_INDEX] : null; - $this->sourceLine = isset($child[Parser::SOURCE_LINE]) ? $child[Parser::SOURCE_LINE] : -1; - $this->sourceColumn = isset($child[Parser::SOURCE_COLUMN]) ? $child[Parser::SOURCE_COLUMN] : -1; + if (isset($child[Parser::SOURCE_LINE])) { + $this->sourceIndex = isset($child[Parser::SOURCE_INDEX]) ? $child[Parser::SOURCE_INDEX] : null; + $this->sourceLine = isset($child[Parser::SOURCE_LINE]) ? $child[Parser::SOURCE_LINE] : -1; + $this->sourceColumn = isset($child[Parser::SOURCE_COLUMN]) ? $child[Parser::SOURCE_COLUMN] : -1; + } elseif (\is_array($child) && isset($child[1]->sourceLine)) { + $this->sourceIndex = $child[1]->sourceIndex; + $this->sourceLine = $child[1]->sourceLine; + $this->sourceColumn = $child[1]->sourceColumn; + } elseif (! empty($out->sourceLine) && ! empty($out->sourceName)) { + $this->sourceLine = $out->sourceLine; + $this->sourceIndex = array_search($out->sourceName, $this->sourceNames); + $this->sourceColumn = $out->sourceColumn; + + if ($this->sourceIndex === false) { + $this->sourceIndex = null; + } + } switch ($child[0]) { case Type::T_SCSSPHP_IMPORT_ONCE: - list(, $rawPath) = $child; - - $rawPath = $this->reduce($rawPath); + $rawPath = $this->reduce($child[1]); - if (! $this->compileImport($rawPath, $out, true)) { - $out->lines[] = '@import ' . $this->compileValue($rawPath) . ';'; - } + $this->compileImport($rawPath, $out, true); break; case Type::T_IMPORT: - list(, $rawPath) = $child; - - $rawPath = $this->reduce($rawPath); + $rawPath = $this->reduce($child[1]); - if (! $this->compileImport($rawPath, $out)) { - $out->lines[] = '@import ' . $this->compileValue($rawPath) . ';'; - } + $this->compileImport($rawPath, $out); break; case Type::T_DIRECTIVE: - $this->compileDirective($child[1]); + $this->compileDirective($child[1], $out); break; case Type::T_AT_ROOT: @@ -1606,44 +2471,130 @@ protected function compileChild($child, OutputBlock $out) case Type::T_CHARSET: if (! $this->charsetSeen) { $this->charsetSeen = true; - - $out->lines[] = '@charset ' . $this->compileValue($child[1]) . ';'; + $this->appendRootDirective('@charset ' . $this->compileValue($child[1]) . ';', $out); } break; - case Type::T_ASSIGN: + case Type::T_CUSTOM_PROPERTY: list(, $name, $value) = $child; + $compiledName = $this->compileValue($name); - if ($name[0] === Type::T_VARIABLE) { - $flags = isset($child[3]) ? $child[3] : []; - $isDefault = in_array('!default', $flags); - $isGlobal = in_array('!global', $flags); + // if the value reduces to null from something else then + // the property should be discarded + if ($value[0] !== Type::T_NULL) { + $value = $this->reduce($value); - if ($isGlobal) { - $this->set($name[1], $this->reduce($value), false, $this->rootEnv); + if ($value[0] === Type::T_NULL || $value === static::$nullString) { break; } + } - $shouldSet = $isDefault && - (($result = $this->get($name[1], false)) === null - || $result === static::$null); + $compiledValue = $this->compileValue($value); - if (! $isDefault || $shouldSet) { - $this->set($name[1], $this->reduce($value)); - } + $line = $this->formatter->customProperty( + $compiledName, + $compiledValue + ); + + $this->appendOutputLine($out, Type::T_ASSIGN, $line); + break; + + case Type::T_ASSIGN: + list(, $name, $value) = $child; + + if ($name[0] === Type::T_VARIABLE) { + $flags = isset($child[3]) ? $child[3] : []; + $isDefault = \in_array('!default', $flags); + $isGlobal = \in_array('!global', $flags); + + if ($isGlobal) { + $this->set($name[1], $this->reduce($value), false, $this->rootEnv, $value); + break; + } + + $shouldSet = $isDefault && + (\is_null($result = $this->get($name[1], false)) || + $result === static::$null); + + if (! $isDefault || $shouldSet) { + $this->set($name[1], $this->reduce($value), true, null, $value); + } break; } $compiledName = $this->compileValue($name); - // handle shorthand syntax: size / line-height - if ($compiledName === 'font') { - if ($value[0] === Type::T_EXPRESSION && $value[1] === '/') { - $value = $this->expToString($value); - } elseif ($value[0] === Type::T_LIST) { - foreach ($value[2] as &$item) { + // handle shorthand syntaxes : size / line-height... + if (\in_array($compiledName, ['font', 'grid-row', 'grid-column', 'border-radius'])) { + if ($value[0] === Type::T_VARIABLE) { + // if the font value comes from variable, the content is already reduced + // (i.e., formulas were already calculated), so we need the original unreduced value + $value = $this->get($value[1], true, null, true); + } + + $shorthandValue=&$value; + + $shorthandDividerNeedsUnit = false; + $maxListElements = null; + $maxShorthandDividers = 1; + + switch ($compiledName) { + case 'border-radius': + $maxListElements = 4; + $shorthandDividerNeedsUnit = true; + break; + } + + if ($compiledName === 'font' and $value[0] === Type::T_LIST && $value[1]==',') { + // this is the case if more than one font is given: example: "font: 400 1em/1.3 arial,helvetica" + // we need to handle the first list element + $shorthandValue=&$value[2][0]; + } + + if ($shorthandValue[0] === Type::T_EXPRESSION && $shorthandValue[1] === '/') { + $revert = true; + + if ($shorthandDividerNeedsUnit) { + $divider = $shorthandValue[3]; + + if (\is_array($divider)) { + $divider = $this->reduce($divider, true); + } + + if (\intval($divider->dimension) and ! \count($divider->units)) { + $revert = false; + } + } + + if ($revert) { + $shorthandValue = $this->expToString($shorthandValue); + } + } elseif ($shorthandValue[0] === Type::T_LIST) { + foreach ($shorthandValue[2] as &$item) { if ($item[0] === Type::T_EXPRESSION && $item[1] === '/') { - $item = $this->expToString($item); + if ($maxShorthandDividers > 0) { + $revert = true; + // if the list of values is too long, this has to be a shorthand, + // otherwise it could be a real division + if (\is_null($maxListElements) or \count($shorthandValue[2]) <= $maxListElements) { + if ($shorthandDividerNeedsUnit) { + $divider = $item[3]; + + if (\is_array($divider)) { + $divider = $this->reduce($divider, true); + } + + if (\intval($divider->dimension) and ! \count($divider->units)) { + $revert = false; + } + } + } + + if ($revert) { + $item = $this->expToString($item); + $maxShorthandDividers--; + } + } } } } @@ -1661,10 +2612,14 @@ protected function compileChild($child, OutputBlock $out) $compiledValue = $this->compileValue($value); - $out->lines[] = $this->formatter->property( - $compiledName, - $compiledValue - ); + // ignore empty value + if (\strlen($compiledValue)) { + $line = $this->formatter->property( + $compiledName, + $compiledValue + ); + $this->appendOutputLine($out, Type::T_ASSIGN, $line); + } break; case Type::T_COMMENT: @@ -1673,27 +2628,32 @@ protected function compileChild($child, OutputBlock $out) break; } - $out->lines[] = $child[1]; + $line = $this->compileCommentValue($child, true); + $this->appendOutputLine($out, Type::T_COMMENT, $line); break; case Type::T_MIXIN: case Type::T_FUNCTION: list(, $block) = $child; - - $this->set(static::$namespaces[$block->type] . $block->name, $block); + // the block need to be able to go up to it's parent env to resolve vars + $block->parentEnv = $this->getStoreEnv(); + $this->set(static::$namespaces[$block->type] . $block->name, $block, true); break; case Type::T_EXTEND: - list(, $selectors) = $child; - - foreach ($selectors as $sel) { + foreach ($child[1] as $sel) { $results = $this->evalSelectors([$sel]); foreach ($results as $result) { // only use the first one $result = current($result); + $selectors = $out->selectors; - $this->pushExtends($result, $out->selectors, $child); + if (! $selectors && isset($child['selfParent'])) { + $selectors = $this->multiplySelectors($this->env, $child['selfParent']); + } + + $this->pushExtends($result, $selectors, $child); } } break; @@ -1717,12 +2677,12 @@ protected function compileChild($child, OutputBlock $out) case Type::T_EACH: list(, $each) = $child; - $list = $this->coerceList($this->reduce($each->list)); + $list = $this->coerceList($this->reduce($each->list), ',', true); $this->pushEnv(); foreach ($list[2] as $item) { - if (count($each->vars) === 1) { + if (\count($each->vars) === 1) { $this->set($each->vars[0], $item, true); } else { list(,, $values) = $this->coerceList($item); @@ -1736,7 +2696,9 @@ protected function compileChild($child, OutputBlock $out) if ($ret) { if ($ret[0] !== Type::T_CONTROL) { + $store = $this->env->store; $this->popEnv(); + $this->backPropagateEnv($store, $each->vars); return $ret; } @@ -1746,8 +2708,10 @@ protected function compileChild($child, OutputBlock $out) } } } - + $store = $this->env->store; $this->popEnv(); + $this->backPropagateEnv($store, $each->vars); + break; case Type::T_WHILE: @@ -1786,6 +2750,8 @@ protected function compileChild($child, OutputBlock $out) $d = $start < $end ? 1 : -1; + $this->pushEnv(); + for (;;) { if ((! $for->until && $start - $d == $end) || ($for->until && $start == $end) @@ -1800,6 +2766,9 @@ protected function compileChild($child, OutputBlock $out) if ($ret) { if ($ret[0] !== Type::T_CONTROL) { + $store = $this->env->store; + $this->popEnv(); + $this->backPropagateEnv($store, [$for->var]); return $ret; } @@ -1808,6 +2777,11 @@ protected function compileChild($child, OutputBlock $out) } } } + + $store = $this->env->store; + $this->popEnv(); + $this->backPropagateEnv($store, [$for->var]); + break; case Type::T_BREAK: @@ -1820,31 +2794,12 @@ protected function compileChild($child, OutputBlock $out) return $this->reduce($child[1], true); case Type::T_NESTED_PROPERTY: - list(, $prop) = $child; - - $prefixed = []; - $prefix = $this->compileValue($prop->prefix) . '-'; - - foreach ($prop->children as $child) { - switch ($child[0]) { - case Type::T_ASSIGN: - array_unshift($child[1][2], $prefix); - break; - - case Type::T_NESTED_PROPERTY: - array_unshift($child[1]->prefix[2], $prefix); - break; - } - - $prefixed[] = $child; - } - - $this->compileChildrenNoReturn($prefixed, $out); + $this->compileNestedPropertiesBlock($child[1], $out); break; case Type::T_INCLUDE: // including a mixin - list(, $name, $argValues, $content) = $child; + list(, $name, $argValues, $content, $argUsing) = $child; $mixin = $this->get(static::$namespaces['mixin'] . $name, false); @@ -1859,13 +2814,43 @@ protected function compileChild($child, OutputBlock $out) $this->pushEnv(); $this->env->depth--; - $storeEnv = $this->storeEnv; - $this->storeEnv = $this->env; + // Find the parent selectors in the env to be able to know what '&' refers to in the mixin + // and assign this fake parent to childs + $selfParent = null; + if (isset($child['selfParent']) && isset($child['selfParent']->selectors)) { + $selfParent = $child['selfParent']; + } else { + $parentSelectors = $this->multiplySelectors($this->env); + + if ($parentSelectors) { + $parent = new Block(); + $parent->selectors = $parentSelectors; + + foreach ($mixin->children as $k => $child) { + if (isset($child[1]) && \is_object($child[1]) && $child[1] instanceof Block) { + $mixin->children[$k][1]->parent = $parent; + } + } + } + } + + // clone the stored content to not have its scope spoiled by a further call to the same mixin + // i.e., recursive @include of the same mixin if (isset($content)) { - $content->scope = $callingScope; + $copyContent = clone $content; + $copyContent->scope = clone $callingScope; - $this->setRaw(static::$namespaces['special'] . 'content', $content, $this->env); + $this->setRaw(static::$namespaces['special'] . 'content', $copyContent, $this->env); + } else { + $this->setRaw(static::$namespaces['special'] . 'content', null, $this->env); + } + + // save the "using" argument list for applying it to when "@content" is invoked + if (isset($argUsing)) { + $this->setRaw(static::$namespaces['special'] . 'using', $argUsing, $this->env); + } else { + $this->setRaw(static::$namespaces['special'] . 'using', null, $this->env); } if (isset($mixin->args)) { @@ -1874,27 +2859,44 @@ protected function compileChild($child, OutputBlock $out) $this->env->marker = 'mixin'; - $this->compileChildrenNoReturn($mixin->children, $out); + if (! empty($mixin->parentEnv)) { + $this->env->declarationScopeParent = $mixin->parentEnv; + } else { + $this->throwError("@mixin $name() without parentEnv"); + } - $this->storeEnv = $storeEnv; + $this->compileChildrenNoReturn($mixin->children, $out, $selfParent, $this->env->marker . " " . $name); $this->popEnv(); break; case Type::T_MIXIN_CONTENT: - $content = $this->get(static::$namespaces['special'] . 'content', false, $this->getStoreEnv()) - ?: $this->get(static::$namespaces['special'] . 'content', false, $this->env); + $env = isset($this->storeEnv) ? $this->storeEnv : $this->env; + $content = $this->get(static::$namespaces['special'] . 'content', false, $env); + $argUsing = $this->get(static::$namespaces['special'] . 'using', false, $env); + $argContent = $child[1]; if (! $content) { - $content = new \stdClass(); - $content->scope = new \stdClass(); - $content->children = $this->storeEnv->parent->block->children; break; } $storeEnv = $this->storeEnv; + $varsUsing = []; + + if (isset($argUsing) && isset($argContent)) { + // Get the arguments provided for the content with the names provided in the "using" argument list + $this->storeEnv = null; + $varsUsing = $this->applyArguments($argUsing, $argContent, false); + } + + // restore the scope from the @content $this->storeEnv = $content->scope; + // append the vars from using if any + foreach ($varsUsing as $name => $val) { + $this->set($name, $val, true, $this->storeEnv); + } + $this->compileChildrenNoReturn($content->children, $out); $this->storeEnv = $storeEnv; @@ -1903,25 +2905,31 @@ protected function compileChild($child, OutputBlock $out) case Type::T_DEBUG: list(, $value) = $child; - $line = $this->sourceLine; + $fname = $this->sourceNames[$this->sourceIndex]; + $line = $this->sourceLine; $value = $this->compileValue($this->reduce($value, true)); - fwrite($this->stderr, "Line $line DEBUG: $value\n"); + + fwrite($this->stderr, "File $fname on line $line DEBUG: $value\n"); break; case Type::T_WARN: list(, $value) = $child; - $line = $this->sourceLine; + $fname = $this->sourceNames[$this->sourceIndex]; + $line = $this->sourceLine; $value = $this->compileValue($this->reduce($value, true)); - fwrite($this->stderr, "Line $line WARN: $value\n"); + + fwrite($this->stderr, "File $fname on line $line WARN: $value\n"); break; case Type::T_ERROR: list(, $value) = $child; - $line = $this->sourceLine; + $fname = $this->sourceNames[$this->sourceIndex]; + $line = $this->sourceLine; $value = $this->compileValue($this->reduce($value, true)); - $this->throwError("Line $line ERROR: $value\n"); + + $this->throwError("File $fname on line $line ERROR: $value\n"); break; case Type::T_CONTROL: @@ -1966,7 +2974,7 @@ protected function expToString($exp) * * @param array $value * - * @return array + * @return boolean */ protected function isTruthy($value) { @@ -1997,7 +3005,7 @@ protected function shouldEval($value) switch ($value[0]) { case Type::T_EXPRESSION: if ($value[1] === '/') { - return $this->shouldEval($value[2], $value[3]); + return $this->shouldEval($value[2]) || $this->shouldEval($value[3]); } // fall-thru @@ -2015,13 +3023,15 @@ protected function shouldEval($value) * @param array $value * @param boolean $inExp * - * @return array|\Leafo\ScssPhp\Node\Number + * @return null|string|array|\ScssPhp\ScssPhp\Node\Number */ protected function reduce($value, $inExp = false) { - list($type) = $value; + if (\is_null($value)) { + return null; + } - switch ($type) { + switch ($value[0]) { case Type::T_EXPRESSION: list(, $op, $left, $right, $inParens) = $value; @@ -2035,16 +3045,15 @@ protected function reduce($value, $inExp = false) } // special case: looks like css shorthand - if ($opName == 'div' && ! $inParens && ! $inExp && isset($right[2]) - && (($right[0] !== Type::T_NUMBER && $right[2] != '') - || ($right[0] === Type::T_NUMBER && ! $right->unitless())) + if ($opName == 'div' && ! $inParens && ! $inExp && isset($right[2]) && + (($right[0] !== Type::T_NUMBER && $right[2] != '') || + ($right[0] === Type::T_NUMBER && ! $right->unitless())) ) { return $this->expToString($value); } - $left = $this->coerceForExpression($left); + $left = $this->coerceForExpression($left); $right = $this->coerceForExpression($right); - $ltype = $left[0]; $rtype = $right[0]; @@ -2058,12 +3067,12 @@ protected function reduce($value, $inExp = false) // 3. op[op name] $fn = "op${ucOpName}${ucLType}${ucRType}"; - if (is_callable([$this, $fn]) || + if (\is_callable([$this, $fn]) || (($fn = "op${ucLType}${ucRType}") && - is_callable([$this, $fn]) && + \is_callable([$this, $fn]) && $passOp = true) || (($fn = "op${ucOpName}") && - is_callable([$this, $fn]) && + \is_callable([$this, $fn]) && $genOp = true) ) { $coerceUnit = false; @@ -2098,9 +3107,14 @@ protected function reduce($value, $inExp = false) $targetUnit = $left->unitless() ? $right[2] : $left[2]; } - if (! $left->unitless() && ! $right->unitless()) { + $baseUnitLeft = $left->isNormalizable(); + $baseUnitRight = $right->isNormalizable(); + + if ($baseUnitLeft && $baseUnitRight && $baseUnitLeft === $baseUnitRight) { $left = $left->normalize(); $right = $right->normalize(); + } elseif ($coerceUnit) { + $left = new Node\Number($left[1], []); } } @@ -2154,9 +3168,7 @@ protected function reduce($value, $inExp = false) return [Type::T_STRING, '', [$op, $exp]]; case Type::T_VARIABLE: - list(, $name) = $value; - - return $this->reduce($this->get($name)); + return $this->reduce($this->get($value[1])); case Type::T_LIST: foreach ($value[2] as &$item) { @@ -2178,7 +3190,7 @@ protected function reduce($value, $inExp = false) case Type::T_STRING: foreach ($value[2] as &$item) { - if (is_array($item) || $item instanceof \ArrayAccess) { + if (\is_array($item) || $item instanceof \ArrayAccess) { $item = $this->reduce($item); } } @@ -2188,12 +3200,21 @@ protected function reduce($value, $inExp = false) case Type::T_INTERPOLATE: $value[1] = $this->reduce($value[1]); + if ($inExp) { + return $value[1]; + } + return $value; case Type::T_FUNCTION_CALL: - list(, $name, $argValues) = $value; + return $this->fncall($value[1], $value[2]); + + case Type::T_SELF: + $selfParent = ! empty($this->env->block->selfParent) ? $this->env->block->selfParent : null; + $selfSelector = $this->multiplySelectors($this->env, $selfParent); + $selfSelector = $this->collapseSelectors($selfSelector, true); - return $this->fncall($name, $argValues); + return $selfSelector; default: return $value; @@ -2208,7 +3229,7 @@ protected function reduce($value, $inExp = false) * * @return array|null */ - private function fncall($name, $argValues) + protected function fncall($name, $argValues) { // SCSS @function if ($this->callScssFunction($name, $argValues, $returnValue)) { @@ -2254,9 +3275,8 @@ protected function normalizeName($name) public function normalizeValue($value) { $value = $this->coerceForExpression($this->reduce($value)); - list($type) = $value; - switch ($type) { + switch ($value[0]) { case Type::T_LIST: $value = $this->extractInterpolation($value); @@ -2268,10 +3288,14 @@ public function normalizeValue($value) $value[2][$key] = $this->normalizeValue($item); } + if (! empty($value['enclosing'])) { + unset($value['enclosing']); + } + return $value; case Type::T_STRING: - return [$type, '"', [$this->compileStringContent($value)]]; + return [$value[0], '"', [$this->compileStringContent($value)]]; case Type::T_NUMBER: return $value->normalize(); @@ -2290,7 +3314,7 @@ public function normalizeValue($value) * @param array $left * @param array $right * - * @return \Leafo\ScssPhp\Node\Number + * @return \ScssPhp\ScssPhp\Node\Number */ protected function opAddNumberNumber($left, $right) { @@ -2303,7 +3327,7 @@ protected function opAddNumberNumber($left, $right) * @param array $left * @param array $right * - * @return \Leafo\ScssPhp\Node\Number + * @return \ScssPhp\ScssPhp\Node\Number */ protected function opMulNumberNumber($left, $right) { @@ -2316,7 +3340,7 @@ protected function opMulNumberNumber($left, $right) * @param array $left * @param array $right * - * @return \Leafo\ScssPhp\Node\Number + * @return \ScssPhp\ScssPhp\Node\Number */ protected function opSubNumberNumber($left, $right) { @@ -2329,12 +3353,12 @@ protected function opSubNumberNumber($left, $right) * @param array $left * @param array $right * - * @return array|\Leafo\ScssPhp\Node\Number + * @return array|\ScssPhp\ScssPhp\Node\Number */ protected function opDivNumberNumber($left, $right) { if ($right[1] == 0) { - return [Type::T_STRING, '', [$left[1] . $left[2] . '/' . $right[1] . $right[2]]]; + return ($left[1] == 0) ? static::$NaN : static::$Infinity; } return new Node\Number($left[1] / $right[1], $left[2]); @@ -2346,10 +3370,14 @@ protected function opDivNumberNumber($left, $right) * @param array $left * @param array $right * - * @return \Leafo\ScssPhp\Node\Number + * @return \ScssPhp\ScssPhp\Node\Number */ protected function opModNumberNumber($left, $right) { + if ($right[1] == 0) { + return static::$NaN; + } + return new Node\Number($left[1] % $right[1], $left[2]); } @@ -2359,7 +3387,7 @@ protected function opModNumberNumber($left, $right) * @param array $left * @param array $right * - * @return array + * @return array|null */ protected function opAdd($left, $right) { @@ -2382,6 +3410,8 @@ protected function opAdd($left, $right) return $strRight; } + + return null; } /** @@ -2391,15 +3421,21 @@ protected function opAdd($left, $right) * @param array $right * @param boolean $shouldEval * - * @return array + * @return array|null */ protected function opAnd($left, $right, $shouldEval) { + $truthy = ($left === static::$null || $right === static::$null) || + ($left === static::$false || $left === static::$true) && + ($right === static::$false || $right === static::$true); + if (! $shouldEval) { - return; + if (! $truthy) { + return null; + } } - if ($left !== static::$false and $left !== static::$null) { + if ($left !== static::$false && $left !== static::$null) { return $this->reduce($right, true); } @@ -2413,15 +3449,21 @@ protected function opAnd($left, $right, $shouldEval) * @param array $right * @param boolean $shouldEval * - * @return array + * @return array|null */ protected function opOr($left, $right, $shouldEval) { + $truthy = ($left === static::$null || $right === static::$null) || + ($left === static::$false || $left === static::$true) && + ($right === static::$false || $right === static::$true); + if (! $shouldEval) { - return; + if (! $truthy) { + return null; + } } - if ($left !== static::$false and $left !== static::$null) { + if ($left !== static::$false && $left !== static::$null) { return $left; } @@ -2632,7 +3674,7 @@ protected function opLtNumberNumber($left, $right) * @param array $left * @param array $right * - * @return \Leafo\ScssPhp\Node\Number + * @return \ScssPhp\ScssPhp\Node\Number */ protected function opCmpNumberNumber($left, $right) { @@ -2670,15 +3712,13 @@ public function toBool($thing) * * @param array $value * - * @return string + * @return string|array */ public function compileValue($value) { $value = $this->reduce($value); - list($type) = $value; - - switch ($type) { + switch ($value[0]) { case Type::T_KEYWORD: return $value[1]; @@ -2689,12 +3729,38 @@ public function compileValue($value) // [4] - optional alpha component list(, $r, $g, $b) = $value; - $r = round($r); - $g = round($g); - $b = round($b); + $r = $this->compileRGBAValue($r); + $g = $this->compileRGBAValue($g); + $b = $this->compileRGBAValue($b); + + if (\count($value) === 5) { + $alpha = $this->compileRGBAValue($value[4], true); + + if (! is_numeric($alpha) || $alpha < 1) { + $colorName = Colors::RGBaToColorName($r, $g, $b, $alpha); + + if (! \is_null($colorName)) { + return $colorName; + } + + if (is_numeric($alpha)) { + $a = new Node\Number($alpha, ''); + } else { + $a = $alpha; + } + + return 'rgba(' . $r . ', ' . $g . ', ' . $b . ', ' . $a . ')'; + } + } + + if (! is_numeric($r) || ! is_numeric($g) || ! is_numeric($b)) { + return 'rgb(' . $r . ', ' . $g . ', ' . $b . ')'; + } + + $colorName = Colors::RGBaToColorName($r, $g, $b); - if (count($value) === 5 && $value[4] !== 1) { // rgba - return 'rgba(' . $r . ', ' . $g . ', ' . $b . ', ' . $value[4] . ')'; + if (! \is_null($colorName)) { + return $colorName; } $h = sprintf('#%02x%02x%02x', $r, $g, $b); @@ -2725,9 +3791,29 @@ public function compileValue($value) } list(, $delim, $items) = $value; + $pre = $post = ""; + if (! empty($value['enclosing'])) { + switch ($value['enclosing']) { + case 'parent': + //$pre = "("; + //$post = ")"; + break; + case 'forced_parent': + $pre = "("; + $post = ")"; + break; + case 'bracket': + case 'forced_bracket': + $pre = "["; + $post = "]"; + break; + } + } + + $prefix_value = ''; if ($delim !== ' ') { - $delim .= ' '; + $prefix_value = ' '; } $filtered = []; @@ -2737,17 +3823,21 @@ public function compileValue($value) continue; } - $filtered[] = $this->compileValue($item); + $compiled = $this->compileValue($item); + if ($prefix_value && \strlen($compiled)) { + $compiled = $prefix_value . $compiled; + } + $filtered[] = $compiled; } - return implode("$delim", $filtered); + return $pre . substr(implode("$delim", $filtered), \strlen($prefix_value)) . $post; case Type::T_MAP: - $keys = $value[1]; - $values = $value[2]; + $keys = $value[1]; + $values = $value[2]; $filtered = []; - for ($i = 0, $s = count($keys); $i < $s; $i++) { + for ($i = 0, $s = \count($keys); $i < $s; $i++) { $filtered[$this->compileValue($keys[$i])] = $this->compileValue($values[$i]); } @@ -2762,20 +3852,29 @@ public function compileValue($value) list(, $interpolate, $left, $right) = $value; list(,, $whiteLeft, $whiteRight) = $interpolate; - $left = count($left[2]) > 0 ? - $this->compileValue($left) . $whiteLeft : ''; + $delim = $left[1]; - $right = count($right[2]) > 0 ? - $whiteRight . $this->compileValue($right) : ''; + if ($delim && $delim !== ' ' && ! $whiteLeft) { + $delim .= ' '; + } + + $left = \count($left[2]) > 0 ? + $this->compileValue($left) . $delim . $whiteLeft: ''; + + $delim = $right[1]; + + if ($delim && $delim !== ' ') { + $delim .= ' '; + } + + $right = \count($right[2]) > 0 ? + $whiteRight . $delim . $this->compileValue($right) : ''; return $left . $this->compileValue($interpolate) . $right; case Type::T_INTERPOLATE: - // raw parse node - list(, $exp) = $value; - // strip quotes if it's a string - $reduced = $this->reduce($exp); + $reduced = $this->reduce($value[1]); switch ($reduced[0]) { case Type::T_LIST: @@ -2799,6 +3898,7 @@ public function compileValue($value) } $temp = $this->compileValue([Type::T_KEYWORD, $item]); + if ($temp[0] === Type::T_STRING) { $filtered[] = $this->compileStringContent($temp); } elseif ($temp[0] === Type::T_KEYWORD) { @@ -2824,8 +3924,11 @@ public function compileValue($value) case Type::T_NULL: return 'null'; + case Type::T_COMMENT: + return $this->compileCommentValue($value); + default: - $this->throwError("unknown value type: $type"); + $this->throwError("unknown value type: ".json_encode($value)); } } @@ -2853,7 +3956,7 @@ protected function compileStringContent($string) $parts = []; foreach ($string[2] as $part) { - if (is_array($part) || $part instanceof \ArrayAccess) { + if (\is_array($part) || $part instanceof \ArrayAccess) { $parts[] = $this->compileValue($part); } else { $parts[] = $part; @@ -2876,8 +3979,8 @@ protected function extractInterpolation($list) foreach ($items as $i => $item) { if ($item[0] === Type::T_INTERPOLATE) { - $before = [Type::T_LIST, $list[1], array_slice($items, 0, $i)]; - $after = [Type::T_LIST, $list[1], array_slice($items, $i + 1)]; + $before = [Type::T_LIST, $list[1], \array_slice($items, 0, $i)]; + $after = [Type::T_LIST, $list[1], \array_slice($items, $i + 1)]; return [Type::T_INTERPOLATED, $item, $before, $after]; } @@ -2889,44 +3992,75 @@ protected function extractInterpolation($list) /** * Find the final set of selectors * - * @param \Leafo\ScssPhp\Compiler\Environment $env + * @param \ScssPhp\ScssPhp\Compiler\Environment $env + * @param \ScssPhp\ScssPhp\Block $selfParent * * @return array */ - protected function multiplySelectors(Environment $env) + protected function multiplySelectors(Environment $env, $selfParent = null) { $envs = $this->compactEnv($env); $selectors = []; $parentSelectors = [[]]; + $selfParentSelectors = null; + + if (! \is_null($selfParent) && $selfParent->selectors) { + $selfParentSelectors = $this->evalSelectors($selfParent->selectors); + } + while ($env = array_pop($envs)) { if (empty($env->selectors)) { continue; } - $selectors = []; + $selectors = $env->selectors; - foreach ($env->selectors as $selector) { - foreach ($parentSelectors as $parent) { - $selectors[] = $this->joinSelectors($parent, $selector); + do { + $stillHasSelf = false; + $prevSelectors = $selectors; + $selectors = []; + + foreach ($prevSelectors as $selector) { + foreach ($parentSelectors as $parent) { + if ($selfParentSelectors) { + foreach ($selfParentSelectors as $selfParent) { + // if no '&' in the selector, each call will give same result, only add once + $s = $this->joinSelectors($parent, $selector, $stillHasSelf, $selfParent); + $selectors[serialize($s)] = $s; + } + } else { + $s = $this->joinSelectors($parent, $selector, $stillHasSelf); + $selectors[serialize($s)] = $s; + } + } } - } + } while ($stillHasSelf); $parentSelectors = $selectors; } + $selectors = array_values($selectors); + + // case we are just starting a at-root : nothing to multiply but parentSelectors + if (!$selectors and $selfParentSelectors) { + $selectors = $selfParentSelectors; + } + return $selectors; } /** * Join selectors; looks for & to replace, or append parent before child * - * @param array $parent - * @param array $child - * + * @param array $parent + * @param array $child + * @param boolean $stillHasSelf + * @param array $selfParentSelectors + * @return array */ - protected function joinSelectors($parent, $child) + protected function joinSelectors($parent, $child, &$stillHasSelf, $selfParentSelectors = null) { $setSelf = false; $out = []; @@ -2935,16 +4069,35 @@ protected function joinSelectors($parent, $child) $newPart = []; foreach ($part as $p) { - if ($p === static::$selfSelector) { + // only replace & once and should be recalled to be able to make combinations + if ($p === static::$selfSelector && $setSelf) { + $stillHasSelf = true; + } + + if ($p === static::$selfSelector && ! $setSelf) { $setSelf = true; - foreach ($parent as $i => $parentPart) { + if (\is_null($selfParentSelectors)) { + $selfParentSelectors = $parent; + } + + foreach ($selfParentSelectors as $i => $parentPart) { if ($i > 0) { $out[] = $newPart; $newPart = []; } foreach ($parentPart as $pp) { + if (\is_array($pp)) { + $flatten = []; + + array_walk_recursive($pp, function ($a) use (&$flatten) { + $flatten[] = $a; + }); + + $pp = implode($flatten); + } + $newPart[] = $pp; } } @@ -2962,8 +4115,8 @@ protected function joinSelectors($parent, $child) /** * Multiply media * - * @param \Leafo\ScssPhp\Compiler\Environment $env - * @param array $childQueries + * @param \ScssPhp\ScssPhp\Compiler\Environment $env + * @param array $childQueries * * @return array */ @@ -2984,7 +4137,15 @@ protected function multiplyMedia(Environment $env = null, $childQueries = null) ? $env->block->queryList : [[[Type::T_MEDIA_VALUE, $env->block->value]]]; - if ($childQueries === null) { + $store = [$this->env, $this->storeEnv]; + + $this->env = $env; + $this->storeEnv = null; + $parentQueries = $this->evaluateMediaQuery($parentQueries); + + list($this->env, $this->storeEnv) = $store; + + if (\is_null($childQueries)) { $childQueries = $parentQueries; } else { $originalQueries = $childQueries; @@ -2992,7 +4153,11 @@ protected function multiplyMedia(Environment $env = null, $childQueries = null) foreach ($parentQueries as $parentQuery) { foreach ($originalQueries as $childQuery) { - $childQueries []= array_merge($parentQuery, $childQuery); + $childQueries[] = array_merge( + $parentQuery, + [[Type::T_MEDIA_TYPE, [Type::T_KEYWORD, 'all']]], + $childQuery + ); } } } @@ -3003,11 +4168,11 @@ protected function multiplyMedia(Environment $env = null, $childQueries = null) /** * Convert env linked list to stack * - * @param \Leafo\ScssPhp\Compiler\Environment $env + * @param \ScssPhp\ScssPhp\Compiler\Environment $env * * @return array */ - private function compactEnv(Environment $env) + protected function compactEnv(Environment $env) { for ($envs = []; $env; $env = $env->parent) { $envs[] = $env; @@ -3021,9 +4186,9 @@ private function compactEnv(Environment $env) * * @param array $envs * - * @return \Leafo\ScssPhp\Compiler\Environment + * @return \ScssPhp\ScssPhp\Compiler\Environment */ - private function extractEnv($envs) + protected function extractEnv($envs) { for ($env = null; $e = array_pop($envs);) { $e->parent = $env; @@ -3036,19 +4201,21 @@ private function extractEnv($envs) /** * Push environment * - * @param \Leafo\ScssPhp\Block $block + * @param \ScssPhp\ScssPhp\Block $block * - * @return \Leafo\ScssPhp\Compiler\Environment + * @return \ScssPhp\ScssPhp\Compiler\Environment */ protected function pushEnv(Block $block = null) { - $env = new Environment; + $env = new Environment(); $env->parent = $this->env; + $env->parentStore = $this->storeEnv; $env->store = []; $env->block = $block; $env->depth = isset($this->env->depth) ? $this->env->depth + 1 : 0; $this->env = $env; + $this->storeEnv = null; return $env; } @@ -3058,13 +4225,29 @@ protected function pushEnv(Block $block = null) */ protected function popEnv() { + $this->storeEnv = $this->env->parentStore; $this->env = $this->env->parent; } + /** + * Propagate vars from a just poped Env (used in @each and @for) + * + * @param array $store + * @param null|array $excludedVars + */ + protected function backPropagateEnv($store, $excludedVars = null) + { + foreach ($store as $key => $value) { + if (empty($excludedVars) || ! \in_array($key, $excludedVars)) { + $this->set($key, $value, true); + } + } + } + /** * Get store environment * - * @return \Leafo\ScssPhp\Compiler\Environment + * @return \ScssPhp\ScssPhp\Compiler\Environment */ protected function getStoreEnv() { @@ -3074,12 +4257,13 @@ protected function getStoreEnv() /** * Set variable * - * @param string $name - * @param mixed $value - * @param boolean $shadow - * @param \Leafo\ScssPhp\Compiler\Environment $env + * @param string $name + * @param mixed $value + * @param boolean $shadow + * @param \ScssPhp\ScssPhp\Compiler\Environment $env + * @param mixed $valueUnreduced */ - protected function set($name, $value, $shadow = false, Environment $env = null) + protected function set($name, $value, $shadow = false, Environment $env = null, $valueUnreduced = null) { $name = $this->normalizeName($name); @@ -3088,56 +4272,85 @@ protected function set($name, $value, $shadow = false, Environment $env = null) } if ($shadow) { - $this->setRaw($name, $value, $env); + $this->setRaw($name, $value, $env, $valueUnreduced); } else { - $this->setExisting($name, $value, $env); + $this->setExisting($name, $value, $env, $valueUnreduced); } } /** * Set existing variable * - * @param string $name - * @param mixed $value - * @param \Leafo\ScssPhp\Compiler\Environment $env + * @param string $name + * @param mixed $value + * @param \ScssPhp\ScssPhp\Compiler\Environment $env + * @param mixed $valueUnreduced */ - protected function setExisting($name, $value, Environment $env) + protected function setExisting($name, $value, Environment $env, $valueUnreduced = null) { $storeEnv = $env; + $specialContentKey = static::$namespaces['special'] . 'content'; $hasNamespace = $name[0] === '^' || $name[0] === '@' || $name[0] === '%'; + $maxDepth = 10000; + for (;;) { - if (array_key_exists($name, $env->store)) { + if ($maxDepth-- <= 0) { break; } - if (! $hasNamespace && isset($env->marker)) { - $env = $storeEnv; + if (\array_key_exists($name, $env->store)) { break; } - if (! isset($env->parent)) { + if (! $hasNamespace && isset($env->marker)) { + if (! empty($env->store[$specialContentKey])) { + $env = $env->store[$specialContentKey]->scope; + continue; + } + + if (! empty($env->declarationScopeParent)) { + $env = $env->declarationScopeParent; + continue; + } else { + $env = $storeEnv; + break; + } + } + + if (isset($env->parentStore)) { + $env = $env->parentStore; + } elseif (isset($env->parent)) { + $env = $env->parent; + } else { $env = $storeEnv; break; } - - $env = $env->parent; } $env->store[$name] = $value; + + if ($valueUnreduced) { + $env->storeUnreduced[$name] = $valueUnreduced; + } } /** * Set raw variable * - * @param string $name - * @param mixed $value - * @param \Leafo\ScssPhp\Compiler\Environment $env + * @param string $name + * @param mixed $value + * @param \ScssPhp\ScssPhp\Compiler\Environment $env + * @param mixed $valueUnreduced */ - protected function setRaw($name, $value, Environment $env) + protected function setRaw($name, $value, Environment $env, $valueUnreduced = null) { $env->store[$name] = $value; + + if ($valueUnreduced) { + $env->storeUnreduced[$name] = $valueUnreduced; + } } /** @@ -3145,13 +4358,14 @@ protected function setRaw($name, $value, Environment $env) * * @api * - * @param string $name - * @param boolean $shouldThrow - * @param \Leafo\ScssPhp\Compiler\Environment $env + * @param string $name + * @param boolean $shouldThrow + * @param \ScssPhp\ScssPhp\Compiler\Environment $env + * @param boolean $unreduced * - * @return mixed + * @return mixed|null */ - public function get($name, $shouldThrow = true, Environment $env = null) + public function get($name, $shouldThrow = true, Environment $env = null, $unreduced = false) { $normalizedName = $this->normalizeName($name); $specialContentKey = static::$namespaces['special'] . 'content'; @@ -3160,50 +4374,65 @@ public function get($name, $shouldThrow = true, Environment $env = null) $env = $this->getStoreEnv(); } - $nextIsRoot = false; $hasNamespace = $normalizedName[0] === '^' || $normalizedName[0] === '@' || $normalizedName[0] === '%'; + $maxDepth = 10000; + for (;;) { - if (array_key_exists($normalizedName, $env->store)) { + if ($maxDepth-- <= 0) { + break; + } + + if (\array_key_exists($normalizedName, $env->store)) { + if ($unreduced && isset($env->storeUnreduced[$normalizedName])) { + return $env->storeUnreduced[$normalizedName]; + } + return $env->store[$normalizedName]; } if (! $hasNamespace && isset($env->marker)) { - if (! $nextIsRoot && ! empty($env->store[$specialContentKey])) { + if (! empty($env->store[$specialContentKey])) { $env = $env->store[$specialContentKey]->scope; - $nextIsRoot = true; continue; } - $env = $this->rootEnv; + if (! empty($env->declarationScopeParent)) { + $env = $env->declarationScopeParent; + } else { + $env = $this->rootEnv; + } continue; } - if (! isset($env->parent)) { + if (isset($env->parentStore)) { + $env = $env->parentStore; + } elseif (isset($env->parent)) { + $env = $env->parent; + } else { break; } - - $env = $env->parent; } if ($shouldThrow) { - $this->throwError("Undefined variable \$$name"); + $this->throwError("Undefined variable \$$name" . ($maxDepth <= 0 ? " (infinite recursion)" : "")); } // found nothing + return null; } /** * Has variable? * - * @param string $name - * @param \Leafo\ScssPhp\Compiler\Environment $env + * @param string $name + * @param \ScssPhp\ScssPhp\Compiler\Environment $env * * @return boolean */ protected function has($name, Environment $env = null) { - return $this->get($name, false, $env) !== null; + return ! \is_null($this->get($name, false, $env)); } /** @@ -3277,7 +4506,7 @@ public function getVariables() */ public function addParsedFile($path) { - if (isset($path) && file_exists($path)) { + if (isset($path) && is_file($path)) { $this->parsedFiles[realpath($path)] = filemtime($path); } } @@ -3299,11 +4528,11 @@ public function getParsedFiles() * * @api * - * @param string $path + * @param string|callable $path */ public function addImportPath($path) { - if (! in_array($path, $this->importPaths)) { + if (! \in_array($path, $this->importPaths)) { $this->importPaths[] = $path; } } @@ -3421,11 +4650,12 @@ public function addFeature($name) /** * Import file * - * @param string $path - * @param array $out + * @param string $path + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out */ - protected function importFile($path, $out) + protected function importFile($path, OutputBlock $out) { + $this->pushCallStack('import '.$path); // see if tree is cached $realPath = realpath($path); @@ -3442,9 +4672,11 @@ protected function importFile($path, $out) } $pi = pathinfo($path); + array_unshift($this->importPaths, $pi['dirname']); $this->compileChildrenNoReturn($tree->children, $out); array_shift($this->importPaths); + $this->popCallStack(); } /** @@ -3460,38 +4692,58 @@ public function findImport($url) { $urls = []; + $hasExtension = preg_match('/[.]s?css$/', $url); + // for "normal" scss imports (ignore vanilla css and external requests) - if (! preg_match('/\.css$|^https?:\/\//', $url)) { + if (! preg_match('~\.css$|^https?://|^//~', $url)) { + $isPartial = (strpos(basename($url), '_') === 0); + // try both normal and the _partial filename - $urls = [$url, preg_replace('/[^\/]+$/', '_\0', $url)]; - } + $urls = [$url . ($hasExtension ? '' : '.scss')]; - $hasExtension = preg_match('/[.]s?css$/', $url); + if (! $isPartial) { + $urls[] = preg_replace('~[^/]+$~', '_\0', $url) . ($hasExtension ? '' : '.scss'); + } + + if (! $hasExtension) { + $urls[] = "$url/index.scss"; + $urls[] = "$url/_index.scss"; + // allow to find a plain css file, *if* no scss or partial scss is found + $urls[] .= $url . ".css"; + } + } foreach ($this->importPaths as $dir) { - if (is_string($dir)) { + if (\is_string($dir)) { // check urls for normal import paths foreach ($urls as $full) { - $full = $dir - . (! empty($dir) && substr($dir, -1) !== '/' ? '/' : '') - . $full; - - if ($this->fileExists($file = $full . '.scss') || - ($hasExtension && $this->fileExists($file = $full)) - ) { + $separator = ( + ! empty($dir) && + substr($dir, -1) !== '/' && + substr($full, 0, 1) !== '/' + ) ? '/' : ''; + $full = $dir . $separator . $full; + + if (is_file($file = $full)) { return $file; } } - } elseif (is_callable($dir)) { + } elseif (\is_callable($dir)) { // check custom callback for import path - $file = call_user_func($dir, $url); + $file = \call_user_func($dir, $url); - if ($file !== null) { + if (! \is_null($file)) { return $file; } } } + if ($urls) { + if (! $hasExtension or preg_match('/[.]scss$/', $url)) { + $this->throwError("`$url` file not found for @import"); + } + } + return null; } @@ -3514,11 +4766,13 @@ public function setEncoding($encoding) * * @param boolean $ignoreErrors * - * @return \Leafo\ScssPhp\Compiler + * @return \ScssPhp\ScssPhp\Compiler */ public function setIgnoreErrors($ignoreErrors) { $this->ignoreErrors = $ignoreErrors; + + return $this; } /** @@ -3528,7 +4782,7 @@ public function setIgnoreErrors($ignoreErrors) * * @param string $msg Message with optional sprintf()-style vararg parameters * - * @throws \Leafo\ScssPhp\Exception\CompilerException + * @throws \ScssPhp\ScssPhp\Exception\CompilerException */ public function throwError($msg) { @@ -3536,45 +4790,85 @@ public function throwError($msg) return; } - if (func_num_args() > 1) { - $msg = call_user_func_array('sprintf', func_get_args()); + if (\func_num_args() > 1) { + $msg = \call_user_func_array('sprintf', \func_get_args()); } - $line = $this->sourceLine; - $msg = "$msg: line: $line"; + if (! $this->ignoreCallStackMessage) { + $line = $this->sourceLine; + $column = $this->sourceColumn; + + $loc = isset($this->sourceNames[$this->sourceIndex]) + ? $this->sourceNames[$this->sourceIndex] . " on line $line, at column $column" + : "line: $line, column: $column"; + + $msg = "$msg: $loc"; + + $callStackMsg = $this->callStackMessage(); + + if ($callStackMsg) { + $msg .= "\nCall Stack:\n" . $callStackMsg; + } + } throw new CompilerException($msg); } /** - * Handle import loop + * Beautify call stack for output * - * @param string $name + * @param boolean $all + * @param null $limit * - * @throws \Exception + * @return string */ - protected function handleImportLoop($name) + protected function callStackMessage($all = false, $limit = null) { - for ($env = $this->env; $env; $env = $env->parent) { - $file = $this->sourceNames[$env->block->sourceIndex]; + $callStackMsg = []; + $ncall = 0; - if (realpath($file) === $name) { - $this->throwError('An @import loop has been found: %s imports %s', $file, basename($file)); - break; + if ($this->callStack) { + foreach (array_reverse($this->callStack) as $call) { + if ($all || (isset($call['n']) && $call['n'])) { + $msg = "#" . $ncall++ . " " . $call['n'] . " "; + $msg .= (isset($this->sourceNames[$call[Parser::SOURCE_INDEX]]) + ? $this->sourceNames[$call[Parser::SOURCE_INDEX]] + : '(unknown file)'); + $msg .= " on line " . $call[Parser::SOURCE_LINE]; + + $callStackMsg[] = $msg; + + if (! \is_null($limit) && $ncall > $limit) { + break; + } + } } } + + return implode("\n", $callStackMsg); } /** - * Does file exist? + * Handle import loop * * @param string $name * - * @return boolean + * @throws \Exception */ - protected function fileExists($name) + protected function handleImportLoop($name) { - return file_exists($name) && is_file($name); + for ($env = $this->env; $env; $env = $env->parent) { + if (! $env->block) { + continue; + } + + $file = $this->sourceNames[$env->block->sourceIndex]; + + if (realpath($file) === $name) { + $this->throwError('An @import loop has been found: %s imports %s', $file, basename($file)); + break; + } + } } /** @@ -3596,24 +4890,25 @@ protected function callScssFunction($name, $argValues, &$returnValue) $this->pushEnv(); - $storeEnv = $this->storeEnv; - $this->storeEnv = $this->env; - // set the args if (isset($func->args)) { $this->applyArguments($func->args, $argValues); } // throw away lines and children - $tmp = new OutputBlock; + $tmp = new OutputBlock(); $tmp->lines = []; $tmp->children = []; $this->env->marker = 'function'; - $ret = $this->compileChildren($func->children, $tmp); + if (! empty($func->parentEnv)) { + $this->env->declarationScopeParent = $func->parentEnv; + } else { + $this->throwError("@function $name() without parentEnv"); + } - $this->storeEnv = $storeEnv; + $ret = $this->compileChildren($func->children, $tmp, $this->env->marker . " " . $name); $this->popEnv(); @@ -3635,26 +4930,33 @@ protected function callNativeFunction($name, $args, &$returnValue) { // try a lib function $name = $this->normalizeName($name); + $libName = null; if (isset($this->userFunctions[$name])) { // see if we can find a user function list($f, $prototype) = $this->userFunctions[$name]; - } elseif (($f = $this->getBuiltinFunction($name)) && is_callable($f)) { + } elseif (($f = $this->getBuiltinFunction($name)) && \is_callable($f)) { $libName = $f[1]; $prototype = isset(static::$$libName) ? static::$$libName : null; } else { return false; } - list($sorted, $kwargs) = $this->sortArgs($prototype, $args); + @list($sorted, $kwargs) = $this->sortNativeFunctionArgs($libName, $prototype, $args); if ($name !== 'if' && $name !== 'call') { + $inExp = true; + + if ($name === 'join') { + $inExp = false; + } + foreach ($sorted as &$val) { - $val = $this->reduce($val, true); + $val = $this->reduce($val, $inExp); } } - $returnValue = call_user_func($f, $sorted, $kwargs); + $returnValue = \call_user_func($f, $sorted, $kwargs); if (! isset($returnValue)) { return false; @@ -3688,43 +4990,143 @@ function ($m) { /** * Sorts keyword arguments * - * @param array $prototype - * @param array $args + * @param string $functionName + * @param array $prototypes + * @param array $args * * @return array */ - protected function sortArgs($prototype, $args) + protected function sortNativeFunctionArgs($functionName, $prototypes, $args) { - $keyArgs = []; - $posArgs = []; + static $parser = null; - // separate positional and keyword arguments - foreach ($args as $arg) { - list($key, $value) = $arg; + if (! isset($prototypes)) { + $keyArgs = []; + $posArgs = []; + + // separate positional and keyword arguments + foreach ($args as $arg) { + list($key, $value) = $arg; - $key = $key[1]; + $key = $key[1]; - if (empty($key)) { - $posArgs[] = $value; - } else { - $keyArgs[$key] = $value; + if (empty($key)) { + $posArgs[] = empty($arg[2]) ? $value : $arg; + } else { + $keyArgs[$key] = $value; + } } - } - if (! isset($prototype)) { return [$posArgs, $keyArgs]; } - // copy positional args - $finalArgs = array_pad($posArgs, count($prototype), null); + // specific cases ? + if (\in_array($functionName, ['libRgb', 'libRgba', 'libHsl', 'libHsla'])) { + // notation 100 127 255 / 0 is in fact a simple list of 4 values + foreach ($args as $k => $arg) { + if ($arg[1][0] === Type::T_LIST && \count($arg[1][2]) === 3) { + $last = end($arg[1][2]); + + if ($last[0] === Type::T_EXPRESSION && $last[1] === '/') { + array_pop($arg[1][2]); + $arg[1][2][] = $last[2]; + $arg[1][2][] = $last[3]; + $args[$k] = $arg; + } + } + } + } + + $finalArgs = []; + + if (! \is_array(reset($prototypes))) { + $prototypes = [$prototypes]; + } + + $keyArgs = []; + + // trying each prototypes + $prototypeHasMatch = false; + $exceptionMessage = ''; + + foreach ($prototypes as $prototype) { + $argDef = []; + + foreach ($prototype as $i => $p) { + $default = null; + $p = explode(':', $p, 2); + $name = array_shift($p); + + if (\count($p)) { + $p = trim(reset($p)); + + if ($p === 'null') { + // differentiate this null from the static::$null + $default = [Type::T_KEYWORD, 'null']; + } else { + if (\is_null($parser)) { + $parser = $this->parserFactory(__METHOD__); + } + + $parser->parseValue($p, $default); + } + } + + $isVariable = false; + + if (substr($name, -3) === '...') { + $isVariable = true; + $name = substr($name, 0, -3); + } + + $argDef[] = [$name, $default, $isVariable]; + } + + $ignoreCallStackMessage = $this->ignoreCallStackMessage; + $this->ignoreCallStackMessage = true; + + try { + $vars = $this->applyArguments($argDef, $args, false, false); + + // ensure all args are populated + foreach ($prototype as $i => $p) { + $name = explode(':', $p)[0]; + + if (! isset($finalArgs[$i])) { + $finalArgs[$i] = null; + } + } + + // apply positional args + foreach (array_values($vars) as $i => $val) { + $finalArgs[$i] = $val; + } + + $keyArgs = array_merge($keyArgs, $vars); + $prototypeHasMatch = true; + + // overwrite positional args with keyword args + foreach ($prototype as $i => $p) { + $name = explode(':', $p)[0]; + + if (isset($keyArgs[$name])) { + $finalArgs[$i] = $keyArgs[$name]; + } - // overwrite positional args with keyword args - foreach ($prototype as $i => $names) { - foreach ((array) $names as $name) { - if (isset($keyArgs[$name])) { - $finalArgs[$i] = $keyArgs[$name]; + // special null value as default: translate to real null here + if ($finalArgs[$i] === [Type::T_KEYWORD, 'null']) { + $finalArgs[$i] = null; + } } + // should we break if this prototype seems fulfilled? + } catch (CompilerException $e) { + $exceptionMessage = $e->getMessage(); } + $this->ignoreCallStackMessage = $ignoreCallStackMessage; + } + + if ($exceptionMessage && ! $prototypeHasMatch) { + $this->throwError($exceptionMessage); } return [$finalArgs, $keyArgs]; @@ -3733,17 +5135,30 @@ protected function sortArgs($prototype, $args) /** * Apply argument values per definition * - * @param array $argDef - * @param array $argValues + * @param array $argDef + * @param array $argValues + * @param boolean $storeInEnv + * @param boolean $reduce + * only used if $storeInEnv = false + * + * @return array * * @throws \Exception */ - protected function applyArguments($argDef, $argValues) + protected function applyArguments($argDef, $argValues, $storeInEnv = true, $reduce = true) { - $storeEnv = $this->getStoreEnv(); + $output = []; + + if (\is_array($argValues) && \count($argValues) && end($argValues) === static::$null) { + array_pop($argValues); + } + + if ($storeInEnv) { + $storeEnv = $this->getStoreEnv(); - $env = new Environment; - $env->store = $storeEnv->store; + $env = new Environment(); + $env->store = $storeEnv->store; + } $hasVariable = false; $args = []; @@ -3755,37 +5170,65 @@ protected function applyArguments($argDef, $argValues) $hasVariable |= $isVariable; } - $keywordArgs = []; + $splatSeparator = null; + $keywordArgs = []; $deferredKeywordArgs = []; - $remaining = []; + $remaining = []; + $hasKeywordArgument = false; // assign the keyword args foreach ((array) $argValues as $arg) { if (! empty($arg[0])) { - if (! isset($args[$arg[0][1]])) { + $hasKeywordArgument = true; + + $name = $arg[0][1]; + if (! isset($args[$name])) { + foreach (array_keys($args) as $an) { + if (str_replace("_", "-", $an) === str_replace("_", "-", $name)) { + $name = $an; + break; + } + } + } + + if (! isset($args[$name]) || $args[$name][3]) { if ($hasVariable) { - $deferredKeywordArgs[$arg[0][1]] = $arg[1]; + $deferredKeywordArgs[$name] = $arg[1]; } else { $this->throwError("Mixin or function doesn't have an argument named $%s.", $arg[0][1]); break; } - } elseif ($args[$arg[0][1]][0] < count($remaining)) { + } elseif ($args[$name][0] < \count($remaining)) { $this->throwError("The argument $%s was passed both by position and by name.", $arg[0][1]); break; } else { - $keywordArgs[$arg[0][1]] = $arg[1]; + $keywordArgs[$name] = $arg[1]; } - } elseif (count($keywordArgs)) { - $this->throwError('Positional arguments must come before keyword arguments.'); - break; } elseif ($arg[2] === true) { $val = $this->reduce($arg[1], true); if ($val[0] === Type::T_LIST) { foreach ($val[2] as $name => $item) { if (! is_numeric($name)) { - $keywordArgs[$name] = $item; + if (! isset($args[$name])) { + foreach (array_keys($args) as $an) { + if (str_replace("_", "-", $an) === str_replace("_", "-", $name)) { + $name = $an; + break; + } + } + } + + if ($hasVariable) { + $deferredKeywordArgs[$name] = $item; + } else { + $keywordArgs[$name] = $item; + } } else { + if (\is_null($splatSeparator)) { + $splatSeparator = $val[1]; + } + $remaining[] = $item; } } @@ -3795,14 +5238,34 @@ protected function applyArguments($argDef, $argValues) $item = $val[2][$i]; if (! is_numeric($name)) { - $keywordArgs[$name] = $item; + if (! isset($args[$name])) { + foreach (array_keys($args) as $an) { + if (str_replace("_", "-", $an) === str_replace("_", "-", $name)) { + $name = $an; + break; + } + } + } + + if ($hasVariable) { + $deferredKeywordArgs[$name] = $item; + } else { + $keywordArgs[$name] = $item; + } } else { + if (\is_null($splatSeparator)) { + $splatSeparator = $val[1]; + } + $remaining[] = $item; } } } else { $remaining[] = $val; } + } elseif ($hasKeywordArgument) { + $this->throwError('Positional arguments must come before keyword arguments.'); + break; } else { $remaining[] = $arg[1]; } @@ -3812,9 +5275,9 @@ protected function applyArguments($argDef, $argValues) list($i, $name, $default, $isVariable) = $arg; if ($isVariable) { - $val = [Type::T_LIST, ',', [], $isVariable]; + $val = [Type::T_LIST, \is_null($splatSeparator) ? ',' : $splatSeparator , [], $isVariable]; - for ($count = count($remaining); $i < $count; $i++) { + for ($count = \count($remaining); $i < $count; $i++) { $val[2][] = $remaining[$i]; } @@ -3832,10 +5295,16 @@ protected function applyArguments($argDef, $argValues) break; } - $this->set($name, $this->reduce($val, true), true, $env); + if ($storeInEnv) { + $this->set($name, $this->reduce($val, true), true, $env); + } else { + $output[$name] = ($reduce ? $this->reduce($val, true) : $val); + } } - $storeEnv->store = $env->store; + if ($storeInEnv) { + $storeEnv->store = $env->store; + } foreach ($args as $arg) { list($i, $name, $default, $isVariable) = $arg; @@ -3844,8 +5313,14 @@ protected function applyArguments($argDef, $argValues) continue; } - $this->set($name, $this->reduce($default, true), true); + if ($storeInEnv) { + $this->set($name, $this->reduce($default, true), true); + } else { + $output[$name] = ($reduce ? $this->reduce($default, true) : $default); + } } + + return $output; } /** @@ -3853,19 +5328,19 @@ protected function applyArguments($argDef, $argValues) * * @param mixed $value * - * @return array|\Leafo\ScssPhp\Node\Number + * @return array|\ScssPhp\ScssPhp\Node\Number */ - private function coerceValue($value) + protected function coerceValue($value) { - if (is_array($value) || $value instanceof \ArrayAccess) { + if (\is_array($value) || $value instanceof \ArrayAccess) { return $value; } - if (is_bool($value)) { + if (\is_bool($value)) { return $this->toBool($value); } - if ($value === null) { + if (\is_null($value)) { return static::$null; } @@ -3877,30 +5352,14 @@ private function coerceValue($value) return static::$emptyString; } - if (preg_match('/^(#([0-9a-f]{6})|#([0-9a-f]{3}))$/i', $value, $m)) { - $color = [Type::T_COLOR]; - - if (isset($m[3])) { - $num = hexdec($m[3]); - - foreach ([3, 2, 1] as $i) { - $t = $num & 0xf; - $color[$i] = $t << 4 | $t; - $num >>= 4; - } - } else { - $num = hexdec($m[2]); - - foreach ([3, 2, 1] as $i) { - $color[$i] = $num & 0xff; - $num >>= 8; - } - } + $value = [Type::T_KEYWORD, $value]; + $color = $this->coerceColor($value); + if ($color) { return $color; } - return [Type::T_KEYWORD, $value]; + return $value; } /** @@ -3916,7 +5375,10 @@ protected function coerceMap($item) return $item; } - if ($item === static::$emptyList) { + if ($item[0] === static::$emptyList[0] && + $item[1] === static::$emptyList[1] && + $item[2] === static::$emptyList[2] + ) { return static::$emptyMap; } @@ -3926,14 +5388,20 @@ protected function coerceMap($item) /** * Coerce something to list * - * @param array $item - * @param string $delim + * @param array $item + * @param string $delim + * @param boolean $removeTrailingNull * * @return array */ - protected function coerceList($item, $delim = ',') + protected function coerceList($item, $delim = ',', $removeTrailingNull = false) { if (isset($item) && $item[0] === Type::T_LIST) { + // remove trailing null from the list + if ($removeTrailingNull && end($item[2]) === static::$null) { + array_pop($item[2]); + } + return $item; } @@ -3942,14 +5410,26 @@ protected function coerceList($item, $delim = ',') $values = $item[2]; $list = []; - for ($i = 0, $s = count($keys); $i < $s; $i++) { + for ($i = 0, $s = \count($keys); $i < $s; $i++) { $key = $keys[$i]; $value = $values[$i]; + switch ($key[0]) { + case Type::T_LIST: + case Type::T_MAP: + case Type::T_STRING: + case Type::T_NULL: + break; + + default: + $key = [Type::T_KEYWORD, $this->compileStringContent($this->coerceString($key))]; + break; + } + $list[] = [ Type::T_LIST, '', - [[Type::T_KEYWORD, $this->compileStringContent($this->coerceString($key))], $value] + [$key, $value] ]; } @@ -3982,21 +5462,107 @@ protected function coerceForExpression($value) * * @return array|null */ - protected function coerceColor($value) + protected function coerceColor($value, $inRGBFunction = false) { switch ($value[0]) { case Type::T_COLOR: + for ($i = 1; $i <= 3; $i++) { + if (! is_numeric($value[$i])) { + $cv = $this->compileRGBAValue($value[$i]); + + if (! is_numeric($cv)) { + return null; + } + + $value[$i] = $cv; + } + + if (isset($value[4])) { + if (! is_numeric($value[4])) { + $cv = $this->compileRGBAValue($value[4], true); + + if (! is_numeric($cv)) { + return null; + } + + $value[4] = $cv; + } + } + } + return $value; + case Type::T_LIST: + if ($inRGBFunction) { + if (\count($value[2]) == 3 || \count($value[2]) == 4) { + $color = $value[2]; + array_unshift($color, Type::T_COLOR); + + return $this->coerceColor($color); + } + } + + return null; + case Type::T_KEYWORD: + if (! \is_string($value[1])) { + return null; + } + $name = strtolower($value[1]); - if (isset(Colors::$cssColors[$name])) { - $rgba = explode(',', Colors::$cssColors[$name]); + // hexa color? + if (preg_match('/^#([0-9a-f]+)$/i', $name, $m)) { + $nofValues = \strlen($m[1]); + + if (\in_array($nofValues, [3, 4, 6, 8])) { + $nbChannels = 3; + $color = []; + $num = hexdec($m[1]); + + switch ($nofValues) { + case 4: + $nbChannels = 4; + // then continuing with the case 3: + case 3: + for ($i = 0; $i < $nbChannels; $i++) { + $t = $num & 0xf; + array_unshift($color, $t << 4 | $t); + $num >>= 4; + } + + break; + + case 8: + $nbChannels = 4; + // then continuing with the case 6: + case 6: + for ($i = 0; $i < $nbChannels; $i++) { + array_unshift($color, $num & 0xff); + $num >>= 8; + } + + break; + } + + if ($nbChannels === 4) { + if ($color[3] === 255) { + $color[3] = 1; // fully opaque + } else { + $color[3] = round($color[3] / 255, 3); + } + } + array_unshift($color, Type::T_COLOR); + + return $color; + } + } + + if ($rgba = Colors::colorNameToRGBa($name)) { return isset($rgba[3]) - ? [Type::T_COLOR, (int) $rgba[0], (int) $rgba[1], (int) $rgba[2], (int) $rgba[3]] - : [Type::T_COLOR, (int) $rgba[0], (int) $rgba[1], (int) $rgba[2]]; + ? [Type::T_COLOR, $rgba[0], $rgba[1], $rgba[2], $rgba[3]] + : [Type::T_COLOR, $rgba[0], $rgba[1], $rgba[2]]; } return null; @@ -4005,6 +5571,88 @@ protected function coerceColor($value) return null; } + /** + * @param integer|\ScssPhp\ScssPhp\Node\Number $value + * @param boolean $isAlpha + * + * @return integer|mixed + */ + protected function compileRGBAValue($value, $isAlpha = false) + { + if ($isAlpha) { + return $this->compileColorPartValue($value, 0, 1, false); + } + + return $this->compileColorPartValue($value, 0, 255, true); + } + + /** + * @param mixed $value + * @param integer|float $min + * @param integer|float $max + * @param boolean $isInt + * @param boolean $clamp + * @param boolean $modulo + * + * @return integer|mixed + */ + protected function compileColorPartValue($value, $min, $max, $isInt = true, $clamp = true, $modulo = false) + { + if (! is_numeric($value)) { + if (\is_array($value)) { + $reduced = $this->reduce($value); + + if (\is_object($reduced) && $value->type === Type::T_NUMBER) { + $value = $reduced; + } + } + + if (\is_object($value) && $value->type === Type::T_NUMBER) { + $num = $value->dimension; + + if (\count($value->units)) { + $unit = array_keys($value->units); + $unit = reset($unit); + + switch ($unit) { + case '%': + $num *= $max / 100; + break; + default: + break; + } + } + + $value = $num; + } elseif (\is_array($value)) { + $value = $this->compileValue($value); + } + } + + if (is_numeric($value)) { + if ($isInt) { + $value = round($value); + } + + if ($clamp) { + $value = min($max, max($min, $value)); + } + + if ($modulo) { + $value = $value % $max; + + // still negative? + while ($value < $min) { + $value += $max; + } + } + + return $value; + } + + return $value; + } + /** * Coerce value to string * @@ -4057,7 +5705,7 @@ public function assertMap($value) $value = $this->coerceMap($value); if ($value[0] !== Type::T_MAP) { - $this->throwError('expecting map'); + $this->throwError('expecting map, %s received', $value[0]); } return $value; @@ -4077,7 +5725,7 @@ public function assertMap($value) public function assertList($value) { if ($value[0] !== Type::T_LIST) { - $this->throwError('expecting list'); + $this->throwError('expecting list, %s received', $value[0]); } return $value; @@ -4100,7 +5748,7 @@ public function assertColor($value) return $color; } - $this->throwError('expecting color'); + $this->throwError('expecting color, %s received', $value[0]); } /** @@ -4117,7 +5765,7 @@ public function assertColor($value) public function assertNumber($value) { if ($value[0] !== Type::T_NUMBER) { - $this->throwError('expecting number'); + $this->throwError('expecting number, %s received', $value[0]); } return $value[1]; @@ -4194,7 +5842,7 @@ public function toHSL($red, $green, $blue) * * @return float */ - private function hueToRGB($m1, $m2, $h) + protected function hueToRGB($m1, $m2, $h) { if ($h < 0) { $h += 1; @@ -4252,28 +5900,27 @@ public function toRGB($hue, $saturation, $lightness) // Built in functions - //protected static $libCall = ['name', 'args...']; + protected static $libCall = ['name', 'args...']; protected function libCall($args, $kwargs) { $name = $this->compileStringContent($this->coerceString($this->reduce(array_shift($args), true))); + $callArgs = []; - $args = array_map( - function ($a) { - return [null, $a, false]; - }, - $args - ); - - if (count($kwargs)) { - foreach ($kwargs as $key => $value) { - $args[] = [[Type::T_VARIABLE, $key], $value, false]; + // $kwargs['args'] is [Type::T_LIST, ',', [..]] + foreach ($kwargs['args'][2] as $varname => $arg) { + if (is_numeric($varname)) { + $varname = null; + } else { + $varname = [ 'var', $varname]; } + + $callArgs[] = [$varname, $arg, false]; } - return $this->reduce([Type::T_FUNCTION_CALL, $name, $args]); + return $this->reduce([Type::T_FUNCTION_CALL, $name, $callArgs]); } - protected static $libIf = ['condition', 'if-true', 'if-false']; + protected static $libIf = ['condition', 'if-true', 'if-false:']; protected function libIf($args) { list($cond, $t, $f) = $args; @@ -4290,10 +5937,6 @@ protected function libIndex($args) { list($list, $value) = $args; - if ($value[0] === Type::T_MAP) { - return static::$null; - } - if ($list[0] === Type::T_MAP || $list[0] === Type::T_STRING || $list[0] === Type::T_KEYWORD || @@ -4317,30 +5960,68 @@ protected function libIndex($args) return false === $key ? static::$null : $key + 1; } - protected static $libRgb = ['red', 'green', 'blue']; - protected function libRgb($args) + protected static $libRgb = [ + ['color'], + ['color', 'alpha'], + ['channels'], + ['red', 'green', 'blue'], + ['red', 'green', 'blue', 'alpha'] ]; + protected function libRgb($args, $kwargs, $funcName = 'rgb') { - list($r, $g, $b) = $args; + switch (\count($args)) { + case 1: + if (! $color = $this->coerceColor($args[0], true)) { + $color = [Type::T_STRING, '', [$funcName . '(', $args[0], ')']]; + } + break; - return [Type::T_COLOR, $r[1], $g[1], $b[1]]; - } + case 3: + $color = [Type::T_COLOR, $args[0], $args[1], $args[2]]; - protected static $libRgba = [ - ['red', 'color'], - 'green', 'blue', 'alpha']; - protected function libRgba($args) - { - if ($color = $this->coerceColor($args[0])) { - $num = ! isset($args[1]) ? $args[3] : $args[1]; - $alpha = $this->assertNumber($num); - $color[4] = $alpha; + if (! $color = $this->coerceColor($color)) { + $color = [Type::T_STRING, '', [$funcName .'(', $args[0], ', ', $args[1], ', ', $args[2], ')']]; + } - return $color; + return $color; + + case 2: + if ($color = $this->coerceColor($args[0], true)) { + $alpha = $this->compileRGBAValue($args[1], true); + + if (is_numeric($alpha)) { + $color[4] = $alpha; + } else { + $color = [Type::T_STRING, '', + [$funcName . '(', $color[1], ', ', $color[2], ', ', $color[3], ', ', $alpha, ')']]; + } + } else { + $color = [Type::T_STRING, '', [$funcName . '(', $args[0], ')']]; + } + break; + + case 4: + default: + $color = [Type::T_COLOR, $args[0], $args[1], $args[2], $args[3]]; + + if (! $color = $this->coerceColor($color)) { + $color = [Type::T_STRING, '', + [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ', ', $args[3], ')']]; + } + break; } - list($r, $g, $b, $a) = $args; + return $color; + } - return [Type::T_COLOR, $r[1], $g[1], $b[1], $a[1]]; + protected static $libRgba = [ + ['color'], + ['color', 'alpha'], + ['channels'], + ['red', 'green', 'blue'], + ['red', 'green', 'blue', 'alpha'] ]; + protected function libRgba($args, $kwargs) + { + return $this->libRgb($args, $kwargs, 'rgba'); } // helper function for adjust_color, change_color, and scale_color @@ -4348,21 +6029,25 @@ protected function alterColor($args, $fn) { $color = $this->assertColor($args[0]); - foreach ([1, 2, 3, 7] as $i) { - if (isset($args[$i])) { - $val = $this->assertNumber($args[$i]); - $ii = $i === 7 ? 4 : $i; // alpha - $color[$ii] = call_user_func($fn, isset($color[$ii]) ? $color[$ii] : 0, $val, $i); + foreach ([1 => 1, 2 => 2, 3 => 3, 7 => 4] as $iarg => $irgba) { + if (isset($args[$iarg])) { + $val = $this->assertNumber($args[$iarg]); + + if (! isset($color[$irgba])) { + $color[$irgba] = (($irgba < 4) ? 0 : 1); + } + + $color[$irgba] = \call_user_func($fn, $color[$irgba], $val, $iarg); } } - if (isset($args[4]) || isset($args[5]) || isset($args[6])) { + if (! empty($args[4]) || ! empty($args[5]) || ! empty($args[6])) { $hsl = $this->toHSL($color[1], $color[2], $color[3]); - foreach ([4, 5, 6] as $i) { - if (isset($args[$i])) { - $val = $this->assertNumber($args[$i]); - $hsl[$i - 3] = call_user_func($fn, $hsl[$i - 3], $val, $i); + foreach ([4 => 1, 5 => 2, 6 => 3] as $iarg => $ihsl) { + if (! empty($args[$iarg])) { + $val = $this->assertNumber($args[$iarg]); + $hsl[$ihsl] = \call_user_func($fn, $hsl[$ihsl], $val, $iarg); } } @@ -4379,8 +6064,8 @@ protected function alterColor($args, $fn) } protected static $libAdjustColor = [ - 'color', 'red', 'green', 'blue', - 'hue', 'saturation', 'lightness', 'alpha' + 'color', 'red:null', 'green:null', 'blue:null', + 'hue:null', 'saturation:null', 'lightness:null', 'alpha:null' ]; protected function libAdjustColor($args) { @@ -4390,8 +6075,8 @@ protected function libAdjustColor($args) } protected static $libChangeColor = [ - 'color', 'red', 'green', 'blue', - 'hue', 'saturation', 'lightness', 'alpha' + 'color', 'red:null', 'green:null', 'blue:null', + 'hue:null', 'saturation:null', 'lightness:null', 'alpha:null' ]; protected function libChangeColor($args) { @@ -4401,8 +6086,8 @@ protected function libChangeColor($args) } protected static $libScaleColor = [ - 'color', 'red', 'green', 'blue', - 'hue', 'saturation', 'lightness', 'alpha' + 'color', 'red:null', 'green:null', 'blue:null', + 'hue:null', 'saturation:null', 'lightness:null', 'alpha:null' ]; protected function libScaleColor($args) { @@ -4445,7 +6130,7 @@ protected function libIeHexStr($args) $color = $this->coerceColor($args[0]); $color[4] = isset($color[4]) ? round(255 * $color[4]) : 255; - return sprintf('#%02X%02X%02X%02X', $color[4], $color[1], $color[2], $color[3]); + return [Type::T_STRING, '', [sprintf('#%02X%02X%02X%02X', $color[4], $color[1], $color[2], $color[3])]]; } protected static $libRed = ['color']; @@ -4496,7 +6181,7 @@ protected function libOpacity($args) } // mix two colors - protected static $libMix = ['color-1', 'color-2', 'weight']; + protected static $libMix = ['color-1', 'color-2', 'weight:0.5']; protected function libMix($args) { list($first, $second, $weight) = $args; @@ -4532,26 +6217,57 @@ protected function libMix($args) return $this->fixColor($new); } - protected static $libHsl = ['hue', 'saturation', 'lightness']; - protected function libHsl($args) + protected static $libHsl =[ + ['channels'], + ['hue', 'saturation', 'lightness'], + ['hue', 'saturation', 'lightness', 'alpha'] ]; + protected function libHsl($args, $kwargs, $funcName = 'hsl') { - list($h, $s, $l) = $args; + if (\count($args) == 1) { + if ($args[0][0] !== Type::T_LIST || \count($args[0][2]) < 3 || \count($args[0][2]) > 4) { + return [Type::T_STRING, '', [$funcName . '(', $args[0], ')']]; + } - return $this->toRGB($h[1], $s[1], $l[1]); - } + $args = $args[0][2]; + } - protected static $libHsla = ['hue', 'saturation', 'lightness', 'alpha']; - protected function libHsla($args) - { - list($h, $s, $l, $a) = $args; + $hue = $this->compileColorPartValue($args[0], 0, 360, false, false, true); + $saturation = $this->compileColorPartValue($args[1], 0, 100, false); + $lightness = $this->compileColorPartValue($args[2], 0, 100, false); - $color = $this->toRGB($h[1], $s[1], $l[1]); - $color[4] = $a[1]; + $alpha = null; - return $color; - } + if (\count($args) === 4) { + $alpha = $this->compileColorPartValue($args[3], 0, 100, false); - protected static $libHue = ['color']; + if (! is_numeric($hue) || ! is_numeric($saturation) || ! is_numeric($lightness) || ! is_numeric($alpha)) { + return [Type::T_STRING, '', + [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ', ', $args[3], ')']]; + } + } else { + if (! is_numeric($hue) || ! is_numeric($saturation) || ! is_numeric($lightness)) { + return [Type::T_STRING, '', [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ')']]; + } + } + + $color = $this->toRGB($hue, $saturation, $lightness); + + if (! \is_null($alpha)) { + $color[4] = $alpha; + } + + return $color; + } + + protected static $libHsla = [ + ['channels'], + ['hue', 'saturation', 'lightness', 'alpha:1'] ]; + protected function libHsla($args, $kwargs) + { + return $this->libHsl($args, $kwargs, 'hsla'); + } + + protected static $libHue = ['color']; protected function libHue($args) { $color = $this->assertColor($args[0]); @@ -4618,7 +6334,7 @@ protected function libDarken($args) return $this->adjustHsl($color, 3, -$amount); } - protected static $libSaturate = ['color', 'amount']; + protected static $libSaturate = [['color', 'amount'], ['number']]; protected function libSaturate($args) { $value = $args[0]; @@ -4660,21 +6376,32 @@ protected function libComplement($args) return $this->adjustHsl($this->assertColor($args[0]), 1, 180); } - protected static $libInvert = ['color']; + protected static $libInvert = ['color', 'weight:1']; protected function libInvert($args) { - $value = $args[0]; + list($value, $weight) = $args; + + if (! isset($weight)) { + $weight = 1; + } else { + $weight = $this->coercePercent($weight); + } if ($value[0] === Type::T_NUMBER) { return null; } $color = $this->assertColor($value); - $color[1] = 255 - $color[1]; - $color[2] = 255 - $color[2]; - $color[3] = 255 - $color[3]; + $inverted = $color; + $inverted[1] = 255 - $inverted[1]; + $inverted[2] = 255 - $inverted[2]; + $inverted[3] = 255 - $inverted[3]; - return $color; + if ($weight < 1) { + return $this->libMix([$inverted, $color, [Type::T_NUMBER, $weight]]); + } + + return $inverted; } // increases opacity by amount @@ -4739,13 +6466,13 @@ protected function libQuote($args) return [Type::T_STRING, '"', [$value]]; } - protected static $libPercentage = ['value']; + protected static $libPercentage = ['number']; protected function libPercentage($args) { return new Node\Number($this->coercePercent($args[0]) * 100, '%'); } - protected static $libRound = ['value']; + protected static $libRound = ['number']; protected function libRound($args) { $num = $args[0]; @@ -4753,7 +6480,7 @@ protected function libRound($args) return new Node\Number(round($num[1]), $num[2]); } - protected static $libFloor = ['value']; + protected static $libFloor = ['number']; protected function libFloor($args) { $num = $args[0]; @@ -4761,7 +6488,7 @@ protected function libFloor($args) return new Node\Number(floor($num[1]), $num[2]); } - protected static $libCeil = ['value']; + protected static $libCeil = ['number']; protected function libCeil($args) { $num = $args[0]; @@ -4769,7 +6496,7 @@ protected function libCeil($args) return new Node\Number(ceil($num[1]), $num[2]); } - protected static $libAbs = ['value']; + protected static $libAbs = ['number']; protected function libAbs($args) { $num = $args[0]; @@ -4780,29 +6507,47 @@ protected function libAbs($args) protected function libMin($args) { $numbers = $this->getNormalizedNumbers($args); - $min = null; + $minOriginal = null; + $minNormalized = null; + + foreach ($numbers as $key => $pair) { + list($original, $normalized) = $pair; - foreach ($numbers as $key => $number) { - if (null === $min || $number[1] <= $min[1]) { - $min = [$key, $number[1]]; + if (\is_null($normalized) or \is_null($minNormalized)) { + if (\is_null($minOriginal) || $original[1] <= $minOriginal[1]) { + $minOriginal = $original; + $minNormalized = $normalized; + } + } elseif ($normalized[1] <= $minNormalized[1]) { + $minOriginal = $original; + $minNormalized = $normalized; } } - return $args[$min[0]]; + return $minOriginal; } protected function libMax($args) { $numbers = $this->getNormalizedNumbers($args); - $max = null; + $maxOriginal = null; + $maxNormalized = null; + + foreach ($numbers as $key => $pair) { + list($original, $normalized) = $pair; - foreach ($numbers as $key => $number) { - if (null === $max || $number[1] >= $max[1]) { - $max = [$key, $number[1]]; + if (\is_null($normalized) or \is_null($maxNormalized)) { + if (\is_null($maxOriginal) || $original[1] >= $maxOriginal[1]) { + $maxOriginal = $original; + $maxNormalized = $normalized; + } + } elseif ($normalized[1] >= $maxNormalized[1]) { + $maxOriginal = $original; + $maxNormalized = $normalized; } } - return $args[$max[0]]; + return $maxOriginal; } /** @@ -4814,9 +6559,9 @@ protected function libMax($args) */ protected function getNormalizedNumbers($args) { - $unit = null; + $unit = null; $originalUnit = null; - $numbers = []; + $numbers = []; foreach ($args as $key => $item) { if ($item[0] !== Type::T_NUMBER) { @@ -4826,15 +6571,15 @@ protected function getNormalizedNumbers($args) $number = $item->normalize(); - if (null === $unit) { + if (empty($unit)) { $unit = $number[2]; $originalUnit = $item->unitStr(); - } elseif ($unit !== $number[2]) { + } elseif ($number[1] && $unit !== $number[2] && ! empty($number[2])) { $this->throwError('Incompatible units: "%s" and "%s".', $originalUnit, $item->unitStr()); break; } - $numbers[$key] = $number; + $numbers[$key] = [$args[$key], empty($number[2]) ? null : $number]; } return $numbers; @@ -4843,21 +6588,21 @@ protected function getNormalizedNumbers($args) protected static $libLength = ['list']; protected function libLength($args) { - $list = $this->coerceList($args[0]); + $list = $this->coerceList($args[0], ',', true); - return count($list[2]); + return \count($list[2]); } //protected static $libListSeparator = ['list...']; protected function libListSeparator($args) { - if (count($args) > 1) { + if (\count($args) > 1) { return 'comma'; } $list = $this->coerceList($args[0]); - if (count($list[2]) <= 1) { + if (\count($list[2]) <= 1) { return 'space'; } @@ -4871,13 +6616,13 @@ protected function libListSeparator($args) protected static $libNth = ['list', 'n']; protected function libNth($args) { - $list = $this->coerceList($args[0]); + $list = $this->coerceList($args[0], ',', false); $n = $this->assertNumber($args[1]); if ($n > 0) { $n--; } elseif ($n < 0) { - $n += count($list[2]); + $n += \count($list[2]); } return isset($list[2][$n]) ? $list[2][$n] : static::$defaultValue; @@ -4892,13 +6637,13 @@ protected function libSetNth($args) if ($n > 0) { $n--; } elseif ($n < 0) { - $n += count($list[2]); + $n += \count($list[2]); } if (! isset($list[2][$n])) { $this->throwError('Invalid argument for "n"'); - return; + return null; } $list[2][$n] = $args[2]; @@ -4910,11 +6655,15 @@ protected function libSetNth($args) protected function libMapGet($args) { $map = $this->assertMap($args[0]); - $key = $this->compileStringContent($this->coerceString($args[1])); + $key = $args[1]; - for ($i = count($map[1]) - 1; $i >= 0; $i--) { - if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) { - return $map[2][$i]; + if (! \is_null($key)) { + $key = $this->compileStringContent($this->coerceString($key)); + + for ($i = \count($map[1]) - 1; $i >= 0; $i--) { + if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) { + return $map[2][$i]; + } } } @@ -4945,7 +6694,7 @@ protected function libMapRemove($args) $map = $this->assertMap($args[0]); $key = $this->compileStringContent($this->coerceString($args[1])); - for ($i = count($map[1]) - 1; $i >= 0; $i--) { + for ($i = \count($map[1]) - 1; $i >= 0; $i--) { if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) { array_splice($map[1], $i, 1); array_splice($map[2], $i, 1); @@ -4961,7 +6710,7 @@ protected function libMapHasKey($args) $map = $this->assertMap($args[0]); $key = $this->compileStringContent($this->coerceString($args[1])); - for ($i = count($map[1]) - 1; $i >= 0; $i--) { + for ($i = \count($map[1]) - 1; $i >= 0; $i--) { if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) { return true; } @@ -4976,7 +6725,21 @@ protected function libMapMerge($args) $map1 = $this->assertMap($args[0]); $map2 = $this->assertMap($args[1]); - return [Type::T_MAP, array_merge($map1[1], $map2[1]), array_merge($map1[2], $map2[2])]; + foreach ($map2[1] as $i2 => $key2) { + $key = $this->compileStringContent($this->coerceString($key2)); + + foreach ($map1[1] as $i1 => $key1) { + if ($key === $this->compileStringContent($this->coerceString($key1))) { + $map1[2][$i1] = $map2[2][$i2]; + continue 2; + } + } + + $map1[1][] = $map2[1][$i2]; + $map1[2][] = $map2[2][$i2]; + } + + return $map1; } protected static $libKeywords = ['args']; @@ -4995,6 +6758,19 @@ protected function libKeywords($args) return [Type::T_MAP, $keys, $values]; } + protected static $libIsBracketed = ['list']; + protected function libIsBracketed($args) + { + $list = $args[0]; + $this->coerceList($list, ' '); + + if (! empty($list['enclosing']) && $list['enclosing'] === 'bracket') { + return true; + } + + return false; + } + protected function listSeparatorForJoin($list1, $sep) { if (! isset($sep)) { @@ -5006,40 +6782,80 @@ protected function listSeparatorForJoin($list1, $sep) return ','; case 'space': - return ''; + return ' '; default: return $list1[1]; } } - protected static $libJoin = ['list1', 'list2', 'separator']; + protected static $libJoin = ['list1', 'list2', 'separator:null', 'bracketed:auto']; protected function libJoin($args) { - list($list1, $list2, $sep) = $args; + list($list1, $list2, $sep, $bracketed) = $args; + + $list1 = $this->coerceList($list1, ' ', true); + $list2 = $this->coerceList($list2, ' ', true); + $sep = $this->listSeparatorForJoin($list1, $sep); - $list1 = $this->coerceList($list1, ' '); - $list2 = $this->coerceList($list2, ' '); - $sep = $this->listSeparatorForJoin($list1, $sep); + if ($bracketed === static::$true) { + $bracketed = true; + } elseif ($bracketed === static::$false) { + $bracketed = false; + } elseif ($bracketed === [Type::T_KEYWORD, 'auto']) { + $bracketed = 'auto'; + } elseif ($bracketed === static::$null) { + $bracketed = false; + } else { + $bracketed = $this->compileValue($bracketed); + $bracketed = ! ! $bracketed; + + if ($bracketed === true) { + $bracketed = true; + } + } + + if ($bracketed === 'auto') { + $bracketed = false; + + if (! empty($list1['enclosing']) && $list1['enclosing'] === 'bracket') { + $bracketed = true; + } + } + + $res = [Type::T_LIST, $sep, array_merge($list1[2], $list2[2])]; + + if (isset($list1['enclosing'])) { + $res['enlcosing'] = $list1['enclosing']; + } + + if ($bracketed) { + $res['enclosing'] = 'bracket'; + } - return [Type::T_LIST, $sep, array_merge($list1[2], $list2[2])]; + return $res; } - protected static $libAppend = ['list', 'val', 'separator']; + protected static $libAppend = ['list', 'val', 'separator:null']; protected function libAppend($args) { list($list1, $value, $sep) = $args; - $list1 = $this->coerceList($list1, ' '); - $sep = $this->listSeparatorForJoin($list1, $sep); + $list1 = $this->coerceList($list1, ' ', true); + $sep = $this->listSeparatorForJoin($list1, $sep); + $res = [Type::T_LIST, $sep, array_merge($list1[2], [$value])]; - return [Type::T_LIST, $sep, array_merge($list1[2], [$value])]; + if (isset($list1['enclosing'])) { + $res['enclosing'] = $list1['enclosing']; + } + + return $res; } protected function libZip($args) { - foreach ($args as $arg) { - $this->assertList($arg); + foreach ($args as $key => $arg) { + $args[$key] = $this->coerceList($arg); } $lists = []; @@ -5122,7 +6938,7 @@ protected function libComparable($args) ) { $this->throwError('Invalid argument(s) for "comparable"'); - return; + return null; } $number1 = $number1->normalize(); @@ -5167,13 +6983,13 @@ protected function libStrLength($args) $string = $this->coerceString($args[0]); $stringContent = $this->compileStringContent($string); - return new Node\Number(strlen($stringContent), ''); + return new Node\Number(\strlen($stringContent), ''); } - protected static $libStrSlice = ['string', 'start-at', 'end-at']; + protected static $libStrSlice = ['string', 'start-at', 'end-at:-1']; protected function libStrSlice($args) { - if (isset($args[2]) && $args[2][1] == 0) { + if (isset($args[2]) && ! $args[2][1]) { return static::$nullString; } @@ -5186,7 +7002,7 @@ protected function libStrSlice($args) $start--; } - $end = (int) $args[2][1]; + $end = isset($args[2]) ? (int) $args[2][1] : -1; $length = $end < 0 ? $end + 1 : ($end > 0 ? $end - $start : $end); $string[2] = $length @@ -5202,7 +7018,7 @@ protected function libToLowerCase($args) $string = $this->coerceString($args[0]); $stringContent = $this->compileStringContent($string); - $string[2] = [function_exists('mb_strtolower') ? mb_strtolower($stringContent) : strtolower($stringContent)]; + $string[2] = [\function_exists('mb_strtolower') ? mb_strtolower($stringContent) : strtolower($stringContent)]; return $string; } @@ -5213,7 +7029,7 @@ protected function libToUpperCase($args) $string = $this->coerceString($args[0]); $stringContent = $this->compileStringContent($string); - $string[2] = [function_exists('mb_strtoupper') ? mb_strtoupper($stringContent) : strtoupper($stringContent)]; + $string[2] = [\function_exists('mb_strtoupper') ? mb_strtoupper($stringContent) : strtoupper($stringContent)]; return $string; } @@ -5225,7 +7041,7 @@ protected function libFeatureExists($args) $name = $this->compileStringContent($string); return $this->toBool( - array_key_exists($name, $this->registeredFeatures) ? $this->registeredFeatures[$name] : false + \array_key_exists($name, $this->registeredFeatures) ? $this->registeredFeatures[$name] : false ); } @@ -5249,7 +7065,7 @@ protected function libFunctionExists($args) // built-in functions $f = $this->getBuiltinFunction($name); - return $this->toBool(is_callable($f)); + return $this->toBool(\is_callable($f)); } protected static $libGlobalVariableExists = ['name']; @@ -5293,19 +7109,25 @@ protected function libCounter($args) return [Type::T_STRING, '', ['counter(' . implode(',', $list) . ')']]; } - protected static $libRandom = ['limit']; + protected static $libRandom = ['limit:1']; protected function libRandom($args) { if (isset($args[0])) { $n = $this->assertNumber($args[0]); if ($n < 1) { - $this->throwError("limit must be greater than or equal to 1"); + $this->throwError("\$limit must be greater than or equal to 1"); - return; + return null; } - return new Node\Number(mt_rand(1, $n), ''); + if ($n - \intval($n) > 0) { + $this->throwError("Expected \$limit to be an integer but got $n for `random`"); + + return null; + } + + return new Node\Number(mt_rand(1, \intval($n)), ''); } return new Node\Number(mt_rand(1, mt_getrandmax()), ''); @@ -5316,7 +7138,9 @@ protected function libUniqueId() static $id; if (! isset($id)) { - $id = mt_rand(0, pow(36, 8)); + $id = PHP_INT_SIZE === 4 + ? mt_rand(0, pow(36, 5)) . str_pad(mt_rand(0, pow(36, 5)) % 10000000, 7, '0', STR_PAD_LEFT) + : mt_rand(0, pow(36, 8)); } $id += mt_rand(0, 10) + 1; @@ -5324,13 +7148,695 @@ protected function libUniqueId() return [Type::T_STRING, '', ['u' . str_pad(base_convert($id, 10, 36), 8, '0', STR_PAD_LEFT)]]; } + protected function inspectFormatValue($value, $force_enclosing_display = false) + { + if ($value === static::$null) { + $value = [Type::T_KEYWORD, 'null']; + } + + $stringValue = [$value]; + + if ($value[0] === Type::T_LIST) { + if (end($value[2]) === static::$null) { + array_pop($value[2]); + $value[2][] = [Type::T_STRING, '', ['']]; + $force_enclosing_display = true; + } + + if (! empty($value['enclosing']) && + ($force_enclosing_display || + ($value['enclosing'] === 'bracket') || + ! \count($value[2])) + ) { + $value['enclosing'] = 'forced_'.$value['enclosing']; + $force_enclosing_display = true; + } + + foreach ($value[2] as $k => $listelement) { + $value[2][$k] = $this->inspectFormatValue($listelement, $force_enclosing_display); + } + + $stringValue = [$value]; + } + + return [Type::T_STRING, '', $stringValue]; + } + protected static $libInspect = ['value']; protected function libInspect($args) { - if ($args[0] === static::$null) { - return [Type::T_KEYWORD, 'null']; + $value = $args[0]; + + return $this->inspectFormatValue($value); + } + + /** + * Preprocess selector args + * + * @param array $arg + * + * @return array|boolean + */ + protected function getSelectorArg($arg) + { + static $parser = null; + + if (\is_null($parser)) { + $parser = $this->parserFactory(__METHOD__); + } + + $arg = $this->libUnquote([$arg]); + $arg = $this->compileValue($arg); + + $parsedSelector = []; + + if ($parser->parseSelector($arg, $parsedSelector)) { + $selector = $this->evalSelectors($parsedSelector); + $gluedSelector = $this->glueFunctionSelectors($selector); + + return $gluedSelector; + } + + return false; + } + + /** + * Postprocess selector to output in right format + * + * @param array $selectors + * + * @return string + */ + protected function formatOutputSelector($selectors) + { + $selectors = $this->collapseSelectors($selectors, true); + + return $selectors; + } + + protected static $libIsSuperselector = ['super', 'sub']; + protected function libIsSuperselector($args) + { + list($super, $sub) = $args; + + $super = $this->getSelectorArg($super); + $sub = $this->getSelectorArg($sub); + + return $this->isSuperSelector($super, $sub); + } + + /** + * Test a $super selector again $sub + * + * @param array $super + * @param array $sub + * + * @return boolean + */ + protected function isSuperSelector($super, $sub) + { + // one and only one selector for each arg + if (! $super || \count($super) !== 1) { + $this->throwError("Invalid super selector for isSuperSelector()"); + } + + if (! $sub || \count($sub) !== 1) { + $this->throwError("Invalid sub selector for isSuperSelector()"); + } + + $super = reset($super); + $sub = reset($sub); + + $i = 0; + $nextMustMatch = false; + + foreach ($super as $node) { + $compound = ''; + + array_walk_recursive( + $node, + function ($value, $key) use (&$compound) { + $compound .= $value; + } + ); + + if ($this->isImmediateRelationshipCombinator($compound)) { + if ($node !== $sub[$i]) { + return false; + } + + $nextMustMatch = true; + $i++; + } else { + while ($i < \count($sub) && ! $this->isSuperPart($node, $sub[$i])) { + if ($nextMustMatch) { + return false; + } + + $i++; + } + + if ($i >= \count($sub)) { + return false; + } + + $nextMustMatch = false; + $i++; + } + } + + return true; + } + + /** + * Test a part of super selector again a part of sub selector + * + * @param array $superParts + * @param array $subParts + * + * @return boolean + */ + protected function isSuperPart($superParts, $subParts) + { + $i = 0; + + foreach ($superParts as $superPart) { + while ($i < \count($subParts) && $subParts[$i] !== $superPart) { + $i++; + } + + if ($i >= \count($subParts)) { + return false; + } + + $i++; + } + + return true; + } + + protected static $libSelectorAppend = ['selector...']; + protected function libSelectorAppend($args) + { + // get the selector... list + $args = reset($args); + $args = $args[2]; + + if (\count($args) < 1) { + $this->throwError("selector-append() needs at least 1 argument"); + } + + $selectors = array_map([$this, 'getSelectorArg'], $args); + + return $this->formatOutputSelector($this->selectorAppend($selectors)); + } + + /** + * Append parts of the last selector in the list to the previous, recursively + * + * @param array $selectors + * + * @return array + * + * @throws \ScssPhp\ScssPhp\Exception\CompilerException + */ + protected function selectorAppend($selectors) + { + $lastSelectors = array_pop($selectors); + + if (! $lastSelectors) { + $this->throwError("Invalid selector list in selector-append()"); + } + + while (\count($selectors)) { + $previousSelectors = array_pop($selectors); + + if (! $previousSelectors) { + $this->throwError("Invalid selector list in selector-append()"); + } + + // do the trick, happening $lastSelector to $previousSelector + $appended = []; + + foreach ($lastSelectors as $lastSelector) { + $previous = $previousSelectors; + + foreach ($lastSelector as $lastSelectorParts) { + foreach ($lastSelectorParts as $lastSelectorPart) { + foreach ($previous as $i => $previousSelector) { + foreach ($previousSelector as $j => $previousSelectorParts) { + $previous[$i][$j][] = $lastSelectorPart; + } + } + } + } + + foreach ($previous as $ps) { + $appended[] = $ps; + } + } + + $lastSelectors = $appended; + } + + return $lastSelectors; + } + + protected static $libSelectorExtend = ['selectors', 'extendee', 'extender']; + protected function libSelectorExtend($args) + { + list($selectors, $extendee, $extender) = $args; + + $selectors = $this->getSelectorArg($selectors); + $extendee = $this->getSelectorArg($extendee); + $extender = $this->getSelectorArg($extender); + + if (! $selectors || ! $extendee || ! $extender) { + $this->throwError("selector-extend() invalid arguments"); + } + + $extended = $this->extendOrReplaceSelectors($selectors, $extendee, $extender); + + return $this->formatOutputSelector($extended); + } + + protected static $libSelectorReplace = ['selectors', 'original', 'replacement']; + protected function libSelectorReplace($args) + { + list($selectors, $original, $replacement) = $args; + + $selectors = $this->getSelectorArg($selectors); + $original = $this->getSelectorArg($original); + $replacement = $this->getSelectorArg($replacement); + + if (! $selectors || ! $original || ! $replacement) { + $this->throwError("selector-replace() invalid arguments"); + } + + $replaced = $this->extendOrReplaceSelectors($selectors, $original, $replacement, true); + + return $this->formatOutputSelector($replaced); + } + + /** + * Extend/replace in selectors + * used by selector-extend and selector-replace that use the same logic + * + * @param array $selectors + * @param array $extendee + * @param array $extender + * @param boolean $replace + * + * @return array + */ + protected function extendOrReplaceSelectors($selectors, $extendee, $extender, $replace = false) + { + $saveExtends = $this->extends; + $saveExtendsMap = $this->extendsMap; + + $this->extends = []; + $this->extendsMap = []; + + foreach ($extendee as $es) { + // only use the first one + $this->pushExtends(reset($es), $extender, null); + } + + $extended = []; + + foreach ($selectors as $selector) { + if (! $replace) { + $extended[] = $selector; + } + + $n = \count($extended); + + $this->matchExtends($selector, $extended); + + // if didnt match, keep the original selector if we are in a replace operation + if ($replace and \count($extended) === $n) { + $extended[] = $selector; + } + } + + $this->extends = $saveExtends; + $this->extendsMap = $saveExtendsMap; + + return $extended; + } + + protected static $libSelectorNest = ['selector...']; + protected function libSelectorNest($args) + { + // get the selector... list + $args = reset($args); + $args = $args[2]; + + if (\count($args) < 1) { + $this->throwError("selector-nest() needs at least 1 argument"); + } + + $selectorsMap = array_map([$this, 'getSelectorArg'], $args); + $envs = []; + + foreach ($selectorsMap as $selectors) { + $env = new Environment(); + $env->selectors = $selectors; + + $envs[] = $env; + } + + $envs = array_reverse($envs); + $env = $this->extractEnv($envs); + $outputSelectors = $this->multiplySelectors($env); + + return $this->formatOutputSelector($outputSelectors); + } + + protected static $libSelectorParse = ['selectors']; + protected function libSelectorParse($args) + { + $selectors = reset($args); + $selectors = $this->getSelectorArg($selectors); + + return $this->formatOutputSelector($selectors); + } + + protected static $libSelectorUnify = ['selectors1', 'selectors2']; + protected function libSelectorUnify($args) + { + list($selectors1, $selectors2) = $args; + + $selectors1 = $this->getSelectorArg($selectors1); + $selectors2 = $this->getSelectorArg($selectors2); + + if (! $selectors1 || ! $selectors2) { + $this->throwError("selector-unify() invalid arguments"); + } + + // only consider the first compound of each + $compound1 = reset($selectors1); + $compound2 = reset($selectors2); + + // unify them and that's it + $unified = $this->unifyCompoundSelectors($compound1, $compound2); + + return $this->formatOutputSelector($unified); + } + + /** + * The selector-unify magic as its best + * (at least works as expected on test cases) + * + * @param array $compound1 + * @param array $compound2 + * + * @return array|mixed + */ + protected function unifyCompoundSelectors($compound1, $compound2) + { + if (! \count($compound1)) { + return $compound2; + } + + if (! \count($compound2)) { + return $compound1; + } + + // check that last part are compatible + $lastPart1 = array_pop($compound1); + $lastPart2 = array_pop($compound2); + $last = $this->mergeParts($lastPart1, $lastPart2); + + if (! $last) { + return [[]]; + } + + $unifiedCompound = [$last]; + $unifiedSelectors = [$unifiedCompound]; + + // do the rest + while (\count($compound1) || \count($compound2)) { + $part1 = end($compound1); + $part2 = end($compound2); + + if ($part1 && ($match2 = $this->matchPartInCompound($part1, $compound2))) { + list($compound2, $part2, $after2) = $match2; + + if ($after2) { + $unifiedSelectors = $this->prependSelectors($unifiedSelectors, $after2); + } + + $c = $this->mergeParts($part1, $part2); + $unifiedSelectors = $this->prependSelectors($unifiedSelectors, [$c]); + + $part1 = $part2 = null; + + array_pop($compound1); + } + + if ($part2 && ($match1 = $this->matchPartInCompound($part2, $compound1))) { + list($compound1, $part1, $after1) = $match1; + + if ($after1) { + $unifiedSelectors = $this->prependSelectors($unifiedSelectors, $after1); + } + + $c = $this->mergeParts($part2, $part1); + $unifiedSelectors = $this->prependSelectors($unifiedSelectors, [$c]); + + $part1 = $part2 = null; + + array_pop($compound2); + } + + $new = []; + + if ($part1 && $part2) { + array_pop($compound1); + array_pop($compound2); + + $s = $this->prependSelectors($unifiedSelectors, [$part2]); + $new = array_merge($new, $this->prependSelectors($s, [$part1])); + $s = $this->prependSelectors($unifiedSelectors, [$part1]); + $new = array_merge($new, $this->prependSelectors($s, [$part2])); + } elseif ($part1) { + array_pop($compound1); + + $new = array_merge($new, $this->prependSelectors($unifiedSelectors, [$part1])); + } elseif ($part2) { + array_pop($compound2); + + $new = array_merge($new, $this->prependSelectors($unifiedSelectors, [$part2])); + } + + if ($new) { + $unifiedSelectors = $new; + } + } + + return $unifiedSelectors; + } + + /** + * Prepend each selector from $selectors with $parts + * + * @param array $selectors + * @param array $parts + * + * @return array + */ + protected function prependSelectors($selectors, $parts) + { + $new = []; + + foreach ($selectors as $compoundSelector) { + array_unshift($compoundSelector, $parts); + + $new[] = $compoundSelector; + } + + return $new; + } + + /** + * Try to find a matching part in a compound: + * - with same html tag name + * - with some class or id or something in common + * + * @param array $part + * @param array $compound + * + * @return array|boolean + */ + protected function matchPartInCompound($part, $compound) + { + $partTag = $this->findTagName($part); + $before = $compound; + $after = []; + + // try to find a match by tag name first + while (\count($before)) { + $p = array_pop($before); + + if ($partTag && $partTag !== '*' && $partTag == $this->findTagName($p)) { + return [$before, $p, $after]; + } + + $after[] = $p; + } + + // try again matching a non empty intersection and a compatible tagname + $before = $compound; + $after = []; + + while (\count($before)) { + $p = array_pop($before); + + if ($this->checkCompatibleTags($partTag, $this->findTagName($p))) { + if (\count(array_intersect($part, $p))) { + return [$before, $p, $after]; + } + } + + $after[] = $p; + } + + return false; + } + + /** + * Merge two part list taking care that + * - the html tag is coming first - if any + * - the :something are coming last + * + * @param array $parts1 + * @param array $parts2 + * + * @return array + */ + protected function mergeParts($parts1, $parts2) + { + $tag1 = $this->findTagName($parts1); + $tag2 = $this->findTagName($parts2); + $tag = $this->checkCompatibleTags($tag1, $tag2); + + // not compatible tags + if ($tag === false) { + return []; + } + + if ($tag) { + if ($tag1) { + $parts1 = array_diff($parts1, [$tag1]); + } + + if ($tag2) { + $parts2 = array_diff($parts2, [$tag2]); + } + } + + $mergedParts = array_merge($parts1, $parts2); + $mergedOrderedParts = []; + + foreach ($mergedParts as $part) { + if (strpos($part, ':') === 0) { + $mergedOrderedParts[] = $part; + } + } + + $mergedParts = array_diff($mergedParts, $mergedOrderedParts); + $mergedParts = array_merge($mergedParts, $mergedOrderedParts); + + if ($tag) { + array_unshift($mergedParts, $tag); + } + + return $mergedParts; + } + + /** + * Check the compatibility between two tag names: + * if both are defined they should be identical or one has to be '*' + * + * @param string $tag1 + * @param string $tag2 + * + * @return array|boolean + */ + protected function checkCompatibleTags($tag1, $tag2) + { + $tags = [$tag1, $tag2]; + $tags = array_unique($tags); + $tags = array_filter($tags); + + if (\count($tags) > 1) { + $tags = array_diff($tags, ['*']); + } + + // not compatible nodes + if (\count($tags) > 1) { + return false; + } + + return $tags; + } + + /** + * Find the html tag name in a selector parts list + * + * @param array $parts + * + * @return mixed|string + */ + protected function findTagName($parts) + { + foreach ($parts as $part) { + if (! preg_match('/^[\[.:#%_-]/', $part)) { + return $part; + } + } + + return ''; + } + + protected static $libSimpleSelectors = ['selector']; + protected function libSimpleSelectors($args) + { + $selector = reset($args); + $selector = $this->getSelectorArg($selector); + + // remove selectors list layer, keeping the first one + $selector = reset($selector); + + // remove parts list layer, keeping the first part + $part = reset($selector); + + $listParts = []; + + foreach ($part as $p) { + $listParts[] = [Type::T_STRING, '', [$p]]; + } + + return [Type::T_LIST, ',', $listParts]; + } + + protected static $libScssphpGlob = ['pattern']; + protected function libScssphpGlob($args) + { + $string = $this->coerceString($args[0]); + $pattern = $this->compileStringContent($string); + $matches = glob($pattern); + $listParts = []; + + foreach ($matches as $match) { + if (! is_file($match)) { + continue; + } + + $listParts[] = [Type::T_STRING, '"', [$match]]; } - return $args[0]; + return [Type::T_LIST, ',', $listParts]; } } diff --git a/scssphp/src/Compiler/Environment.php b/scssphp/src/Compiler/Environment.php index fe309dd..5dbe9f3 100755 --- a/scssphp/src/Compiler/Environment.php +++ b/scssphp/src/Compiler/Environment.php @@ -2,14 +2,14 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp\Compiler; +namespace ScssPhp\ScssPhp\Compiler; /** * Compiler environment @@ -19,12 +19,12 @@ class Environment { /** - * @var \Leafo\ScssPhp\Block + * @var \ScssPhp\ScssPhp\Block */ public $block; /** - * @var \Leafo\ScssPhp\Compiler\Environment + * @var \ScssPhp\ScssPhp\Compiler\Environment */ public $parent; @@ -33,6 +33,11 @@ class Environment */ public $store; + /** + * @var array + */ + public $storeUnreduced; + /** * @var integer */ diff --git a/scssphp/src/Exception/CompilerException.php b/scssphp/src/Exception/CompilerException.php index 7ca2e2b..c91ec96 100755 --- a/scssphp/src/Exception/CompilerException.php +++ b/scssphp/src/Exception/CompilerException.php @@ -2,14 +2,14 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp\Exception; +namespace ScssPhp\ScssPhp\Exception; /** * Compiler exception diff --git a/scssphp/src/Exception/ParserException.php b/scssphp/src/Exception/ParserException.php index 6d64335..62e9df4 100755 --- a/scssphp/src/Exception/ParserException.php +++ b/scssphp/src/Exception/ParserException.php @@ -2,14 +2,14 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp\Exception; +namespace ScssPhp\ScssPhp\Exception; /** * Parser Exception diff --git a/scssphp/src/Exception/RangeException.php b/scssphp/src/Exception/RangeException.php index 3ba6bf1..5f7537f 100755 --- a/scssphp/src/Exception/RangeException.php +++ b/scssphp/src/Exception/RangeException.php @@ -2,14 +2,14 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp\Exception; +namespace ScssPhp\ScssPhp\Exception; /** * Range exception diff --git a/scssphp/src/Exception/ServerException.php b/scssphp/src/Exception/ServerException.php index d0ed084..4853344 100755 --- a/scssphp/src/Exception/ServerException.php +++ b/scssphp/src/Exception/ServerException.php @@ -2,14 +2,14 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp\Exception; +namespace ScssPhp\ScssPhp\Exception; /** * Server Exception diff --git a/scssphp/src/Formatter.php b/scssphp/src/Formatter.php index b4f90aa..eb09c39 100755 --- a/scssphp/src/Formatter.php +++ b/scssphp/src/Formatter.php @@ -2,17 +2,17 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp; +namespace ScssPhp\ScssPhp; -use Leafo\ScssPhp\Formatter\OutputBlock; -use Leafo\ScssPhp\SourceMap\SourceMapGenerator; +use ScssPhp\ScssPhp\Formatter\OutputBlock; +use ScssPhp\ScssPhp\SourceMap\SourceMapGenerator; /** * Base formatter @@ -62,7 +62,7 @@ abstract class Formatter public $keepSemicolons; /** - * @var \Leafo\ScssPhp\Formatter\OutputBlock + * @var \ScssPhp\ScssPhp\Formatter\OutputBlock */ protected $currentBlock; @@ -77,10 +77,15 @@ abstract class Formatter protected $currentColumn; /** - * @var \Leafo\ScssPhp\SourceMap\SourceMapGenerator + * @var \ScssPhp\ScssPhp\SourceMap\SourceMapGenerator */ protected $sourceMapGenerator; + /** + * @var string + */ + protected $strippedSemicolon; + /** * Initialize formatter * @@ -114,35 +119,30 @@ public function property($name, $value) } /** - * Strip semi-colon appended by property(); it's a separator, not a terminator + * Return custom property assignment + * differs in that you have to keep spaces in the value as is * * @api * - * @param array $lines + * @param string $name + * @param mixed $value + * + * @return string */ - public function stripSemicolon(&$lines) + public function customProperty($name, $value) { - if ($this->keepSemicolons) { - return; - } - - if (($count = count($lines)) - && substr($lines[$count - 1], -1) === ';' - ) { - $lines[$count - 1] = substr($lines[$count - 1], 0, -1); - } + return rtrim($name) . trim($this->assignSeparator) . $value . ';'; } /** * Output lines inside a block * - * @param \Leafo\ScssPhp\Formatter\OutputBlock $block + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block */ protected function blockLines(OutputBlock $block) { $inner = $this->indentStr(); - - $glue = $this->break . $inner; + $glue = $this->break . $inner; $this->write($inner . implode($glue, $block->lines)); @@ -154,7 +154,7 @@ protected function blockLines(OutputBlock $block) /** * Output block selectors * - * @param \Leafo\ScssPhp\Formatter\OutputBlock $block + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block */ protected function blockSelectors(OutputBlock $block) { @@ -168,7 +168,7 @@ protected function blockSelectors(OutputBlock $block) /** * Output block children * - * @param \Leafo\ScssPhp\Formatter\OutputBlock $block + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block */ protected function blockChildren(OutputBlock $block) { @@ -180,7 +180,7 @@ protected function blockChildren(OutputBlock $block) /** * Output non-empty block * - * @param \Leafo\ScssPhp\Formatter\OutputBlock $block + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block */ protected function block(OutputBlock $block) { @@ -209,6 +209,10 @@ protected function block(OutputBlock $block) if (! empty($block->selectors)) { $this->indentLevel--; + if (! $this->keepSemicolons) { + $this->strippedSemicolon = ''; + } + if (empty($block->children)) { $this->write($this->break); } @@ -217,13 +221,41 @@ protected function block(OutputBlock $block) } } + /** + * Test and clean safely empty children + * + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block + * + * @return boolean + */ + protected function testEmptyChildren($block) + { + $isEmpty = empty($block->lines); + + if ($block->children) { + foreach ($block->children as $k => &$child) { + if (! $this->testEmptyChildren($child)) { + $isEmpty = false; + continue; + } + + if ($child->type === Type::T_MEDIA || $child->type === Type::T_DIRECTIVE) { + $child->children = []; + $child->selectors = null; + } + } + } + + return $isEmpty; + } + /** * Entry point to formatting a block * * @api * - * @param \Leafo\ScssPhp\Formatter\OutputBlock $block An abstract syntax tree - * @param \Leafo\ScssPhp\SourceMap\SourceMapGenerator|null $sourceMapGenerator Optional source map generator + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block An abstract syntax tree + * @param \ScssPhp\ScssPhp\SourceMap\SourceMapGenerator|null $sourceMapGenerator Optional source map generator * * @return string */ @@ -232,11 +264,13 @@ public function format(OutputBlock $block, SourceMapGenerator $sourceMapGenerato $this->sourceMapGenerator = null; if ($sourceMapGenerator) { - $this->currentLine = 1; - $this->currentColumn = 0; + $this->currentLine = 1; + $this->currentColumn = 0; $this->sourceMapGenerator = $sourceMapGenerator; } + $this->testEmptyChildren($block); + ob_start(); $this->block($block); @@ -247,26 +281,49 @@ public function format(OutputBlock $block, SourceMapGenerator $sourceMapGenerato } /** + * Output content + * * @param string $str */ protected function write($str) { + if (! empty($this->strippedSemicolon)) { + echo $this->strippedSemicolon; + + $this->strippedSemicolon = ''; + } + + /* + * Maybe Strip semi-colon appended by property(); it's a separator, not a terminator + * will be striped for real before a closing, otherwise displayed unchanged starting the next write + */ + if (! $this->keepSemicolons && + $str && + (strpos($str, ';') !== false) && + (substr($str, -1) === ';') + ) { + $str = substr($str, 0, -1); + + $this->strippedSemicolon = ';'; + } + if ($this->sourceMapGenerator) { $this->sourceMapGenerator->addMapping( $this->currentLine, $this->currentColumn, $this->currentBlock->sourceLine, - $this->currentBlock->sourceColumn - 1, //columns from parser are off by one + //columns from parser are off by one + $this->currentBlock->sourceColumn > 0 ? $this->currentBlock->sourceColumn - 1 : 0, $this->currentBlock->sourceName ); $lines = explode("\n", $str); - $lineCount = count($lines); + $lineCount = \count($lines); $this->currentLine += $lineCount-1; $lastLine = array_pop($lines); - $this->currentColumn = ($lineCount === 1 ? $this->currentColumn : 0) + strlen($lastLine); + $this->currentColumn = ($lineCount === 1 ? $this->currentColumn : 0) + \strlen($lastLine); } echo $str; diff --git a/scssphp/src/Formatter/Compact.php b/scssphp/src/Formatter/Compact.php index 4efa1a0..a166ed9 100755 --- a/scssphp/src/Formatter/Compact.php +++ b/scssphp/src/Formatter/Compact.php @@ -2,16 +2,16 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp\Formatter; +namespace ScssPhp\ScssPhp\Formatter; -use Leafo\ScssPhp\Formatter; +use ScssPhp\ScssPhp\Formatter; /** * Compact formatter diff --git a/scssphp/src/Formatter/Compressed.php b/scssphp/src/Formatter/Compressed.php index 1faa7e1..f400d92 100755 --- a/scssphp/src/Formatter/Compressed.php +++ b/scssphp/src/Formatter/Compressed.php @@ -2,17 +2,17 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp\Formatter; +namespace ScssPhp\ScssPhp\Formatter; -use Leafo\ScssPhp\Formatter; -use Leafo\ScssPhp\Formatter\OutputBlock; +use ScssPhp\ScssPhp\Formatter; +use ScssPhp\ScssPhp\Formatter\OutputBlock; /** * Compressed formatter @@ -59,4 +59,23 @@ public function blockLines(OutputBlock $block) $this->write($this->break); } } + + /** + * Output block selectors + * + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block + */ + protected function blockSelectors(OutputBlock $block) + { + $inner = $this->indentStr(); + + $this->write( + $inner + . implode( + $this->tagSeparator, + str_replace([' > ', ' + ', ' ~ '], ['>', '+', '~'], $block->selectors) + ) + . $this->open . $this->break + ); + } } diff --git a/scssphp/src/Formatter/Crunched.php b/scssphp/src/Formatter/Crunched.php index 42d77b5..c2aea99 100755 --- a/scssphp/src/Formatter/Crunched.php +++ b/scssphp/src/Formatter/Crunched.php @@ -2,17 +2,17 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp\Formatter; +namespace ScssPhp\ScssPhp\Formatter; -use Leafo\ScssPhp\Formatter; -use Leafo\ScssPhp\Formatter\OutputBlock; +use ScssPhp\ScssPhp\Formatter; +use ScssPhp\ScssPhp\Formatter\OutputBlock; /** * Crunched formatter @@ -57,4 +57,23 @@ public function blockLines(OutputBlock $block) $this->write($this->break); } } + + /** + * Output block selectors + * + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block + */ + protected function blockSelectors(OutputBlock $block) + { + $inner = $this->indentStr(); + + $this->write( + $inner + . implode( + $this->tagSeparator, + str_replace([' > ', ' + ', ' ~ '], ['>', '+', '~'], $block->selectors) + ) + . $this->open . $this->break + ); + } } diff --git a/scssphp/src/Formatter/Debug.php b/scssphp/src/Formatter/Debug.php index bfcbf41..6a2848d 100755 --- a/scssphp/src/Formatter/Debug.php +++ b/scssphp/src/Formatter/Debug.php @@ -2,17 +2,17 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp\Formatter; +namespace ScssPhp\ScssPhp\Formatter; -use Leafo\ScssPhp\Formatter; -use Leafo\ScssPhp\Formatter\OutputBlock; +use ScssPhp\ScssPhp\Formatter; +use ScssPhp\ScssPhp\Formatter\OutputBlock; /** * Debug formatter diff --git a/scssphp/src/Formatter/Expanded.php b/scssphp/src/Formatter/Expanded.php index d8c1e88..e3510fa 100755 --- a/scssphp/src/Formatter/Expanded.php +++ b/scssphp/src/Formatter/Expanded.php @@ -2,17 +2,17 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp\Formatter; +namespace ScssPhp\ScssPhp\Formatter; -use Leafo\ScssPhp\Formatter; -use Leafo\ScssPhp\Formatter\OutputBlock; +use ScssPhp\ScssPhp\Formatter; +use ScssPhp\ScssPhp\Formatter\OutputBlock; /** * Expanded formatter @@ -55,7 +55,7 @@ protected function blockLines(OutputBlock $block) foreach ($block->lines as $index => $line) { if (substr($line, 0, 2) === '/*') { - $block->lines[$index] = preg_replace('/(\r|\n)+/', $glue, $line); + $block->lines[$index] = preg_replace('/[\r\n]+/', $glue, $line); } } diff --git a/scssphp/src/Formatter/Nested.php b/scssphp/src/Formatter/Nested.php index 8f72206..7179908 100755 --- a/scssphp/src/Formatter/Nested.php +++ b/scssphp/src/Formatter/Nested.php @@ -2,17 +2,18 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp\Formatter; +namespace ScssPhp\ScssPhp\Formatter; -use Leafo\ScssPhp\Formatter; -use Leafo\ScssPhp\Formatter\OutputBlock; +use ScssPhp\ScssPhp\Formatter; +use ScssPhp\ScssPhp\Formatter\OutputBlock; +use ScssPhp\ScssPhp\Type; /** * Nested formatter @@ -57,63 +58,54 @@ protected function indentStr() protected function blockLines(OutputBlock $block) { $inner = $this->indentStr(); - - $glue = $this->break . $inner; + $glue = $this->break . $inner; foreach ($block->lines as $index => $line) { if (substr($line, 0, 2) === '/*') { - $block->lines[$index] = preg_replace('/(\r|\n)+/', $glue, $line); + $block->lines[$index] = preg_replace('/[\r\n]+/', $glue, $line); } } $this->write($inner . implode($glue, $block->lines)); - - if (! empty($block->children)) { - $this->write($this->break); - } } /** * {@inheritdoc} */ - protected function blockSelectors(OutputBlock $block) + protected function block(OutputBlock $block) { - $inner = $this->indentStr(); - - $this->write($inner - . implode($this->tagSeparator, $block->selectors) - . $this->open . $this->break); - } + static $depths; + static $downLevel; + static $closeBlock; + static $previousEmpty; + static $previousHasSelector; - /** - * {@inheritdoc} - */ - protected function blockChildren(OutputBlock $block) - { - foreach ($block->children as $i => $child) { - $this->block($child); + if ($block->type === 'root') { + $depths = [ 0 ]; + $downLevel = ''; + $closeBlock = ''; + $this->depth = 0; + $previousEmpty = false; + $previousHasSelector = false; + } - if ($i < count($block->children) - 1) { - $this->write($this->break); + $isMediaOrDirective = \in_array($block->type, [Type::T_DIRECTIVE, Type::T_MEDIA]); + $isSupport = ($block->type === Type::T_DIRECTIVE + && $block->selectors && strpos(implode('', $block->selectors), '@supports') !== false); - if (isset($block->children[$i + 1])) { - $next = $block->children[$i + 1]; + while ($block->depth < end($depths) || ($block->depth == 1 && end($depths) == 1)) { + array_pop($depths); + $this->depth--; - if ($next->depth === max($block->depth, 1) && $child->depth >= $next->depth) { - $this->write($this->break); - } - } + if (! $this->depth && ($block->depth <= 1 || (! $this->indentLevel && $block->type === Type::T_COMMENT)) && + (($block->selectors && ! $isMediaOrDirective) || $previousHasSelector) + ) { + $downLevel = $this->break; } - } - } - /** - * {@inheritdoc} - */ - protected function block(OutputBlock $block) - { - if ($block->type === 'root') { - $this->adjustAllChildren($block); + if (empty($block->lines) && empty($block->children)) { + $previousEmpty = true; + } } if (empty($block->lines) && empty($block->children)) { @@ -122,27 +114,94 @@ protected function block(OutputBlock $block) $this->currentBlock = $block; + if (! empty($block->lines) || (! empty($block->children) && ($this->depth < 1 || $isSupport))) { + if ($block->depth > end($depths)) { + if (! $previousEmpty || $this->depth < 1) { + $this->depth++; - $this->depth = $block->depth; + $depths[] = $block->depth; + } else { + // keep the current depth unchanged but take the block depth as a new reference for following blocks + array_pop($depths); + + $depths[] = $block->depth; + } + } + } + + $previousEmpty = ($block->type === Type::T_COMMENT); + $previousHasSelector = false; if (! empty($block->selectors)) { + if ($closeBlock) { + $this->write($closeBlock); + $closeBlock = ''; + } + + if ($downLevel) { + $this->write($downLevel); + $downLevel = ''; + } + $this->blockSelectors($block); $this->indentLevel++; } if (! empty($block->lines)) { + if ($closeBlock) { + $this->write($closeBlock); + $closeBlock = ''; + } + + if ($downLevel) { + $this->write($downLevel); + $downLevel = ''; + } + $this->blockLines($block); + + $closeBlock = $this->break; } if (! empty($block->children)) { - $this->blockChildren($block); + if ($this->depth > 0 && ($isMediaOrDirective || ! $this->hasFlatChild($block))) { + array_pop($depths); + + $this->depth--; + $this->blockChildren($block); + $this->depth++; + + $depths[] = $block->depth; + } else { + $this->blockChildren($block); + } + } + + // reclear to not be spoiled by children if T_DIRECTIVE + if ($block->type === Type::T_DIRECTIVE) { + $previousHasSelector = false; } if (! empty($block->selectors)) { $this->indentLevel--; + if (! $this->keepSemicolons) { + $this->strippedSemicolon = ''; + } + $this->write($this->close); + + $closeBlock = $this->break; + + if ($this->depth > 1 && ! empty($block->children)) { + array_pop($depths); + $this->depth--; + } + + if (! $isMediaOrDirective) { + $previousHasSelector = true; + } } if ($block->type === 'root') { @@ -151,51 +210,20 @@ protected function block(OutputBlock $block) } /** - * Adjust the depths of all children, depth first + * Block has flat child * - * @param \Leafo\ScssPhp\Formatter\OutputBlock $block + * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block + * + * @return boolean */ - private function adjustAllChildren(OutputBlock $block) + private function hasFlatChild($block) { - // flatten empty nested blocks - $children = []; - - foreach ($block->children as $i => $child) { - if (empty($child->lines) && empty($child->children)) { - if (isset($block->children[$i + 1])) { - $block->children[$i + 1]->depth = $child->depth; - } - - continue; - } - - $children[] = $child; - } - - $count = count($children); - - for ($i = 0; $i < $count; $i++) { - $depth = $children[$i]->depth; - $j = $i + 1; - - if (isset($children[$j]) && $depth < $children[$j]->depth) { - $childDepth = $children[$j]->depth; - - for (; $j < $count; $j++) { - if ($depth < $children[$j]->depth && $childDepth >= $children[$j]->depth) { - $children[$j]->depth = $depth + 1; - } - } + foreach ($block->children as $child) { + if (empty($child->selectors)) { + return true; } } - $block->children = $children; - - // make relative to parent - foreach ($block->children as $child) { - $this->adjustAllChildren($child); - - $child->depth = $child->depth - $block->depth; - } + return false; } } diff --git a/scssphp/src/Formatter/OutputBlock.php b/scssphp/src/Formatter/OutputBlock.php index 5eb589c..24841a5 100755 --- a/scssphp/src/Formatter/OutputBlock.php +++ b/scssphp/src/Formatter/OutputBlock.php @@ -2,14 +2,14 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp\Formatter; +namespace ScssPhp\ScssPhp\Formatter; /** * Output block @@ -44,7 +44,7 @@ class OutputBlock public $children; /** - * @var \Leafo\ScssPhp\Formatter\OutputBlock + * @var \ScssPhp\ScssPhp\Formatter\OutputBlock */ public $parent; diff --git a/scssphp/src/Node.php b/scssphp/src/Node.php index b9f7945..cab9a4b 100755 --- a/scssphp/src/Node.php +++ b/scssphp/src/Node.php @@ -2,14 +2,14 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp; +namespace ScssPhp\ScssPhp; /** * Base node diff --git a/scssphp/src/Node/Number.php b/scssphp/src/Node/Number.php index 42c1680..4e6f664 100755 --- a/scssphp/src/Node/Number.php +++ b/scssphp/src/Node/Number.php @@ -2,18 +2,18 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp\Node; +namespace ScssPhp\ScssPhp\Node; -use Leafo\ScssPhp\Compiler; -use Leafo\ScssPhp\Node; -use Leafo\ScssPhp\Type; +use ScssPhp\ScssPhp\Compiler; +use ScssPhp\ScssPhp\Node; +use ScssPhp\ScssPhp\Type; /** * Dimension + optional units @@ -31,14 +31,14 @@ class Number extends Node implements \ArrayAccess /** * @var integer */ - static public $precision = 10; + public static $precision = 10; /** * @see http://www.w3.org/TR/2012/WD-css3-values-20120308/ * * @var array */ - static protected $unitTable = [ + protected static $unitTable = [ 'in' => [ 'in' => 1, 'pc' => 6, @@ -64,8 +64,8 @@ class Number extends Node implements \ArrayAccess ], 'dpi' => [ 'dpi' => 1, - 'dpcm' => 2.54, - 'dppx' => 96, + 'dpcm' => 1/2.54, + 'dppx' => 1/96, ], ]; @@ -89,7 +89,7 @@ public function __construct($dimension, $initialUnit) { $this->type = Type::T_NUMBER; $this->dimension = $dimension; - $this->units = is_array($initialUnit) + $this->units = \is_array($initialUnit) ? $initialUnit : ($initialUnit ? [$initialUnit => 1] : []); @@ -100,7 +100,7 @@ public function __construct($dimension, $initialUnit) * * @param array $units * - * @return \Leafo\ScssPhp\Node\Number + * @return \ScssPhp\ScssPhp\Node\Number */ public function coerce($units) { @@ -110,11 +110,18 @@ public function coerce($units) $dimension = $this->dimension; - foreach (static::$unitTable['in'] as $unit => $conv) { - $from = isset($this->units[$unit]) ? $this->units[$unit] : 0; - $to = isset($units[$unit]) ? $units[$unit] : 0; - $factor = pow($conv, $from - $to); - $dimension /= $factor; + if (\count($units)) { + $baseUnit = array_keys($units); + $baseUnit = reset($baseUnit); + $baseUnit = $this->findBaseUnit($baseUnit); + if ($baseUnit && isset(static::$unitTable[$baseUnit])) { + foreach (static::$unitTable[$baseUnit] as $unit => $conv) { + $from = isset($this->units[$unit]) ? $this->units[$unit] : 0; + $to = isset($units[$unit]) ? $units[$unit] : 0; + $factor = pow($conv, $from - $to); + $dimension /= $factor; + } + } } return new Number($dimension, $units); @@ -123,14 +130,14 @@ public function coerce($units) /** * Normalize number * - * @return \Leafo\ScssPhp\Node\Number + * @return \ScssPhp\ScssPhp\Node\Number */ public function normalize() { $dimension = $this->dimension; $units = []; - $this->normalizeUnits($dimension, $units, 'in'); + $this->normalizeUnits($dimension, $units); return new Number($dimension, $units); } @@ -141,17 +148,17 @@ public function normalize() public function offsetExists($offset) { if ($offset === -3) { - return $this->sourceColumn !== null; + return ! \is_null($this->sourceColumn); } if ($offset === -2) { - return $this->sourceLine !== null; + return ! \is_null($this->sourceLine); } - if ($offset === -1 - || $offset === 0 - || $offset === 1 - || $offset === 2 + if ($offset === -1 || + $offset === 0 || + $offset === 1 || + $offset === 2 ) { return true; } @@ -231,6 +238,35 @@ public function unitless() return ! array_sum($this->units); } + /** + * Test if a number can be normalized in a base unit + * ie if its units are homogeneous + * + * @return boolean + */ + public function isNormalizable() + { + if ($this->unitless()) { + return false; + } + + $baseUnit = null; + + foreach ($this->units as $unit => $exp) { + $b = $this->findBaseUnit($unit); + + if (\is_null($baseUnit)) { + $baseUnit = $b; + } + + if (\is_null($b) or $b !== $baseUnit) { + return false; + } + } + + return $baseUnit; + } + /** * Returns unit(s) as the product of numerator units divided by the product of denominator units * @@ -243,23 +279,23 @@ public function unitStr() foreach ($this->units as $unit => $unitSize) { if ($unitSize > 0) { - $numerators = array_pad($numerators, count($numerators) + $unitSize, $unit); + $numerators = array_pad($numerators, \count($numerators) + $unitSize, $unit); continue; } if ($unitSize < 0) { - $denominators = array_pad($denominators, count($denominators) + $unitSize, $unit); + $denominators = array_pad($denominators, \count($denominators) - $unitSize, $unit); continue; } } - return implode('*', $numerators) . (count($denominators) ? '/' . implode('*', $denominators) : ''); + return implode('*', $numerators) . (\count($denominators) ? '/' . implode('*', $denominators) : ''); } /** * Output number * - * @param \Leafo\ScssPhp\Compiler $compiler + * @param \ScssPhp\ScssPhp\Compiler $compiler * * @return string */ @@ -271,11 +307,11 @@ public function output(Compiler $compiler = null) return $unitSize; }); - if (count($units) > 1 && array_sum($units) === 0) { + if (\count($units) > 1 && array_sum($units) === 0) { $dimension = $this->dimension; $units = []; - $this->normalizeUnits($dimension, $units, 'in'); + $this->normalizeUnits($dimension, $units); $dimension = round($dimension, static::$precision); $units = array_filter($units, function ($unitSize) { @@ -285,12 +321,14 @@ public function output(Compiler $compiler = null) $unitSize = array_sum($units); - if ($compiler && ($unitSize > 1 || $unitSize < 0 || count($units) > 1)) { - $compiler->throwError((string) $dimension . $this->unitStr() . " isn't a valid CSS value."); + if ($compiler && ($unitSize > 1 || $unitSize < 0 || \count($units) > 1)) { + $this->units = $units; + $unit = $this->unitStr(); + } else { + reset($units); + $unit = key($units); } - reset($units); - $unit = key($units); $dimension = number_format($dimension, static::$precision, '.', ''); return (static::$precision ? rtrim(rtrim($dimension, '0'), '.') : $dimension) . $unit; @@ -311,13 +349,17 @@ public function __toString() * @param array $units * @param string $baseUnit */ - private function normalizeUnits(&$dimension, &$units, $baseUnit = 'in') + private function normalizeUnits(&$dimension, &$units, $baseUnit = null) { $dimension = $this->dimension; $units = []; foreach ($this->units as $unit => $exp) { - if (isset(static::$unitTable[$baseUnit][$unit])) { + if (! $baseUnit) { + $baseUnit = $this->findBaseUnit($unit); + } + + if ($baseUnit && isset(static::$unitTable[$baseUnit][$unit])) { $factor = pow(static::$unitTable[$baseUnit][$unit], $exp); $unit = $baseUnit; @@ -327,4 +369,22 @@ private function normalizeUnits(&$dimension, &$units, $baseUnit = 'in') $units[$unit] = $exp + (isset($units[$unit]) ? $units[$unit] : 0); } } + + /** + * Find the base unit family for a given unit + * + * @param string $unit + * + * @return string|null + */ + private function findBaseUnit($unit) + { + foreach (static::$unitTable as $baseUnit => $unitVariants) { + if (isset($unitVariants[$unit])) { + return $baseUnit; + } + } + + return null; + } } diff --git a/scssphp/src/Parser.php b/scssphp/src/Parser.php index 6fdea3e..da1566c 100755 --- a/scssphp/src/Parser.php +++ b/scssphp/src/Parser.php @@ -2,20 +2,21 @@ /** * SCSSPHP * - * @copyright 2012-2018 Leaf Corcoran + * @copyright 2012-2020 Leaf Corcoran * * @license http://opensource.org/licenses/MIT MIT * - * @link http://leafo.github.io/scssphp + * @link http://scssphp.github.io/scssphp */ -namespace Leafo\ScssPhp; +namespace ScssPhp\ScssPhp; -use Leafo\ScssPhp\Block; -use Leafo\ScssPhp\Compiler; -use Leafo\ScssPhp\Exception\ParserException; -use Leafo\ScssPhp\Node; -use Leafo\ScssPhp\Type; +use ScssPhp\ScssPhp\Block; +use ScssPhp\ScssPhp\Cache; +use ScssPhp\ScssPhp\Compiler; +use ScssPhp\ScssPhp\Exception\ParserException; +use ScssPhp\ScssPhp\Node; +use ScssPhp\ScssPhp\Type; /** * Parser @@ -53,6 +54,8 @@ class Parser protected static $operatorPattern; protected static $whitePattern; + protected $cache; + private $sourceName; private $sourceIndex; private $sourcePositions; @@ -61,27 +64,37 @@ class Parser private $env; private $inParens; private $eatWhiteDefault; + private $discardComments; + private $allowVars; private $buffer; private $utf8; private $encoding; private $patternModifiers; + private $commentsSeen; + + private $cssOnly; /** * Constructor * * @api * - * @param string $sourceName - * @param integer $sourceIndex - * @param string $encoding + * @param string $sourceName + * @param integer $sourceIndex + * @param string $encoding + * @param \ScssPhp\ScssPhp\Cache $cache */ - public function __construct($sourceName, $sourceIndex = 0, $encoding = 'utf-8') + public function __construct($sourceName, $sourceIndex = 0, $encoding = 'utf-8', $cache = null, $cssOnly = false) { $this->sourceName = $sourceName ?: '(stdin)'; $this->sourceIndex = $sourceIndex; $this->charset = null; $this->utf8 = ! $encoding || strtolower($encoding) === 'utf-8'; $this->patternModifiers = $this->utf8 ? 'Aisu' : 'Ais'; + $this->commentsSeen = []; + $this->commentsSeen = []; + $this->allowVars = true; + $this->cssOnly = $cssOnly; if (empty(static::$operatorPattern)) { static::$operatorPattern = '([*\/%+-]|[!=]\=|\>\=?|\<\=\>|\<\=?|and|or)'; @@ -95,6 +108,10 @@ public function __construct($sourceName, $sourceIndex = 0, $encoding = 'utf-8') ? '/' . $commentSingle . '[^\n]*\s*|(' . static::$commentPattern . ')\s*|\s+/AisuS' : '/' . $commentSingle . '[^\n]*\s*|(' . static::$commentPattern . ')\s*|\s+/AisS'; } + + if ($cache) { + $this->cache = $cache; + } } /** @@ -116,18 +133,24 @@ public function getSourceName() * * @param string $msg * - * @throws \Leafo\ScssPhp\Exception\ParserException + * @throws \ScssPhp\ScssPhp\Exception\ParserException */ public function throwParseError($msg = 'parse error') { - list($line, /* $column */) = $this->getSourcePosition($this->count); + list($line, $column) = $this->getSourcePosition($this->count); - $loc = empty($this->sourceName) ? "line: $line" : "$this->sourceName on line $line"; + $loc = empty($this->sourceName) + ? "line: $line, column: $column" + : "$this->sourceName on line $line, at column $column"; if ($this->peek("(.*?)(\n|$)", $m, $this->count)) { + $this->restoreEncoding(); + throw new ParserException("$msg: failed at `$m[1]` $loc"); } + $this->restoreEncoding(); + throw new ParserException("$msg: $loc"); } @@ -138,10 +161,23 @@ public function throwParseError($msg = 'parse error') * * @param string $buffer * - * @return \Leafo\ScssPhp\Block + * @return \ScssPhp\ScssPhp\Block */ public function parse($buffer) { + if ($this->cache) { + $cacheKey = $this->sourceName . ":" . md5($buffer); + $parseOptions = [ + 'charset' => $this->charset, + 'utf8' => $this->utf8, + ]; + $v = $this->cache->getCache("parse", $cacheKey, $parseOptions); + + if (! \is_null($v)) { + return $v; + } + } + // strip BOM (byte order marker) if (substr($buffer, 0, 3) === "\xef\xbb\xbf") { $buffer = substr($buffer, 3); @@ -165,7 +201,7 @@ public function parse($buffer) ; } - if ($this->count !== strlen($this->buffer)) { + if ($this->count !== \strlen($this->buffer)) { $this->throwParseError(); } @@ -177,10 +213,12 @@ public function parse($buffer) array_unshift($this->env->children, $this->charset); } - $this->env->isRoot = true; - $this->restoreEncoding(); + if ($this->cache) { + $this->cache->setCache("parse", $cacheKey, $this->env, $parseOptions); + } + return $this->env; } @@ -189,8 +227,8 @@ public function parse($buffer) * * @api * - * @param string $buffer - * @param string $out + * @param string $buffer + * @param string|array $out * * @return boolean */ @@ -216,8 +254,8 @@ public function parseValue($buffer, &$out) * * @api * - * @param string $buffer - * @param string $out + * @param string $buffer + * @param string|array $out * * @return boolean */ @@ -238,6 +276,33 @@ public function parseSelector($buffer, &$out) return $selector; } + /** + * Parse a media Query + * + * @api + * + * @param string $buffer + * @param string|array $out + * + * @return boolean + */ + public function parseMediaQueryList($buffer, &$out) + { + $this->count = 0; + $this->env = null; + $this->inParens = false; + $this->eatWhiteDefault = true; + $this->buffer = (string) $buffer; + + $this->saveEncoding(); + + $isMediaQuery = $this->mediaQueryList($out); + + $this->restoreEncoding(); + + return $isMediaQuery; + } + /** * Parse a single chunk off the head of the buffer and append it to the * current parse environment. @@ -271,7 +336,7 @@ public function parseSelector($buffer, &$out) * the buffer position will be left at an invalid state. In order to * avoid this, Compiler::seek() is used to remember and set buffer positions. * - * Before parsing a chain, use $s = $this->seek() to remember the current + * Before parsing a chain, use $s = $this->count to remember the current * position into $s. Then if a chain fails, use $this->seek($s) to * go back where we started. * @@ -279,25 +344,32 @@ public function parseSelector($buffer, &$out) */ protected function parseChunk() { - $s = $this->seek(); + $s = $this->count; // the directives if (isset($this->buffer[$this->count]) && $this->buffer[$this->count] === '@') { - if ($this->literal('@at-root') && + if ($this->literal('@at-root', 8) && ($this->selectors($selector) || true) && ($this->map($with) || true) && - $this->literal('{') + (($this->matchChar('(') + && $this->interpolation($with) + && $this->matchChar(')')) || true) && + $this->matchChar('{', false) ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $atRoot = $this->pushSpecialBlock(Type::T_AT_ROOT, $s); $atRoot->selector = $selector; - $atRoot->with = $with; + $atRoot->with = $with; return true; } $this->seek($s); - if ($this->literal('@media') && $this->mediaQueryList($mediaQueryList) && $this->literal('{')) { + if ($this->literal('@media', 6) && $this->mediaQueryList($mediaQueryList) && $this->matchChar('{', false)) { $media = $this->pushSpecialBlock(Type::T_MEDIA, $s); $media->queryList = $mediaQueryList[2]; @@ -306,11 +378,15 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@mixin') && + if ($this->literal('@mixin', 6) && $this->keyword($mixinName) && ($this->argumentDef($args) || true) && - $this->literal('{') + $this->matchChar('{', false) ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $mixin = $this->pushSpecialBlock(Type::T_MIXIN, $s); $mixin->name = $mixinName; $mixin->args = $args; @@ -320,15 +396,28 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@include') && + if ($this->literal('@include', 8) && $this->keyword($mixinName) && - ($this->literal('(') && + ($this->matchChar('(') && ($this->argValues($argValues) || true) && - $this->literal(')') || true) && + $this->matchChar(')') || true) && ($this->end() || - $this->literal('{') && $hasBlock = true) + ($this->literal('using', 5) && + $this->argumentDef($argUsing) && + ($this->end() || $this->matchChar('{') && $hasBlock = true)) || + $this->matchChar('{') && $hasBlock = true) ) { - $child = [Type::T_INCLUDE, $mixinName, isset($argValues) ? $argValues : null, null]; + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + + $child = [ + Type::T_INCLUDE, + $mixinName, + isset($argValues) ? $argValues : null, + null, + isset($argUsing) ? $argUsing : null + ]; if (! empty($hasBlock)) { $include = $this->pushSpecialBlock(Type::T_INCLUDE, $s); @@ -342,10 +431,14 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@scssphp-import-once') && + if ($this->literal('@scssphp-import-once', 20) && $this->valueList($importPath) && $this->end() ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $this->append([Type::T_SCSSPHP_IMPORT_ONCE, $importPath], $s); return true; @@ -353,7 +446,7 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@import') && + if ($this->literal('@import', 7) && $this->valueList($importPath) && $this->end() ) { @@ -364,10 +457,14 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@import') && + if ($this->literal('@import', 7) && $this->url($importPath) && $this->end() ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $this->append([Type::T_IMPORT, $importPath], $s); return true; @@ -375,10 +472,14 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@extend') && + if ($this->literal('@extend', 7) && $this->selectors($selectors) && $this->end() ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + // check for '!flag' $optional = $this->stripOptionalFlag($selectors); $this->append([Type::T_EXTEND, $selectors, $optional], $s); @@ -388,11 +489,15 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@function') && + if ($this->literal('@function', 9) && $this->keyword($fnName) && $this->argumentDef($args) && - $this->literal('{') + $this->matchChar('{', false) ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $func = $this->pushSpecialBlock(Type::T_FUNCTION, $s); $func->name = $fnName; $func->args = $args; @@ -402,7 +507,11 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@break') && $this->end()) { + if ($this->literal('@break', 6) && $this->end()) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $this->append([Type::T_BREAK], $s); return true; @@ -410,7 +519,11 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@continue') && $this->end()) { + if ($this->literal('@continue', 9) && $this->end()) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $this->append([Type::T_CONTINUE], $s); return true; @@ -418,8 +531,11 @@ protected function parseChunk() $this->seek($s); + if ($this->literal('@return', 7) && ($this->valueList($retVal) || true) && $this->end()) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } - if ($this->literal('@return') && ($this->valueList($retVal) || true) && $this->end()) { $this->append([Type::T_RETURN, isset($retVal) ? $retVal : [Type::T_NULL]], $s); return true; @@ -427,12 +543,16 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@each') && + if ($this->literal('@each', 5) && $this->genericList($varNames, 'variable', ',', false) && - $this->literal('in') && + $this->literal('in', 2) && $this->valueList($list) && - $this->literal('{') + $this->matchChar('{', false) ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $each = $this->pushSpecialBlock(Type::T_EACH, $s); foreach ($varNames[2] as $varName) { @@ -446,10 +566,14 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@while') && + if ($this->literal('@while', 6) && $this->expression($cond) && - $this->literal('{') + $this->matchChar('{', false) ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $while = $this->pushSpecialBlock(Type::T_WHILE, $s); $while->cond = $cond; @@ -458,19 +582,23 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@for') && + if ($this->literal('@for', 4) && $this->variable($varName) && - $this->literal('from') && + $this->literal('from', 4) && $this->expression($start) && - ($this->literal('through') || - ($forUntil = true && $this->literal('to'))) && + ($this->literal('through', 7) || + ($forUntil = true && $this->literal('to', 2))) && $this->expression($end) && - $this->literal('{') + $this->matchChar('{', false) ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $for = $this->pushSpecialBlock(Type::T_FOR, $s); - $for->var = $varName[1]; + $for->var = $varName[1]; $for->start = $start; - $for->end = $end; + $for->end = $end; $for->until = isset($forUntil); return true; @@ -478,9 +606,21 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@if') && $this->valueList($cond) && $this->literal('{')) { + if ($this->literal('@if', 3) && $this->valueList($cond) && $this->matchChar('{', false)) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $if = $this->pushSpecialBlock(Type::T_IF, $s); - $if->cond = $cond; + + while ($cond[0] === Type::T_LIST + && ! empty($cond['enclosing']) + && $cond['enclosing'] === 'parent' + && \count($cond[2]) == 1) { + $cond = reset($cond[2]); + } + + $if->cond = $cond; $if->cases = []; return true; @@ -488,10 +628,14 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@debug') && + if ($this->literal('@debug', 6) && $this->valueList($value) && $this->end() ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $this->append([Type::T_DEBUG, $value], $s); return true; @@ -499,10 +643,14 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@warn') && + if ($this->literal('@warn', 5) && $this->valueList($value) && $this->end() ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $this->append([Type::T_WARN, $value], $s); return true; @@ -510,10 +658,14 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@error') && + if ($this->literal('@error', 6) && $this->valueList($value) && $this->end() ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $this->append([Type::T_ERROR, $value], $s); return true; @@ -521,8 +673,18 @@ protected function parseChunk() $this->seek($s); - if ($this->literal('@content') && $this->end()) { - $this->append([Type::T_MIXIN_CONTENT], $s); + if ($this->literal('@content', 8) && + ($this->end() || + $this->matchChar('(') && + $this->argValues($argContent) && + $this->matchChar(')') && + $this->end()) + ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + + $this->append([Type::T_MIXIN_CONTENT, isset($argContent) ? $argContent : null], $s); return true; } @@ -534,10 +696,10 @@ protected function parseChunk() if (isset($last) && $last[0] === Type::T_IF) { list(, $if) = $last; - if ($this->literal('@else')) { - if ($this->literal('{')) { + if ($this->literal('@else', 5)) { + if ($this->matchChar('{', false)) { $else = $this->pushSpecialBlock(Type::T_ELSE, $s); - } elseif ($this->literal('if') && $this->valueList($cond) && $this->literal('{')) { + } elseif ($this->literal('if', 2) && $this->valueList($cond) && $this->matchChar('{', false)) { $else = $this->pushSpecialBlock(Type::T_ELSEIF, $s); $else->cond = $cond; } @@ -554,7 +716,7 @@ protected function parseChunk() } // only retain the first @charset directive encountered - if ($this->literal('@charset') && + if ($this->literal('@charset', 8) && $this->valueList($charset) && $this->end() ) { @@ -575,11 +737,23 @@ protected function parseChunk() $this->seek($s); + if ($this->literal('@supports', 9) && + ($t1=$this->supportsQuery($supportQuery)) && + ($t2=$this->matchChar('{', false)) + ) { + $directive = $this->pushSpecialBlock(Type::T_DIRECTIVE, $s); + $directive->name = 'supports'; + $directive->value = $supportQuery; + + return true; + } + + $this->seek($s); + // doesn't match built in directive, do generic one - if ($this->literal('@', false) && + if ($this->matchChar('@', false) && $this->keyword($dirName) && - ($this->variable($dirValue) || $this->openString('{', $dirValue) || true) && - $this->literal('{') + $this->directiveValue($dirValue, '{') ) { if ($dirName === 'media') { $directive = $this->pushSpecialBlock(Type::T_MEDIA, $s); @@ -597,13 +771,71 @@ protected function parseChunk() $this->seek($s); + // maybe it's a generic blockless directive + if ($this->matchChar('@', false) && + $this->keyword($dirName) && + $this->directiveValue($dirValue) && + $this->end() + ) { + $this->append([Type::T_DIRECTIVE, [$dirName, $dirValue]], $s); + + return true; + } + + $this->seek($s); + return false; } + // custom properties : right part is static + if (($this->customProperty($name) || ($this->cssOnly && $this->propertyName($name))) && + $this->matchChar(':', false) + ) { + $start = $this->count; + + // but can be complex and finish with ; or } + foreach ([';','}'] as $ending) { + if ($this->openString($ending, $stringValue, '(', ')', false) && + $this->end() + ) { + $end = $this->count; + $value = $stringValue; + + // check if we have only a partial value due to nested [] or { } to take in account + $nestingPairs = [['[', ']'], ['{', '}']]; + + foreach ($nestingPairs as $nestingPair) { + $p = strpos($this->buffer, $nestingPair[0], $start); + + if ($p && $p < $end) { + $this->seek($start); + + if ($this->openString($ending, $stringValue, $nestingPair[0], $nestingPair[1], false) && + $this->end() && + $this->count > $end + ) { + $end = $this->count; + $value = $stringValue; + } + } + } + + $this->seek($end); + $this->append([Type::T_CUSTOM_PROPERTY, $name, $value], $s); + + return true; + } + } + + // TODO: output an error here if nothing found according to sass spec + } + + $this->seek($s); + // property shortcut // captures most properties before having to parse a selector if ($this->keyword($name, false) && - $this->literal(': ') && + $this->literal(': ', 2) && $this->valueList($value) && $this->end() ) { @@ -617,10 +849,14 @@ protected function parseChunk() // variable assigns if ($this->variable($name) && - $this->literal(':') && + $this->matchChar(':') && $this->valueList($value) && $this->end() ) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + // check for '!flag' $assignmentFlags = $this->stripAssignmentFlags($value); $this->append([Type::T_ASSIGN, $name, $value, $assignmentFlags], $s); @@ -631,31 +867,52 @@ protected function parseChunk() $this->seek($s); // misc - if ($this->literal('-->')) { + if ($this->literal('-->', 3)) { return true; } // opening css block - if ($this->selectors($selectors) && $this->literal('{')) { + if ($this->selectors($selectors) && $this->matchChar('{', false)) { + if ($this->cssOnly) { + if (! empty($this->env->parent)) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + } + $this->pushBlock($selectors, $s); + if ($this->eatWhiteDefault) { + $this->whitespace(); + $this->append(null); // collect comments at the beginning if needed + } + return true; } $this->seek($s); // property assign, or nested assign - if ($this->propertyName($name) && $this->literal(':')) { + if ($this->propertyName($name) && $this->matchChar(':')) { $foundSomething = false; if ($this->valueList($value)) { + if (empty($this->env->parent)) { + $this->throwParseError('expected "{"'); + } + $this->append([Type::T_ASSIGN, $name, $value], $s); $foundSomething = true; } - if ($this->literal('{')) { + if ($this->matchChar('{', false)) { + if ($this->cssOnly) { + $this->throwParseError("SCSS syntax not allowed in CSS file"); + } + $propBlock = $this->pushSpecialBlock(Type::T_NESTED_PROPERTY, $s); $propBlock->prefix = $name; + $propBlock->hasValue = $foundSomething; + $foundSomething = true; } elseif ($foundSomething) { $foundSomething = $this->end(); @@ -669,9 +926,15 @@ protected function parseChunk() $this->seek($s); // closing a block - if ($this->literal('}')) { + if ($this->matchChar('}', false)) { $block = $this->popBlock(); + if (! isset($block->type) || $block->type !== Type::T_IF) { + if ($this->env->parent) { + $this->append(null); // collect comments before next statement if needed + } + } + if (isset($block->type) && $block->type === Type::T_INCLUDE) { $include = $block->child; unset($block->child); @@ -682,12 +945,21 @@ protected function parseChunk() $this->append([$type, $block], $s); } + // collect comments just after the block closing if needed + if ($this->eatWhiteDefault) { + $this->whitespace(); + + if ($this->env->comments) { + $this->append(null); + } + } + return true; } // extra stuff - if ($this->literal(';') || - $this->literal('', 3)) { + if ($this->literal('-->')) { return true; } // opening css block - if ($this->selectors($selectors) && $this->matchChar('{', false)) { - if ($this->cssOnly) { - if (! empty($this->env->parent)) { - $this->throwParseError("SCSS syntax not allowed in CSS file"); - } - } - + if ($this->selectors($selectors) && $this->literal('{')) { $this->pushBlock($selectors, $s); - if ($this->eatWhiteDefault) { - $this->whitespace(); - $this->append(null); // collect comments at the beginning if needed - } - return true; } $this->seek($s); // property assign, or nested assign - if ($this->propertyName($name) && $this->matchChar(':')) { + if ($this->propertyName($name) && $this->literal(':')) { $foundSomething = false; if ($this->valueList($value)) { - if (empty($this->env->parent)) { - $this->throwParseError('expected "{"'); - } - $this->append([Type::T_ASSIGN, $name, $value], $s); $foundSomething = true; } - if ($this->matchChar('{', false)) { - if ($this->cssOnly) { - $this->throwParseError("SCSS syntax not allowed in CSS file"); - } - + if ($this->literal('{')) { $propBlock = $this->pushSpecialBlock(Type::T_NESTED_PROPERTY, $s); $propBlock->prefix = $name; - $propBlock->hasValue = $foundSomething; - $foundSomething = true; } elseif ($foundSomething) { $foundSomething = $this->end(); @@ -926,15 +669,9 @@ protected function parseChunk() $this->seek($s); // closing a block - if ($this->matchChar('}', false)) { + if ($this->literal('}')) { $block = $this->popBlock(); - if (! isset($block->type) || $block->type !== Type::T_IF) { - if ($this->env->parent) { - $this->append(null); // collect comments before next statement if needed - } - } - if (isset($block->type) && $block->type === Type::T_INCLUDE) { $include = $block->child; unset($block->child); @@ -945,21 +682,12 @@ protected function parseChunk() $this->append([$type, $block], $s); } - // collect comments just after the block closing if needed - if ($this->eatWhiteDefault) { - $this->whitespace(); - - if ($this->env->comments) { - $this->append(null); - } - } - return true; } // extra stuff - if ($this->matchChar(';') || - $this->literal('