diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-13 11:30:08 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-13 11:30:08 +0000 |
commit | 4ce65d59ca91871cfd126497158200a818720bce (patch) | |
tree | e277def01fc7eba7dbc21c4a4ae5576e8aa2cf1f /vendor/wikimedia/less.php/lib/Less/Tree/Ruleset.php | |
parent | Initial commit. (diff) | |
download | icinga-php-library-96ecad332d1684426665842bfcebf1aa4692a020.tar.xz icinga-php-library-96ecad332d1684426665842bfcebf1aa4692a020.zip |
Adding upstream version 0.13.1.upstream/0.13.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'vendor/wikimedia/less.php/lib/Less/Tree/Ruleset.php')
-rw-r--r-- | vendor/wikimedia/less.php/lib/Less/Tree/Ruleset.php | 730 |
1 files changed, 730 insertions, 0 deletions
diff --git a/vendor/wikimedia/less.php/lib/Less/Tree/Ruleset.php b/vendor/wikimedia/less.php/lib/Less/Tree/Ruleset.php new file mode 100644 index 0000000..7acc6af --- /dev/null +++ b/vendor/wikimedia/less.php/lib/Less/Tree/Ruleset.php @@ -0,0 +1,730 @@ +<?php +/** + * @private + */ +class Less_Tree_Ruleset extends Less_Tree { + + protected $lookups; + public $_variables; + public $_rulesets; + + public $strictImports; + + public $selectors; + public $rules; + public $root; + public $allowImports; + public $paths; + public $firstRoot; + public $type = 'Ruleset'; + public $multiMedia; + public $allExtends; + + public $ruleset_id; + public $originalRuleset; + + public $first_oelements; + + public function SetRulesetIndex() { + $this->ruleset_id = Less_Parser::$next_id++; + $this->originalRuleset = $this->ruleset_id; + + if ( $this->selectors ) { + foreach ( $this->selectors as $sel ) { + if ( $sel->_oelements ) { + $this->first_oelements[$sel->_oelements[0]] = true; + } + } + } + } + + /** + * @param null|Less_Tree_Selector[] $selectors + * @param Less_Tree[] $rules + * @param null|bool $strictImports + */ + public function __construct( $selectors, $rules, $strictImports = null ) { + $this->selectors = $selectors; + $this->rules = $rules; + $this->lookups = []; + $this->strictImports = $strictImports; + $this->SetRulesetIndex(); + } + + public function accept( $visitor ) { + if ( $this->paths !== null ) { + $paths_len = count( $this->paths ); + for ( $i = 0; $i < $paths_len; $i++ ) { + $this->paths[$i] = $visitor->visitArray( $this->paths[$i] ); + } + } elseif ( $this->selectors ) { + $this->selectors = $visitor->visitArray( $this->selectors ); + } + + if ( $this->rules ) { + $this->rules = $visitor->visitArray( $this->rules ); + } + } + + /** + * @param Less_Environment $env + * @return Less_Tree_Ruleset + * @see less-2.5.3.js#Ruleset.prototype.eval + */ + public function compile( $env ) { + $ruleset = $this->PrepareRuleset( $env ); + + // Store the frames around mixin definitions, + // so they can be evaluated like closures when the time comes. + $rsRuleCnt = count( $ruleset->rules ); + for ( $i = 0; $i < $rsRuleCnt; $i++ ) { + // These checks are the equivalent of the rule.evalFirst property in less.js + if ( $ruleset->rules[$i] instanceof Less_Tree_Mixin_Definition || $ruleset->rules[$i] instanceof Less_Tree_DetachedRuleset ) { + $ruleset->rules[$i] = $ruleset->rules[$i]->compile( $env ); + } + } + + $mediaBlockCount = count( $env->mediaBlocks ); + + // Evaluate mixin calls. + $this->EvalMixinCalls( $ruleset, $env, $rsRuleCnt ); + + // Evaluate everything else + for ( $i = 0; $i < $rsRuleCnt; $i++ ) { + if ( !( $ruleset->rules[$i] instanceof Less_Tree_Mixin_Definition || $ruleset->rules[$i] instanceof Less_Tree_DetachedRuleset ) ) { + $ruleset->rules[$i] = $ruleset->rules[$i]->compile( $env ); + } + } + + // Evaluate everything else + for ( $i = 0; $i < $rsRuleCnt; $i++ ) { + $rule = $ruleset->rules[$i]; + + // for rulesets, check if it is a css guard and can be removed + if ( $rule instanceof Less_Tree_Ruleset && $rule->selectors && count( $rule->selectors ) === 1 ) { + + // check if it can be folded in (e.g. & where) + if ( $rule->selectors[0]->isJustParentSelector() ) { + array_splice( $ruleset->rules, $i--, 1 ); + $rsRuleCnt--; + + for ( $j = 0; $j < count( $rule->rules ); $j++ ) { + $subRule = $rule->rules[$j]; + if ( !( $subRule instanceof Less_Tree_Rule ) || !$subRule->variable ) { + array_splice( $ruleset->rules, ++$i, 0, [ $subRule ] ); + $rsRuleCnt++; + } + } + + } + } + } + + // Pop the stack + $env->shiftFrame(); + + if ( $mediaBlockCount ) { + $len = count( $env->mediaBlocks ); + for ( $i = $mediaBlockCount; $i < $len; $i++ ) { + $env->mediaBlocks[$i]->bubbleSelectors( $ruleset->selectors ); + } + } + + return $ruleset; + } + + /** + * Compile Less_Tree_Mixin_Call objects + * + * @param Less_Tree_Ruleset $ruleset + * @param int $rsRuleCnt + */ + private function EvalMixinCalls( $ruleset, $env, &$rsRuleCnt ) { + for ( $i = 0; $i < $rsRuleCnt; $i++ ) { + $rule = $ruleset->rules[$i]; + + if ( $rule instanceof Less_Tree_Mixin_Call ) { + $rule = $rule->compile( $env ); + + $temp = []; + foreach ( $rule as $r ) { + if ( ( $r instanceof Less_Tree_Rule ) && $r->variable ) { + // do not pollute the scope if the variable is + // already there. consider returning false here + // but we need a way to "return" variable from mixins + if ( !$ruleset->variable( $r->name ) ) { + $temp[] = $r; + } + } else { + $temp[] = $r; + } + } + $temp_count = count( $temp ) - 1; + array_splice( $ruleset->rules, $i, 1, $temp ); + $rsRuleCnt += $temp_count; + $i += $temp_count; + $ruleset->resetCache(); + + } elseif ( $rule instanceof Less_Tree_RulesetCall ) { + + $rule = $rule->compile( $env ); + $rules = []; + foreach ( $rule->rules as $r ) { + if ( ( $r instanceof Less_Tree_Rule ) && $r->variable ) { + continue; + } + $rules[] = $r; + } + + array_splice( $ruleset->rules, $i, 1, $rules ); + $temp_count = count( $rules ); + $rsRuleCnt += $temp_count - 1; + $i += $temp_count - 1; + $ruleset->resetCache(); + } + + } + } + + /** + * Compile the selectors and create a new ruleset object for the compile() method + * + * @param Less_Environment $env + * @return Less_Tree_Ruleset + */ + private function PrepareRuleset( $env ) { + // NOTE: Preserve distinction between null and empty array when compiling + // $this->selectors to $selectors + $thisSelectors = $this->selectors; + $selectors = null; + $hasOnePassingSelector = false; + + if ( $thisSelectors ) { + Less_Tree_DefaultFunc::error( "it is currently only allowed in parametric mixin guards," ); + + $selectors = []; + foreach ( $thisSelectors as $s ) { + $selector = $s->compile( $env ); + $selectors[] = $selector; + if ( $selector->evaldCondition ) { + $hasOnePassingSelector = true; + } + } + + Less_Tree_DefaultFunc::reset(); + } else { + $hasOnePassingSelector = true; + } + + if ( $this->rules && $hasOnePassingSelector ) { + // Copy the array (no need for slice in PHP) + $rules = $this->rules; + } else { + $rules = []; + } + + $ruleset = new Less_Tree_Ruleset( $selectors, $rules, $this->strictImports ); + + $ruleset->originalRuleset = $this->ruleset_id; + $ruleset->root = $this->root; + $ruleset->firstRoot = $this->firstRoot; + $ruleset->allowImports = $this->allowImports; + + // push the current ruleset to the frames stack + $env->unshiftFrame( $ruleset ); + + // Evaluate imports + if ( $ruleset->root || $ruleset->allowImports || !$ruleset->strictImports ) { + $ruleset->evalImports( $env ); + } + + return $ruleset; + } + + function evalImports( $env ) { + $rules_len = count( $this->rules ); + for ( $i = 0; $i < $rules_len; $i++ ) { + $rule = $this->rules[$i]; + + if ( $rule instanceof Less_Tree_Import ) { + $rules = $rule->compile( $env ); + if ( is_array( $rules ) ) { + array_splice( $this->rules, $i, 1, $rules ); + $temp_count = count( $rules ) - 1; + $i += $temp_count; + $rules_len += $temp_count; + } else { + array_splice( $this->rules, $i, 1, [ $rules ] ); + } + + $this->resetCache(); + } + } + } + + function makeImportant() { + $important_rules = []; + foreach ( $this->rules as $rule ) { + if ( $rule instanceof Less_Tree_Rule || $rule instanceof Less_Tree_Ruleset || $rule instanceof Less_Tree_NameValue ) { + $important_rules[] = $rule->makeImportant(); + } else { + $important_rules[] = $rule; + } + } + + return new Less_Tree_Ruleset( $this->selectors, $important_rules, $this->strictImports ); + } + + public function matchArgs( $args, $env = null ) { + return !$args; + } + + // lets you call a css selector with a guard + public function matchCondition( $args, $env ) { + $lastSelector = end( $this->selectors ); + + if ( !$lastSelector->evaldCondition ) { + return false; + } + if ( $lastSelector->condition && !$lastSelector->condition->compile( $env->copyEvalEnv( $env->frames ) ) ) { + return false; + } + return true; + } + + function resetCache() { + $this->_rulesets = null; + $this->_variables = null; + $this->lookups = []; + } + + public function variables() { + $this->_variables = []; + foreach ( $this->rules as $r ) { + if ( $r instanceof Less_Tree_Rule && $r->variable === true ) { + $this->_variables[$r->name] = $r; + } + } + } + + /** + * @param string $name + * @return Less_Tree_Rule|null + */ + public function variable( $name ) { + if ( $this->_variables === null ) { + $this->variables(); + } + return $this->_variables[$name] ?? null; + } + + public function find( $selector, $self = null ) { + $key = implode( ' ', $selector->_oelements ); + + if ( !isset( $this->lookups[$key] ) ) { + + if ( !$self ) { + $self = $this->ruleset_id; + } + + $this->lookups[$key] = []; + + $first_oelement = $selector->_oelements[0]; + + foreach ( $this->rules as $rule ) { + if ( $rule instanceof Less_Tree_Ruleset && $rule->ruleset_id != $self ) { + + if ( isset( $rule->first_oelements[$first_oelement] ) ) { + + foreach ( $rule->selectors as $ruleSelector ) { + $match = $selector->match( $ruleSelector ); + if ( $match ) { + if ( $selector->elements_len > $match ) { + $this->lookups[$key] = array_merge( $this->lookups[$key], $rule->find( new Less_Tree_Selector( array_slice( $selector->elements, $match ) ), $self ) ); + } else { + $this->lookups[$key][] = $rule; + } + break; + } + } + } + } + } + } + + return $this->lookups[$key]; + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ) { + if ( !$this->root ) { + Less_Environment::$tabLevel++; + } + + $tabRuleStr = $tabSetStr = ''; + if ( !Less_Parser::$options['compress'] ) { + if ( Less_Environment::$tabLevel ) { + $tabRuleStr = "\n" . str_repeat( Less_Parser::$options['indentation'], Less_Environment::$tabLevel ); + $tabSetStr = "\n" . str_repeat( Less_Parser::$options['indentation'], Less_Environment::$tabLevel - 1 ); + } else { + $tabSetStr = $tabRuleStr = "\n"; + } + } + + $ruleNodes = []; + $rulesetNodes = []; + foreach ( $this->rules as $rule ) { + + $class = get_class( $rule ); + if ( + ( $class === 'Less_Tree_Media' ) || + ( $class === 'Less_Tree_Directive' ) || + ( $this->root && $class === 'Less_Tree_Comment' ) || + ( $rule instanceof Less_Tree_Ruleset && $rule->rules ) + ) { + $rulesetNodes[] = $rule; + } else { + $ruleNodes[] = $rule; + } + } + + // If this is the root node, we don't render + // a selector, or {}. + if ( !$this->root ) { + $paths_len = count( $this->paths ); + for ( $i = 0; $i < $paths_len; $i++ ) { + $path = $this->paths[$i]; + $firstSelector = true; + + foreach ( $path as $p ) { + $p->genCSS( $output, $firstSelector ); + $firstSelector = false; + } + + if ( $i + 1 < $paths_len ) { + $output->add( ',' . $tabSetStr ); + } + } + + $output->add( ( Less_Parser::$options['compress'] ? '{' : " {" ) . $tabRuleStr ); + } + + // Compile rules and rulesets + $ruleNodes_len = count( $ruleNodes ); + $rulesetNodes_len = count( $rulesetNodes ); + for ( $i = 0; $i < $ruleNodes_len; $i++ ) { + $rule = $ruleNodes[$i]; + + // @page{ directive ends up with root elements inside it, a mix of rules and rulesets + // In this instance we do not know whether it is the last property + if ( $i + 1 === $ruleNodes_len && ( !$this->root || $rulesetNodes_len === 0 || $this->firstRoot ) ) { + Less_Environment::$lastRule = true; + } + + $rule->genCSS( $output ); + + if ( !Less_Environment::$lastRule ) { + $output->add( $tabRuleStr ); + } else { + Less_Environment::$lastRule = false; + } + } + + if ( !$this->root ) { + $output->add( $tabSetStr . '}' ); + Less_Environment::$tabLevel--; + } + + $firstRuleset = true; + $space = ( $this->root ? $tabRuleStr : $tabSetStr ); + for ( $i = 0; $i < $rulesetNodes_len; $i++ ) { + + if ( $ruleNodes_len && $firstRuleset ) { + $output->add( $space ); + } elseif ( !$firstRuleset ) { + $output->add( $space ); + } + $firstRuleset = false; + $rulesetNodes[$i]->genCSS( $output ); + } + + if ( !Less_Parser::$options['compress'] && $this->firstRoot ) { + $output->add( "\n" ); + } + } + + function markReferenced() { + if ( !$this->selectors ) { + return; + } + foreach ( $this->selectors as $selector ) { + $selector->markReferenced(); + } + } + + /** + * @param Less_Tree_Selector[][] $context + * @param Less_Tree_Selector[]|null $selectors + * @return Less_Tree_Selector[][] + */ + public function joinSelectors( $context, $selectors ) { + $paths = []; + if ( $selectors !== null ) { + foreach ( $selectors as $selector ) { + $this->joinSelector( $paths, $context, $selector ); + } + } + return $paths; + } + + public function joinSelector( array &$paths, array $context, Less_Tree_Selector $selector ) { + $newPaths = []; + $hadParentSelector = $this->replaceParentSelector( $newPaths, $context, $selector ); + + if ( !$hadParentSelector ) { + if ( $context ) { + $newPaths = []; + foreach ( $context as $path ) { + $newPaths[] = array_merge( $path, [ $selector ] ); + } + } else { + $newPaths = [ [ $selector ] ]; + } + } + + foreach ( $newPaths as $newPath ) { + $paths[] = $newPath; + } + } + + /** + * Replace all parent selectors inside $inSelector with $context. + * + * @param array &$paths Resulting selectors are appended to $paths. + * @param mixed $context + * @param Less_Tree_Selector $inSelector Inner selector from Less_Tree_Paren + * @return bool True if $inSelector contained at least one parent selector + */ + private function replaceParentSelector( array &$paths, $context, Less_Tree_Selector $inSelector ) { + $hadParentSelector = false; + + // The paths are [[Selector]] + // The first list is a list of comma separated selectors + // The inner list is a list of inheritance separated selectors + // e.g. + // .a, .b { + // .c { + // } + // } + // == [[.a] [.c]] [[.b] [.c]] + // + + // the elements from the current selector so far + $currentElements = []; + // the current list of new selectors to add to the path. + // We will build it up. We initiate it with one empty selector as we "multiply" the new selectors + // by the parents + $newSelectors = [ + [] + ]; + + foreach ( $inSelector->elements as $el ) { + // non-parent reference elements just get added + if ( $el->value !== '&' ) { + $nestedSelector = $this->findNestedSelector( $el ); + if ( $nestedSelector !== null ) { + $this->mergeElementsOnToSelectors( $currentElements, $newSelectors ); + + $nestedPaths = []; + $replacedNewSelectors = []; + $replaced = $this->replaceParentSelector( $nestedPaths, $context, $nestedSelector ); + $hadParentSelector = $hadParentSelector || $replaced; + // $nestedPaths is populated by replaceParentSelector() + // $nestedPaths should have exactly one TODO, replaceParentSelector does not multiply selectors + foreach ( $nestedPaths as $nestedPath ) { + $replacementSelector = $this->createSelector( $nestedPath, $el ); + + // join selector path from $newSelectors with every selector path in $addPaths array. + // $el contains the element that is being replaced by $addPaths + // + // @see less-2.5.3.js#Ruleset-addAllReplacementsIntoPath + $addPaths = [ $replacementSelector ]; + foreach ( $newSelectors as $newSelector ) { + $replacedNewSelectors[] = $this->addReplacementIntoPath( $newSelector, $addPaths, $el, $inSelector ); + } + } + $newSelectors = $replacedNewSelectors; + $currentElements = []; + } else { + $currentElements[] = $el; + } + } else { + $hadParentSelector = true; + + // the new list of selectors to add + $selectorsMultiplied = []; + + // merge the current list of non parent selector elements + // on to the current list of selectors to add + $this->mergeElementsOnToSelectors( $currentElements, $newSelectors ); + + foreach ( $newSelectors as $sel ) { + // if we don't have any parent paths, the & might be in a mixin so that it can be used + // whether there are parents or not + if ( !$context ) { + // the combinator used on el should now be applied to the next element instead so that + // it is not lost + if ( $sel ) { + $sel[0]->elements[] = new Less_Tree_Element( $el->combinator, '', $el->index, $el->currentFileInfo ); + } + $selectorsMultiplied[] = $sel; + } else { + // and the parent selectors + foreach ( $context as $parentSel ) { + // We need to put the current selectors + // then join the last selector's elements on to the parents selectors + $newSelectorPath = $this->addReplacementIntoPath( $sel, $parentSel, $el, $inSelector ); + // add that to our new set of selectors + $selectorsMultiplied[] = $newSelectorPath; + } + } + } + + // our new selectors has been multiplied, so reset the state + $newSelectors = $selectorsMultiplied; + $currentElements = []; + } + } + + // if we have any elements left over (e.g. .a& .b == .b) + // add them on to all the current selectors + $this->mergeElementsOnToSelectors( $currentElements, $newSelectors ); + + foreach ( $newSelectors as &$sel ) { + $length = count( $sel ); + if ( $length ) { + $paths[] = $sel; + $lastSelector = $sel[$length - 1]; + $sel[$length - 1] = $lastSelector->createDerived( $lastSelector->elements, $inSelector->extendList ); + } + } + + return $hadParentSelector; + } + + /** + * @param array $elementsToPak + * @param Less_Tree_Element $originalElement + * @return Less_Tree_Selector + */ + private function createSelector( array $elementsToPak, $originalElement ) { + if ( !$elementsToPak ) { + // This is an invalid call. Kept to match less.js. Appears unreachable. + // @phan-suppress-next-line PhanTypeMismatchArgumentProbablyReal + $containedElement = new Less_Tree_Paren( null ); + } else { + $insideParent = []; + foreach ( $elementsToPak as $elToPak ) { + $insideParent[] = new Less_Tree_Element( null, $elToPak, $originalElement->index, $originalElement->currentFileInfo ); + } + $containedElement = new Less_Tree_Paren( new Less_Tree_Selector( $insideParent ) ); + } + + $element = new Less_Tree_Element( null, $containedElement, $originalElement->index, $originalElement->currentFileInfo ); + return new Less_Tree_Selector( [ $element ] ); + } + + /** + * @param Less_Tree_Element $element + * @return Less_Tree_Selector|null + */ + private function findNestedSelector( $element ) { + $maybeParen = $element->value; + if ( !( $maybeParen instanceof Less_Tree_Paren ) ) { + return null; + } + $maybeSelector = $maybeParen->value; + if ( !( $maybeSelector instanceof Less_Tree_Selector ) ) { + return null; + } + return $maybeSelector; + } + + /** + * joins selector path from $beginningPath with selector path in $addPath. + * + * $replacedElement contains the element that is being replaced by $addPath + * + * @param Less_Tree_Selector[] $beginningPath + * @param Less_Tree_Selector[] $addPath + * @param Less_Tree_Element $replacedElement + * @param Less_Tree_Selector $originalSelector + * @return Less_Tree_Selector[] Concatenated path + * @see less-2.5.3.js#Ruleset-addReplacementIntoPath + */ + private function addReplacementIntoPath( array $beginningPath, array $addPath, $replacedElement, $originalSelector ) { + // our new selector path + $newSelectorPath = []; + + // construct the joined selector - if `&` is the first thing this will be empty, + // if not newJoinedSelector will be the last set of elements in the selector + if ( $beginningPath ) { + // NOTE: less.js uses Array slice() to copy. In PHP, arrays are naturally copied by value. + $newSelectorPath = $beginningPath; + $lastSelector = array_pop( $newSelectorPath ); + $newJoinedSelector = $originalSelector->createDerived( $lastSelector->elements ); + } else { + $newJoinedSelector = $originalSelector->createDerived( [] ); + } + + if ( $addPath ) { + // if the & does not have a combinator that is "" or " " then + // and there is a combinator on the parent, then grab that. + // this also allows `+ a { & .b { .a & { ...` + $combinator = $replacedElement->combinator; + $parentEl = $addPath[0]->elements[0]; + if ( $replacedElement->combinatorIsEmptyOrWhitespace && !$parentEl->combinatorIsEmptyOrWhitespace ) { + $combinator = $parentEl->combinator; + } + // join the elements so far with the first part of the parent + $newJoinedSelector->elements[] = new Less_Tree_Element( $combinator, $parentEl->value, $replacedElement->index, $replacedElement->currentFileInfo ); + $newJoinedSelector->elements = array_merge( + $newJoinedSelector->elements, + array_slice( $addPath[0]->elements, 1 ) + ); + } + + // now add the joined selector - but only if it is not empty + if ( $newJoinedSelector->elements ) { + $newSelectorPath[] = $newJoinedSelector; + } + + // put together the parent selectors after the join (e.g. the rest of the parent) + if ( count( $addPath ) > 1 ) { + $newSelectorPath = array_merge( $newSelectorPath, array_slice( $addPath, 1 ) ); + } + return $newSelectorPath; + } + + function mergeElementsOnToSelectors( $elements, &$selectors ) { + if ( !$elements ) { + return; + } + if ( !$selectors ) { + $selectors[] = [ new Less_Tree_Selector( $elements ) ]; + return; + } + + foreach ( $selectors as &$sel ) { + // if the previous thing in sel is a parent this needs to join on to it + if ( $sel ) { + $last = count( $sel ) - 1; + $sel[$last] = $sel[$last]->createDerived( array_merge( $sel[$last]->elements, $elements ) ); + } else { + $sel[] = new Less_Tree_Selector( $elements ); + } + } + } +} |