ILess\Node\RulesetNode::compile()

Complexity

Conditions	38
Paths	> 20000

Size

Total Lines	154
Code Lines	85

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function compile(Context $context, $arguments = null, $important = null)
    {
        // compile selectors
        $selectors = [];
        $hasOnePassingSelector = false;

        if ($count = count($this->selectors)) {
            DefaultFunc::error(new ParserException('it is currently only allowed in parametric mixin guards'));
            for ($i = 0; $i < $count; ++$i) {
                $selector = $this->selectors[$i]->compile($context);
                /* @var $selector SelectorNode */
                $selectors[] = $selector;
                if ($selector->compiledCondition) {
                    $hasOnePassingSelector = true;
                }
            }
            DefaultFunc::reset();
        } else {
            $hasOnePassingSelector = true;
        }

        $ruleset = new self($selectors, $this->rules, $this->strictImports);
        $ruleset->originalRuleset = $this;
        $ruleset->root = $this->root;
        $ruleset->firstRoot = $this->firstRoot;
        $ruleset->allowImports = $this->allowImports;

        if ($this->debugInfo) {
            $ruleset->debugInfo = $this->debugInfo;
        }

        if (!$hasOnePassingSelector) {
            $ruleset->rules = [];
        }

        // inherit a function registry from the frames stack when possible;
        // otherwise from the global registry
        $found = null;
        foreach ($context->frames as $i => $frame) {
            if ($frame->functionRegistry) {
                $found = $frame->functionRegistry;
                break;
            }
        }

        $registry = $found ? $found : $context->getFunctionRegistry();
        $ruleset->functionRegistry = $registry->inherit();

        // push the current ruleset to the frames stack
        $context->unshiftFrame($ruleset);

        // current selectors
        array_unshift($context->selectors, $this->selectors);

        // Evaluate imports
        if ($ruleset->root || $ruleset->allowImports || !$ruleset->strictImports) {
            $ruleset->compileImports($context);
        }

        // count after compile imports was called
        $rulesetCount = count($ruleset->rules);

        // Store the frames around mixin definitions,
        // so they can be evaluated like closures when the time comes.
        foreach ($ruleset->rules as $i => $rule) {
            /* @var $rule RuleNode */
            if ($rule && $rule->compileFirst()) {
                $ruleset->rules[$i] = $rule->compile($context);
            }
        }

        $mediaBlockCount = count($context->mediaBlocks);

        // Evaluate mixin calls.
        for ($i = 0; $i < $rulesetCount; ++$i) {
            $rule = $ruleset->rules[$i];

            if ($rule instanceof MixinCallNode) {
                $rule = $rule->compile($context);
                $temp = [];
                foreach ($rule as $r) {
                    if (($r instanceof RuleNode) && $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;
                    }
                }
                $tempCount = count($temp) - 1;
                array_splice($ruleset->rules, $i, 1, $temp);
                $rulesetCount += $tempCount;
                $i += $tempCount;
                $ruleset->resetCache();
            } elseif ($rule instanceof RulesetCallNode) {
                $rule = $rule->compile($context);
                $rules = [];
                foreach ($rule->rules as $r) {
                    if (($r instanceof RuleNode && $r->variable)) {
                        continue;
                    }
                    $rules[] = $r;
                }

                array_splice($ruleset->rules, $i, 1, $rules);
                $tempCount = count($rules);
                $rulesetCount += $tempCount - 1;
                $i += $tempCount - 1;
                $ruleset->resetCache();
            }
        }

        // Evaluate everything else
        for ($i = 0; $i < count($ruleset->rules); ++$i) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

            $rule = $ruleset->rules[$i];
            /* @var $rule Node */
            if ($rule && !$rule->compileFirst()) {
                $ruleset->rules[$i] = $rule instanceof CompilableInterface ? $rule->compile($context) : $rule;
            }
        }

        // Evaluate everything else
        for ($i = 0; $i < count($ruleset->rules); ++$i) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

            $rule = $ruleset->rules[$i];
            // for rulesets, check if it is a css guard and can be removed
            if ($rule instanceof self && 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);
                    for ($j = 0; $j < count($rule->rules); ++$j) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

                        $subRule = $rule->rules[$j];
                        if (!($subRule instanceof RuleNode) || !$subRule->variable) {
                            array_splice($ruleset->rules, ++$i, 0, [$subRule]);
                        }
                    }
                }
            }
        }

        // Pop the stack
        $context->shiftFrame();
        array_shift($context->selectors);

        if ($mediaBlockCount) {
            for ($i = $mediaBlockCount, $count = count($context->mediaBlocks); $i < $count; ++$i) {
                $context->mediaBlocks[$i]->bubbleSelectors($selectors);
            }
        }

        return $ruleset;
    }