Parser::visitSimpleType() - Code Metrics - Inspection of "Use doctrine/lexer instead of hoa/compiler" - schmittjoh/serializer - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#1212)

by Asmir

created 2020-06-13 09:39 UTC

Parser::visitSimpleType() A

↳ Parent: Parser

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	4
ccs	0
cts	0
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace JMS\Serializer\Type;

use JMS\Serializer\Type\Exception\SyntaxError;

/**
 * @internal
 */
final class Parser implements ParserInterface
{
    /**
     * @var Lexer
     */
    private $lexer;

    /**
     * @var bool
     */
    private $root = true;

    public function parse(string $string): array
    {
        $this->lexer = new Lexer();
        $this->lexer->setInput($string);
        $this->lexer->moveNext();
        return $this->visit();
    }

    /**
     * @return mixed
     */
    private function visit()
    {
        $this->lexer->moveNext();

        if (!$this->lexer->token) {
            throw new SyntaxError(
                'Syntax error, unexpected end of stream'
            );
        }

        if (Lexer::T_FLOAT === $this->lexer->token['type']) {
            return floatval($this->lexer->token['value']);
        } elseif (Lexer::T_INTEGER === $this->lexer->token['type']) {
            return intval($this->lexer->token['value']);
        } elseif (Lexer::T_NULL === $this->lexer->token['type']) {
            return null;
        } elseif (Lexer::T_STRING === $this->lexer->token['type']) {
            return $this->lexer->token['value'];
        } elseif (Lexer::T_IDENTIFIER === $this->lexer->token['type']) {
            if ($this->lexer->isNextToken(Lexer::T_TYPE_START)) {
                return $this->visitCompoundType();
            } elseif ($this->lexer->isNextToken(Lexer::T_ARRAY_START)) {
                return $this->visitArrayType();
            }
            return $this->visitSimpleType();
        } elseif (!$this->root && Lexer::T_ARRAY_START === $this->lexer->token['type']) {
            return $this->visitArrayType();
        }

        throw new SyntaxError(sprintf(
            'Syntax error, unexpected "%s" (%s)',
            $this->lexer->token['value'],
            $this->getConstant($this->lexer->token['type'])
        ));
    }

    /**
     * @return string|mixed[]
     */
    private function visitSimpleType()
    {
        $value = $this->lexer->token['value'];
        return ['name' => $value, 'params' => []];
    }

    private function visitCompoundType(): array
    {
        $this->root = false;
        $name = $this->lexer->token['value'];
        $this->match(Lexer::T_TYPE_START);

        $params = [];
        if (!$this->lexer->isNextToken(Lexer::T_TYPE_END)) {
            while (true) {
                $params[] = $this->visit();

                if ($this->lexer->isNextToken(Lexer::T_TYPE_END)) {
                    break;
                }
                $this->match(Lexer::T_COMMA);
            }
        }
        $this->match(Lexer::T_TYPE_END);
        return [
            'name' => $name,
            'params' => $params,
        ];
    }

    private function visitArrayType(): array
    {
        /*
         * Here we should call $this->match(Lexer::T_ARRAY_START); to make it clean
         * but the token has already been consumed by moveNext() in visit()
         */

        $params = [];
        if (!$this->lexer->isNextToken(Lexer::T_ARRAY_END)) {
            while (true) {
                $params[] = $this->visit();
                if ($this->lexer->isNextToken(Lexer::T_ARRAY_END)) {
                    break;
                }
                $this->match(Lexer::T_COMMA);
            }
        }
        $this->match(Lexer::T_ARRAY_END);
        return $params;
    }

    private function match(int $token): void
    {
        if (!$this->lexer->lookahead) {
            throw new SyntaxError(
                sprintf('Syntax error, unexpected end of stream, expected %s', $this->getConstant($token))
            );
        }

        if ($this->lexer->lookahead['type'] === $token) {
            $this->lexer->moveNext();

            return;
        }

        throw new SyntaxError(sprintf(
            'Syntax error, unexpected "%s" (%s), expected was %s',
            $this->lexer->lookahead['value'],
            $this->getConstant($this->lexer->lookahead['type']),
            $this->getConstant($token)
        ));
    }

    private function getConstant(int $value): string
    {
        $oClass = new \ReflectionClass(Lexer::class);
        return array_search($value, $oClass->getConstants());

    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace JMS\Serializer\Type;
6
7		use JMS\Serializer\Type\Exception\SyntaxError;
8
9		/**
10		* @internal
11		*/
12		final class Parser implements ParserInterface
13		{
14		/**
15		* @var Lexer
16		*/
17		private $lexer;
18
19	448	/**
20		* @var bool
21	448	*/
22	448	private $root = true;
23	448
24		public function parse(string $string): array
25	320	{
26		$this->lexer = new Lexer();
27		$this->lexer->setInput($string);
28	320	$this->lexer->moveNext();
29		return $this->visit();
30	314	}
31	6
32	6	/**
33		* @return mixed
34		*/
35		private function visit()
36		{
37		$this->lexer->moveNext();
38
39		if (!$this->lexer->token) {
40		throw new SyntaxError(
41		'Syntax error, unexpected end of stream'
42		);
43		}
44
45		if (Lexer::T_FLOAT === $this->lexer->token['type']) {
46		return floatval($this->lexer->token['value']);
47		} elseif (Lexer::T_INTEGER === $this->lexer->token['type']) {
48		return intval($this->lexer->token['value']);
49		} elseif (Lexer::T_NULL === $this->lexer->token['type']) {
50		return null;
51		} elseif (Lexer::T_STRING === $this->lexer->token['type']) {
52		return $this->lexer->token['value'];
53		} elseif (Lexer::T_IDENTIFIER === $this->lexer->token['type']) {
54		if ($this->lexer->isNextToken(Lexer::T_TYPE_START)) {
55		return $this->visitCompoundType();
56		} elseif ($this->lexer->isNextToken(Lexer::T_ARRAY_START)) {
57		return $this->visitArrayType();
58		}
59		return $this->visitSimpleType();
60		} elseif (!$this->root && Lexer::T_ARRAY_START === $this->lexer->token['type']) {
61		return $this->visitArrayType();
62		}
63
64		throw new SyntaxError(sprintf(
65		'Syntax error, unexpected "%s" (%s)',
66		$this->lexer->token['value'],
67		$this->getConstant($this->lexer->token['type'])
68		));
69		}
70
71		/**
72		* @return string\|mixed[]
73		*/
74		private function visitSimpleType()
75		{
76		$value = $this->lexer->token['value'];
77		return ['name' => $value, 'params' => []];
78		}
79
80		private function visitCompoundType(): array
81		{
82		$this->root = false;
83		$name = $this->lexer->token['value'];
84		$this->match(Lexer::T_TYPE_START);
85
86		$params = [];
87		if (!$this->lexer->isNextToken(Lexer::T_TYPE_END)) {
88		while (true) {
89		$params[] = $this->visit();
90
91		if ($this->lexer->isNextToken(Lexer::T_TYPE_END)) {
92		break;
93		}
94		$this->match(Lexer::T_COMMA);
95		}
96		}
97		$this->match(Lexer::T_TYPE_END);
98		return [
99		'name' => $name,
100		'params' => $params,
101		];
102		}
103
104		private function visitArrayType(): array
105		{
106		/*
107		* Here we should call $this->match(Lexer::T_ARRAY_START); to make it clean
108		* but the token has already been consumed by moveNext() in visit()
109		*/
110
111		$params = [];
112		if (!$this->lexer->isNextToken(Lexer::T_ARRAY_END)) {
113		while (true) {
114		$params[] = $this->visit();
115		if ($this->lexer->isNextToken(Lexer::T_ARRAY_END)) {
116		break;
117		}
118		$this->match(Lexer::T_COMMA);
119		}
120		}
121		$this->match(Lexer::T_ARRAY_END);
122		return $params;
123		}
124
125		private function match(int $token): void
126		{
127		if (!$this->lexer->lookahead) {
128		throw new SyntaxError(
129		sprintf('Syntax error, unexpected end of stream, expected %s', $this->getConstant($token))
130		);
131		}
132
133		if ($this->lexer->lookahead['type'] === $token) {
134		$this->lexer->moveNext();
135
136		return;
137		}
138
139		throw new SyntaxError(sprintf(
140		'Syntax error, unexpected "%s" (%s), expected was %s',
141		$this->lexer->lookahead['value'],
142		$this->getConstant($this->lexer->lookahead['type']),
143		$this->getConstant($token)
144		));
145		}
146
147		private function getConstant(int $value): string
148		{
149		$oClass = new \ReflectionClass(Lexer::class);
150		return array_search($value, $oClass->getConstants());
		0 ignored issues – show Bug Best Practice introduced 2020-06-07 19:34 UTC by Report Bug Copy Issue Report The expression `return array_search($val...oClass->getConstants())` could return the type `false` which is incompatible with the type-hinted return `string`. Consider adding an additional type-check to rule them out. Loading history...
151		}
152		}
153

schmittjoh / serializer

Pull Request — master (#1212)

Parser::visitSimpleType() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like