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

Complexity

Conditions	24
Paths	19

Size

Total Lines	103
Code Lines	66

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	53
CRAP Score	24.0886

Importance

Changes

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),

It seems like $this->parseToken($parser, $token) can also be of type Spiral\Stempler\Node\Raw; however, parameter $name of Spiral\Stempler\Node\HTML\Attr::__construct() does only seem to accept Spiral\Stempler\Node\Mixin|string, maybe add an additional type check?

                    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)
                    && (
                        \str_starts_with($this->attr->name, 'on')
                        || \in_array($this->attr->name, self::VERBATIM_ATTRIBUTES, true)
                    )
                ) {
                    $this->attr->value = $this->parseVerbatim($parser, $token);
                } 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) {
                        /**
                         * TODO issue #767
                         * @link https://github.com/spiral/framework/issues/767
                         * @psalm-suppress NoInterfaceProperties
                         */
                        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 $token of Spiral\Stempler\Exception\SyntaxException::__construct() does only seem to accept Spiral\Stempler\Lexer\Token, maybe add an additional type check?

                        );
                    }

                    $asm->close();
                } elseif (\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)) {
                        $node = new Raw($node, new Parser\Context($token, $parser->getPath()));
                    }

                    $asm->push($node);

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

                }