Spiral\Stempler\Parser\Syntax\HTMLSyntax::handle()

Complexity

Conditions	24
Paths	19

Size

Total Lines	100
Code Lines	67

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

<?php
    public function handle(Parser $parser, Assembler $asm, Token $token): void
    {
        switch ($token->type) {
            case HTMLGrammar::TYPE_OPEN:
            case HTMLGrammar::TYPE_OPEN_SHORT:
                $this->node = new Tag(new Parser\Context($token, $parser->getPath()));
                $this->token = $token;

                break;

            case HTMLGrammar::TYPE_KEYWORD:
                if ($this->node->name === null) {
                    $this->node->name = $this->parseToken($parser, $token);
                    return;
                }

                if ($this->attr !== null && !$this->attr->value instanceof Nil) {
                    $this->attr->value = $this->parseToken($parser, $token);
                    $this->attr = null;
                    break;
                }

                $this->attr = new Attr(
                    $this->parseToken($parser, $token),
                    new Nil(),
                    new Parser\Context($token, $parser->getPath())
                );

                $this->node->attrs[] = $this->attr;
                break;

            case HTMLGrammar::TYPE_EQUAL:
                if ($this->attr === null) {
                    throw new SyntaxException('unexpected attribute token', $token);
                }

                // expect the value
                $this->attr->value = null;
                break;

            case HTMLGrammar::TYPE_ATTRIBUTE:
                if ($this->attr === null) {
                    throw new SyntaxException('unexpected attribute token', $token);
                }

                if (
                    is_string($this->attr->name)
                    && (
                        strpos($this->attr->name, 'on') === 0
                        || in_array($this->attr->name, self::VERBATIM_ATTRIBUTES, true)
                    )
                ) {
                    $this->attr->value = $this->parseVerbatim($parser, $token);

It seems like $this->parseVerbatim($parser, $token) of type Spiral\Stempler\Node\HTML\Verbatim is incompatible with the declared type Spiral\Stempler\Node\HTML\Nil|Spiral\Stempler\Node\Mixin|string of property $value.

                } else {
                    $this->attr->value = $this->parseToken($parser, $token);
                }

                $this->attr = null;
                break;

            case HTMLGrammar::TYPE_CLOSE_SHORT:
                $this->node->void = true;
                $asm->push($this->node);

It seems like $this->node can also be of type null; however, parameter $node of Spiral\Stempler\Parser\Assembler::push() does only seem to accept Spiral\Stempler\Node\NodeInterface, maybe add an additional type check?

                $this->flush();
                break;

            case HTMLGrammar::TYPE_CLOSE:
                if ($this->token->type == HTMLGrammar::TYPE_OPEN_SHORT) {
                    if (!$asm->getNode() instanceof Tag || $asm->getNode()->name !== $this->node->name) {
                        throw new SyntaxException(
                            "Invalid closing tag `{$this->node->name}`, expected `{$asm->getNode()->name}`",
                            $this->token

It seems like $this->token can also be of type null; however, parameter $context of Spiral\Stempler\Exception\SyntaxException::__construct() does only seem to accept Spiral\Stempler\Lexer\Token, maybe add an additional type check?

                        );
                    }

                    $asm->close();
                } else {
                    if (in_array($this->node->name, self::VOID_TAGS)) {
                        $this->node->void = true;
                        $asm->push($this->node);
                    } else {
                        $asm->open($this->node, 'nodes');

It seems like $this->node can also be of type null; however, parameter $node of Spiral\Stempler\Parser\Assembler::open() does only seem to accept Spiral\Stempler\Node\NodeInterface, maybe add an additional type check?

                    }
                }
                $this->flush();

                break;

            case HTMLGrammar::TYPE_VERBATIM:
                $asm->push($this->parseVerbatim($parser, $token));
                break;

            default:
                if ($asm->getNode() instanceof Mixin || $asm->getNode() instanceof Verbatim) {
                    $node = $this->parseToken($parser, $token);
                    if (is_string($node)) {

The condition is_string($node) is always false.

                        $node = new Raw($node, new Parser\Context($token, $parser->getPath()));
                    }

                    $asm->push($node);
                }