Spiral\Stempler\Parser\Syntax\HTMLSyntax

Complexity

Total Complexity

28

Size/Duplication

Total Lines	175
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
D	handle()	0	100	24
A	parseVerbatim()	0	16	3
A	flush()	0	5	1

<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Spiral\Stempler\Parser\Syntax;

use Spiral\Stempler\Exception\SyntaxException;
use Spiral\Stempler\Lexer\Grammar\HTMLGrammar;
use Spiral\Stempler\Lexer\Token;
use Spiral\Stempler\Node\HTML\Attr;
use Spiral\Stempler\Node\HTML\Nil;
use Spiral\Stempler\Node\HTML\Tag;
use Spiral\Stempler\Node\HTML\Verbatim;
use Spiral\Stempler\Node\Mixin;
use Spiral\Stempler\Node\Raw;
use Spiral\Stempler\Parser;
use Spiral\Stempler\Parser\Assembler;
use Spiral\Stempler\Parser\SyntaxInterface;

/**
 * HTML tags and attributes.
 */
final class HTMLSyntax implements SyntaxInterface
{
    use Parser\Syntax\Traits\MixinTrait;

The trait Spiral\Stempler\Parser\Syntax\Traits\MixinTrait requires some properties which are not provided by Spiral\Stempler\Parser\Syntax\HTMLSyntax: $tokens, $type, $content

    // list of tags which are closed automatically (http://xahlee.info/js/html5_non-closing_tag.html)
    private const VOID_TAGS = [
        'area',
        'base',
        'br',
        'col',
        'embed',
        'hr',
        'img',
        'input',
        'link',
        'meta',
        'param',
        'source',
        'track',
        'wbr'
    ];

    // list of attributes which define verbatim blocks (https://www.w3schools.com/tags/ref_eventattributes.asp)
    private const VERBATIM_ATTRIBUTES = [
        'style',
        'on*'
    ];

    /** @var Tag|null */
    private $node;

    /** @var Token|null */
    private $token;

    /** @var Attr|null */
    private $attr;

    /**
     * @inheritDoc
     */
    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);
                }
        }
    }

    /**
     * Flush open nodes and tokens.
     */
    private function flush(): void
    {
        $this->node = null;
        $this->token = null;
        $this->attr = null;
    }

    /**
     * @param Parser $parser
     * @param Token  $token
     * @return Verbatim
     */
    private function parseVerbatim(Parser $parser, Token $token): Verbatim
    {
        $verbatim = new Verbatim(new Parser\Context($token, $parser->getPath()));

        if ($token->tokens === []) {
            if ($token->content) {
                $verbatim->nodes[] = $token->content;
            }
        } else {
            $parser->parseTokens(
                new Assembler($verbatim, 'nodes'),
                $token->tokens
            );
        }

        return $verbatim;
    }
}