Spiral\Stempler\Lexer\Grammar\Dynamic\DirectiveGrammar

Complexity

Total Complexity

41

Size/Duplication

Total Lines	263
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
B	parse()	0	54	9
A	getLastToken()	0	7	2
B	parseBody()	0	46	10
A	flushBody()	0	8	2
A	getKeyword()	0	9	3
A	getLastOffset()	0	3	1
A	flushName()	0	8	2
A	getBody()	0	9	3
B	finalize()	0	32	7
A	getIterator()	0	7	2

<?php

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

declare(strict_types=1);

namespace Spiral\Stempler\Lexer\Grammar\Dynamic;

use Spiral\Stempler\Exception\SyntaxException;
use Spiral\Stempler\Lexer\Buffer;
use Spiral\Stempler\Lexer\Byte;
use Spiral\Stempler\Lexer\Grammar\DynamicGrammar;
use Spiral\Stempler\Lexer\Grammar\Traits\TokenTrait;
use Spiral\Stempler\Lexer\Token;

final class DirectiveGrammar implements \IteratorAggregate
{
    use TokenTrait;

The trait Spiral\Stempler\Lexer\Grammar\Traits\TokenTrait requires some properties which are not provided by Spiral\Stempler\Lexer\Grammar\Dynamic\DirectiveGrammar: $char, $content, $type

    // start directive
    public const DIRECTIVE_CHAR = '@';

    // whitespace
    private const REGEXP_WHITESPACE = '/\s/';

    // Allowed keyword characters.
    private const REGEXP_KEYWORD = '/[a-z0-9_\-:\.]/ui';

    /** @var array */
    private $name = [];

    /** @var array */
    private $body = [];

    /**
     * @param Buffer $src
     * @param int    $offset
     * @return bool
     */
    public function parse(Buffer $src, int $offset): bool
    {
        $this->tokens = [
            new Token(DynamicGrammar::TYPE_DIRECTIVE, $offset, self::DIRECTIVE_CHAR)
        ];

        $this->body = null;
        $hasWhitespace = false;

        while ($n = $src->next()) {
            if (!$n instanceof Byte) {
                // no other grammars are allowed
                break;
            }

            switch ($n->char) {
                case '(':
                    $this->flushName();
                    $this->tokens[] = new Token(DynamicGrammar::TYPE_BODY_OPEN, $n->offset, $n->char);

                    return $this->parseBody($src);
                default:
                    if (preg_match(self::REGEXP_WHITESPACE, $n->char)) {
                        $hasWhitespace = true;
                        if ($this->name !== []) {
                            $this->flushName();
                            $this->tokens[] = new Token(DynamicGrammar::TYPE_WHITESPACE, $n->offset, $n->char);
                            break;
                        }

                        if ($this->getLastToken()->type === DynamicGrammar::TYPE_WHITESPACE) {
                            $this->getLastToken()->content .= $n->char;
                            break;
                        }

                        // invalid directive
                        return false;
                    } elseif ($hasWhitespace) {
                        return $this->finalize();
                    }

                    if (!preg_match(self::REGEXP_KEYWORD, $n->char)) {
                        $this->flushName();

                        return $this->finalize();
                    }

                    $this->name[] = $n;
            }
        }

        $this->flushName();

        return $this->finalize();
    }

    /**
     * Directive tokens.
     *
     * @return \Generator|\Traversable
     */
    public function getIterator()
    {
        if ($this->tokens === []) {
            throw new \LogicException('Directive not parsed');
        }

        yield from $this->tokens;
    }

    /**
     * Return offset after last directive token.
     *
     * @return int
     */
    public function getLastOffset(): int
    {
        return $this->getLastToken()->offset + strlen($this->getLastToken()->content) - 1;
    }

    /**
     * Get directive keyword.
     *
     * @return string
     */
    public function getKeyword(): string
    {
        foreach ($this->tokens as $token) {
            if ($token->type === DynamicGrammar::TYPE_KEYWORD) {
                return $token->content;
            }
        }

        throw new SyntaxException('Directive not parsed', $this->tokens[0]);
    }

    /**
     * Get directive body.
     *
     * @return string
     */
    public function getBody(): ?string
    {
        foreach ($this->tokens as $token) {
            if ($token->type === DynamicGrammar::TYPE_BODY) {
                return $token->content;
            }
        }

        return null;
    }

    /**
     * Pack keyword token.
     */
    private function flushName(): void
    {
        if ($this->name === []) {
            return;
        }

        $this->tokens[] = $this->packToken($this->name, DynamicGrammar::TYPE_KEYWORD);
        $this->name = [];
    }

    /**
     * @param Buffer $src
     * @return bool
     */
    private function parseBody(Buffer $src)
    {
        $this->body = [];
        $level = 1;

        while ($nn = $src->next()) {
            if (!$nn instanceof Byte) {
                $this->flushBody();
                return $this->finalize();
            }

            if (in_array($nn->char, ['"', '"'])) {
                $this->body[] = $nn;
                while ($nnn = $src->next()) {
                    $this->body[] = $nnn;
                    if ($nnn instanceof Byte && $nnn->char === $nn->char) {
                        break;
                    }
                }
                continue;
            }

            $this->body[] = $nn;

            if ($nn->char === '(') {
                $level++;
                continue;
            }

            if ($nn->char === ')') {
                $level--;

                if ($level === 0) {
                    $n = array_pop($this->body);

                    $this->flushBody();
                    $this->tokens[] = new Token(DynamicGrammar::TYPE_BODY_CLOSE, $n->offset, $n->char);

                    return $this->finalize();
                }

                continue;
            }
        }

        return $this->finalize();
    }

    /**
     * Pack name token.
     */
    private function flushBody(): void
    {
        if ($this->body === []) {
            return;
        }

        $this->tokens[] = $this->packToken($this->body, DynamicGrammar::TYPE_BODY);
        $this->body = [];
    }

    /**
     * @return Token
     */
    private function getLastToken(): Token
    {
        if ($this->tokens === []) {
            throw new \LogicException('Directive not parsed');
        }

        return $this->tokens[count($this->tokens) - 1];
    }

    /**
     * Flush directive and seek buffer before last non WHITESPACE token.
     *
     * @return bool
     */
    private function finalize(): bool
    {
        $tokens = $this->tokens;

        foreach (array_reverse($tokens, true) as $i => $t) {
            if ($t->type !== DynamicGrammar::TYPE_WHITESPACE) {
                break;
            }

            unset($tokens[$i]);
        }

        $body = null;
        foreach ($tokens as $t) {
            if ($t->type === DynamicGrammar::TYPE_BODY_OPEN) {
                $body = false;
                continue;
            }

            if ($t->type === DynamicGrammar::TYPE_BODY_CLOSE) {
                $body = null;
                continue;
            }
        }

        if ($body !== null) {
            return false;
        }

        $this->tokens = $tokens;

        return true;
    }
}