LesserPhp\Parser::parseChunk()

Complexity

Conditions	49
Paths	349

Size

Total Lines

186

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	76
CRAP Score	49.3001

Importance

Changes

0

<?php
    protected function parseChunk()
    {
        if (empty($this->buffer)) {
            return false;
        }
        $s = $this->seek();

        if ($this->whitespace()) {
            return true;
        }

        // setting a property
        if ($this->keyword($key) && $this->assign() && $this->propertyValue($value, $key) && $this->end()) {
            $this->append(['assign', $key, $value], $s);

            return true;
        } else {
            $this->seek($s);
        }

        // look for special css blocks
        if ($this->literal('@', false)) {
            $this->count--;

            // media
            if ($this->literal('@media')) {
                return $this->handleLiteralMedia($s);
            }

            if ($this->literal('@', false) && $this->keyword($directiveName)) {
                if ($this->isDirective($directiveName, $this->blockDirectives)) {
                    if ($this->handleDirectiveBlock($directiveName) === true) {
                        return true;
                    }
                } elseif ($this->isDirective($directiveName, $this->lineDirectives)) {
                    if ($this->handleDirectiveLine($directiveName) === true) {
                        return true;
                    }
                } elseif ($this->literal(':', true)) {
                    if ($this->handleRulesetDefinition($directiveName) === true) {
                        return true;
                    }
                }
            }

            $this->seek($s);
        }

        if ($this->literal('&', false)) {
            $this->count--;
            if ($this->literal('&:extend')) {
                // hierauf folgt was in runden klammern, und zwar das element, das erweitert werden soll
                // heißt also, das was in klammern steht wird um die aktuellen klassen erweitert
                /*
Aus

nav ul {
  &:extend(.inline);
  background: blue;
}
.inline {
  color: red;
}


Wird:

nav ul {
  background: blue;
}
.inline,
nav ul {
  color: red;
}

                 */
//                echo "Here we go";
            }
        }


        // setting a variable
        if ($this->variable($var) && $this->assign() &&
            $this->propertyValue($value) && $this->end()
        ) {
            $this->append(['assign', $var, $value], $s);

            return true;
        } else {
            $this->seek($s);
        }

        if ($this->import($importValue)) {
            $this->append($importValue, $s);

            return true;
        }

        // opening parametric mixin
        if ($this->tag($tag, true) && $this->argumentDef($args, $isVararg) &&
            ($this->guards($guards) || true) &&
            $this->literal('{')
        ) {
            $block = $this->pushBlock($this->fixTags([$tag]));
            $block->args = $args;

The property args does not seem to exist in LesserPhp\Block.

            $block->isVararg = $isVararg;
            if (!empty($guards)) {
                $block->guards = $guards;

The property guards does not seem to exist in LesserPhp\Block.

            }

            return true;
        } else {
            $this->seek($s);
        }

        // opening a simple block
        if ($this->tags($tags) && $this->literal('{', false)) {
            $tags = $this->fixTags($tags);
            $this->pushBlock($tags);

            return true;
        } else {
            $this->seek($s);
        }

        // closing a block
        if ($this->literal('}', false)) {
            try {
                $block = $this->pop();
            } catch (\Exception $e) {
                $this->seek($s);
                $this->throwError($e->getMessage());

                return false; // will never be reached, but silences the ide for now
            }

            $hidden = false;
            if ($block->type === null) {
                $hidden = true;
                if (!isset($block->args)) {
                    foreach ($block->tags as $tag) {

The expression $block->tags of type array|null is not guaranteed to be traversable. How about adding an additional type check?

                        if (!is_string($tag) || $tag[0] !== $this->lessc->getMPrefix()) {
                            $hidden = false;
                            break;
                        }
                    }
                }

                foreach ($block->tags as $tag) {

The expression $block->tags of type array|null is not guaranteed to be traversable. How about adding an additional type check?

                    if (is_string($tag)) {
                        $this->env->children[$tag][] = $block;
                    }
                }
            }

            if (!$hidden) {
                $this->append(['block', $block], $s);
            }

            // this is done here so comments aren't bundled into he block that
            // was just closed
            $this->whitespace();

            return true;
        }

        // mixin
        if ($this->mixinTags($tags) &&
            ($this->argumentDef($argv, $isVararg) || true) &&
            ($this->keyword($suffix) || true) && $this->end()
        ) {
            $tags = $this->fixTags($tags);
            $this->append(['mixin', $tags, $argv, $suffix], $s);

            return true;
        } else {
            $this->seek($s);
        }

        // spare ;
        if ($this->literal(';')) {
            return true;
        }

        return false; // got nothing, throw error
    }