JsonDecodeStream\Tokenizer::tokens()

Complexity

Conditions	31
Paths	679

Size

Total Lines	126
Code Lines	93

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	84
CRAP Score	31.0905

Importance

Changes	4
Bugs	3	Features	0

<?php
    public function tokens()
    {
        /** @var string|null $number collecting chars of numeric token */
        $number = null;
        /** @var string|null $string collecting chars of string token */
        $string = null;
        /** @var int $stringSlashes how many sequentative slashes are found in string */
        $stringSlashes = 0;
        /** @var string|null $whitespace collecting chars of whitespace token */
        $whitespace = null;
        /** @var string|null $literalAwaited holding the string for awaited literal */
        $literalAwaited = null;
        /** @var string|null $literal collecting chars of literal token */
        $literal = null;

        $this->lineNumber = 1;
        $this->charNumber = 1;
        foreach ($this->buffer as $char) {
            if ($char == "\n") {
                $this->lineNumber++;
                $this->charNumber = 1;
            } else {
                $this->charNumber++;
            }

            if ($number !== null) {
                if (strpos('0123456789+-Ee\.', $char) !== false) {
                    $number .= $char;
                    continue;
                }
                $parsedNumber = $this->parseNumber($number);

$number of type null is incompatible with the type string expected by parameter $number of JsonDecodeStream\Tokenizer::parseNumber().

                $number = null;
                yield $this->createToken(Token::NUMBER, $parsedNumber);
            }

            if ($string !== null) {
                if ($char == '\\') {
                    $string .= $char;
                    $stringSlashes++;
                    continue;
                } elseif ($char == '"' && ($stringSlashes % 2) == 0) {
                    $parsedString = $this->parseString($string);

$string of type null is incompatible with the type string expected by parameter $string of JsonDecodeStream\Tokenizer::parseString().

                    yield $this->createToken(Token::STRING, $parsedString);
                    $string = null;
                    $stringSlashes = 0;
                    continue;
                } else {
                    $string .= $char;
                    $stringSlashes = 0;
                    continue;
                }
            }

            if ($whitespace !== null) {
                if (strpos(static::WHITESPACE_CHARS, $char)) {
                    $whitespace .= $char;
                    continue;
                } else {
                    yield $this->createToken(Token::WHITESPACE, $whitespace);
                    $whitespace = null;
                }
            }

            if ($literalAwaited !== null) {
                if (strpos($literalAwaited, $char) !== false) {

$literalAwaited of type null is incompatible with the type string expected by parameter $haystack of strpos().

                    $literal .= $char;
                } else {
                    throw TokenizerException::unexpectedToken($literal, $this->lineNumber, $this->charNumber);

$literal of type null is incompatible with the type string expected by parameter $token of JsonDecodeStream\Exception\TokenizerException::unexpectedToken().

                }

                if (strlen($literal) == strlen($literalAwaited)) {

$literalAwaited of type null is incompatible with the type string expected by parameter $string of strlen().

                    if ($literal === $literalAwaited) {
                        yield $this->createToken($literalAwaited, static::LITERALS[$literalAwaited]);

$literalAwaited of type void is incompatible with the type string expected by parameter $tokenId of JsonDecodeStream\Tokenizer::createToken().

                        $literalAwaited = null;
                        $literal = null;
                    } else {
                        throw TokenizerException::unexpectedToken($literal, $this->lineNumber, $this->charNumber);
                    }
                }
                continue;
            }

            if (strpos(static::WHITESPACE_CHARS, $char) !== false) {
                $whitespace = $char;
            } elseif ($char == "{") {
                yield $this->createToken(Token::OBJECT_START);
            } elseif ($char == "}") {
                yield $this->createToken(Token::OBJECT_END);
            } elseif ($char == "[") {
                yield $this->createToken(Token::ARRAY_START);
            } elseif ($char == "]") {
                yield $this->createToken(Token::ARRAY_END);
            } elseif ($char == ":") {
                yield $this->createToken(Token::KEY_DELIMITER);
            } elseif ($char == ",") {
                yield $this->createToken(Token::COMA);
            } elseif ($char == '"') {
                $string = '';
            } elseif (strpos('+-0123456789', $char) !== false) {
                $number = $char;
            } elseif ($char == 't') {
                $literalAwaited = Token::TRUE;
                $literal = $char;
            } elseif ($char == 'f') {
                $literalAwaited = Token::FALSE;
                $literal = $char;
            } elseif ($char == 'n') {
                $literalAwaited = Token::NULL;
                $literal = $char;
            } else {
                throw TokenizerException::unexpectedCharacter($char, $this->lineNumber, $this->charNumber);
            }
        }

        if ($string !== null || $literal !== null) {
            throw TokenizerException::malformedString($string ?? $literal, $this->lineNumber, $this->charNumber);

It seems like $string ?? $literal can also be of type null; however, parameter $string of JsonDecodeStream\Exception\TokenizerException::malformedString() does only seem to accept string, maybe add an additional type check?

        }

        if ($number !== null) {
            $parsedNumber = $this->parseNumber($number);
            yield $this->createToken(Token::NUMBER, $parsedNumber);
            $number = null;

The assignment to $number is dead and can be removed.

        }

        if ($whitespace !== null) {
            yield $this->createToken(Token::WHITESPACE, $whitespace);
        }