Parser - Code Metrics - Inspection of "Fix bug when no mutation was declared for schema" - Youshido/GraphQL - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 27dda5...bd0485 )

by Alexandr

created 2016-01-08 04:17 UTC

Parser F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	334
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	14

Test Coverage

Coverage

99.44%

Importance

Changes	14
Bugs	3	Features	7

Metric	Value
wmc	76
c	14
b	3
f	7
lcom	1
cbo	14
dl	0
loc	334
ccs	177
cts	178
cp	0.9944
rs	3.5632

20 Methods

Rating	Name	Size	Complexity
A	expect()	8	2
A	expectMulti()	8	2
A	parseReference()	10	3
A	parseFragmentReference()	6	1
A	parseIdentifier()	9	1
A	parseArgument()	8	1
B	parse()	28	6
C	parseBody()	36	7
C	parseBodyItem()	30	8
A	parseArgumentList()	21	4
C	parseValue()	29	12
B	parseList()	17	5
A	parseVariable()	8	1
A	parseFragment()	12	1
A	eat()	8	2
A	eatMulti()	8	2
A	match()	4	1
D	parseListValue()	30	9
B	parseObject()	21	5
A	matchMulti()	10	3

How to fix Complexity

<?php
/*
* This file is a part of graphql-youshido project.
*
* @author Portey Vasil <[email protected]>
* created: 11/23/15 1:22 AM
*/

namespace Youshido\GraphQL\Parser;

use Youshido\GraphQL\Parser\Ast\TypedFragment;
use Youshido\GraphQL\Parser\Ast\TypedFragmentReference;
use Youshido\GraphQL\Parser\Value\InputList;
use Youshido\GraphQL\Parser\Ast\Argument;
use Youshido\GraphQL\Parser\Ast\Field;
use Youshido\GraphQL\Parser\Ast\Fragment;
use Youshido\GraphQL\Parser\Ast\FragmentReference;
use Youshido\GraphQL\Parser\Value\InputObject;
use Youshido\GraphQL\Parser\Value\Literal;
use Youshido\GraphQL\Parser\Ast\Mutation;
use Youshido\GraphQL\Parser\Ast\Query;
use Youshido\GraphQL\Parser\Value\Variable;

class Parser extends Tokenizer
{

    public function parse()
    {
        $data = ['queries' => [], 'mutations' => [], 'fragments' => []];

        while (!$this->end()) {
            $tokenType = $this->peek()->getType();

            switch ($tokenType) {
                case Token::TYPE_LBRACE:
                case Token::TYPE_QUERY:
                    $data = array_merge($data, ['queries' => $this->parseBody()]);
                    break;

                case Token::TYPE_MUTATION:
                    $data = array_merge($data, ['mutations' => $this->parseBody(Token::TYPE_MUTATION)]);
                    break;

                case Token::TYPE_FRAGMENT:
                    $data['fragments'][] = $this->parseFragment();
                    break;

                default:
                    throw new SyntaxErrorException();
            }
        }

        return $data;
    }

    protected function parseBody($token = Token::TYPE_QUERY, $highLevel = true)
    {
        $fields = [];
        $first  = true;

        if ($this->peek()->getType() == $token) {
            $this->lex();
            $this->eat(Token::TYPE_IDENTIFIER);
        }

        $this->lex();

        while (!$this->match(Token::TYPE_RBRACE) && !$this->end()) {
            if ($first) {
                $first = false;
            } else {
                $this->eatMulti([Token::TYPE_COMMA]);
            }

            if ($this->match(Token::TYPE_FRAGMENT_REFERENCE)) {
                $this->lex();

                if ($this->eat(Token::TYPE_ON)) {
                    $fields[] = $this->parseBodyItem(Token::TYPE_TYPED_FRAGMENT, $highLevel);
                } else {
                    $fields[] = $this->parseFragmentReference();
                }
            } else {
                $fields[] = $this->parseBodyItem($token, $highLevel);
            }
        }

        $this->expect(Token::TYPE_RBRACE);

        return $fields;
    }

    protected function expect($type)
    {
        if ($this->match($type)) {
            return $this->lex();
        }

        throw $this->createUnexpected($this->peek());
    }

    protected function expectMulti($types)
    {
        if ($this->matchMulti($types)) {
            return $this->lex();
        }

        throw $this->createUnexpected($this->peek());
    }

    protected function parseReference()
    {
        $this->expectMulti([Token::TYPE_AMP, Token::TYPE_VARIABLE]);

        if ($this->match(Token::TYPE_NUMBER) || $this->match(Token::TYPE_IDENTIFIER)) {
            return new Variable($this->lex()->getData());
        }

        throw $this->createUnexpected($this->peek());
    }

    protected function parseFragmentReference()
    {
        $name = $this->parseIdentifier();

        return new FragmentReference($name);
    }

    protected function parseIdentifier()
    {
        return $this->expectMulti([
            Token::TYPE_IDENTIFIER,
            Token::TYPE_MUTATION,
            Token::TYPE_QUERY,
            Token::TYPE_FRAGMENT,
        ])->getData();
    }

    protected function parseBodyItem($type = Token::TYPE_QUERY, $highLevel = true)
    {
        $name  = $this->parseIdentifier();
        $alias = null;

        if ($this->eat(Token::TYPE_COLON)) {
            $alias = $name;
            $name  = $this->parseIdentifier();
        }

        $arguments = $this->match(Token::TYPE_LPAREN) ? $this->parseArgumentList() : [];

        if ($this->match(Token::TYPE_LBRACE)) {
            $fields = $this->parseBody($type, false);

            if ($type == Token::TYPE_QUERY) {
                return new Query($name, $alias, $arguments, $fields);
            } elseif ($type == Token::TYPE_TYPED_FRAGMENT) {
                return new TypedFragmentReference($name, $fields);
            } else {
                return new Mutation($name, $alias, $arguments, $fields);
            }
        } else {
            if ($highLevel && $type == Token::TYPE_MUTATION) {
                return new Mutation($name, $alias, $arguments);
            }

            return new Field($name, $alias);
        }
    }

    protected function parseArgumentList()
    {
        $args  = [];
        $first = true;

        $this->expect(Token::TYPE_LPAREN);

        while (!$this->match(Token::TYPE_RPAREN) && !$this->end()) {
            if ($first) {
                $first = false;
            } else {
                $this->expect(Token::TYPE_COMMA);
            }

            $args[] = $this->parseArgument();
        }

        $this->expect(Token::TYPE_RPAREN);

        return $args;
    }

    protected function parseArgument()
    {
        $name = $this->parseIdentifier();
        $this->expect(Token::TYPE_COLON);
        $value = $this->parseValue();

        return new Argument($name, $value);
    }

    protected function parseValue()
    {
        switch ($this->lookAhead->getType()) {
            case Token::TYPE_LSQUARE_BRACE:
                return $this->parseList();

            case Token::TYPE_LBRACE:
                return $this->parseObject();

            case Token::TYPE_AMP:
            case Token::TYPE_VARIABLE:
                return $this->parseReference();

            case Token::TYPE_LT:
                return $this->parseVariable();

            case Token::TYPE_NUMBER:
            case Token::TYPE_STRING:
            case Token::TYPE_IDENTIFIER:
                return new Literal($this->lex()->getData());

            case Token::TYPE_NULL:
            case Token::TYPE_TRUE:
            case Token::TYPE_FALSE:
                return new Literal($this->lex()->getData());
        }

        throw $this->createUnexpected($this->lookAhead);
    }

    protected function parseList($createType = true)
    {
        $this->eat(Token::TYPE_LSQUARE_BRACE);

        $list = [];
        while (!$this->match(Token::TYPE_RSQUARE_BRACE) && !$this->end()) {
            $list[] = $this->parseListValue();

            if ($this->lookAhead->getType() != Token::TYPE_RSQUARE_BRACE) {
                $this->expect(Token::TYPE_COMMA);
            }
        }

        $this->expect(Token::TYPE_RSQUARE_BRACE);

        return $createType ? new InputList($list) : $list;
    }

    protected function parseListValue()
    {
        switch ($this->lookAhead->getType()) {
            case Token::TYPE_NUMBER:
                return $this->expect(Token::TYPE_NUMBER)->getData();

            case Token::TYPE_STRING:
                return $this->expect(Token::TYPE_STRING)->getData();

            case Token::TYPE_LBRACE:
                return $this->parseObject(false);

            case Token::TYPE_LSQUARE_BRACE:
                return $this->parseList(false);

            case Token::TYPE_TRUE:
                return $this->expect(Token::TYPE_TRUE)->getData();

            case Token::TYPE_FALSE:
                return $this->expect(Token::TYPE_FALSE)->getData();

            case Token::TYPE_NULL:
                return $this->expect(Token::TYPE_NULL)->getData();

            case Token::TYPE_IDENTIFIER:
                return $this->expect(Token::TYPE_IDENTIFIER)->getData();
        }

        throw new SyntaxErrorException('Can\'t parse argument');
    }

    protected function parseObject($createType = true)
    {
        $this->eat(Token::TYPE_LBRACE);

        $object = [];
        while (!$this->match(Token::TYPE_RBRACE) && !$this->end()) {
            $key = $this->expect(Token::TYPE_STRING)->getData();
            $this->expect(Token::TYPE_COLON);
            $value = $this->parseListValue();

            if ($this->peek()->getType() != Token::TYPE_RBRACE) {
                $this->expect(Token::TYPE_COMMA);
            }

            $object[$key] = $value;
        }

        $this->eat(Token::TYPE_RBRACE);

        return $createType ? new InputObject($object) : $object;
    }

    protected function parseVariable()
    {
        $this->expect(Token::TYPE_LT);
        $name = $this->expect(Token::TYPE_IDENTIFIER)->getData();
        $this->expect(Token::TYPE_GT);

        return new Variable($name);
    }

    protected function parseFragment()
    {
        $this->lex();
        $name = $this->parseIdentifier();

        $this->eat(Token::TYPE_ON);

        $model  = $this->parseIdentifier();
        $fields = $this->parseBody();

        return new Fragment($name, $model, $fields);
    }

    protected function eat($type)
    {
        if ($this->match($type)) {
            return $this->lex();
        }

        return null;
    }

    protected function eatMulti($types)
    {
        if ($this->matchMulti($types)) {
            return $this->lex();
        }

        return null;
    }

    protected function matchMulti($types)
    {
        foreach ($types as $type) {
            if ($this->peek()->getType() == $type) {
                return true;
            }
        }

        return false;
    }

    protected function match($type)
    {
        return $this->peek()->getType() === $type;
    }
}

1		<?php
2		/*
3		* This file is a part of graphql-youshido project.
4		*
5		* @author Portey Vasil <[email protected]>
6		* created: 11/23/15 1:22 AM
7		*/
8
9		namespace Youshido\GraphQL\Parser;
10
11		use Youshido\GraphQL\Parser\Ast\TypedFragment;
12		use Youshido\GraphQL\Parser\Ast\TypedFragmentReference;
13		use Youshido\GraphQL\Parser\Value\InputList;
14		use Youshido\GraphQL\Parser\Ast\Argument;
15		use Youshido\GraphQL\Parser\Ast\Field;
16		use Youshido\GraphQL\Parser\Ast\Fragment;
17		use Youshido\GraphQL\Parser\Ast\FragmentReference;
18		use Youshido\GraphQL\Parser\Value\InputObject;
19		use Youshido\GraphQL\Parser\Value\Literal;
20		use Youshido\GraphQL\Parser\Ast\Mutation;
21		use Youshido\GraphQL\Parser\Ast\Query;
22		use Youshido\GraphQL\Parser\Value\Variable;
23
24		class Parser extends Tokenizer
25		{
26
27	45	public function parse()
28		{
29	45	$data = ['queries' => [], 'mutations' => [], 'fragments' => []];
30
31	45	while (!$this->end()) {
32	45	$tokenType = $this->peek()->getType();
33
34		switch ($tokenType) {
35	45	case Token::TYPE_LBRACE:
36	16	case Token::TYPE_QUERY:
37	39	$data = array_merge($data, ['queries' => $this->parseBody()]);
38	33	break;
39
40	9	case Token::TYPE_MUTATION:
41	5	$data = array_merge($data, ['mutations' => $this->parseBody(Token::TYPE_MUTATION)]);
42	3	break;
43
44	4	case Token::TYPE_FRAGMENT:
45	3	$data['fragments'][] = $this->parseFragment();
46	3	break;
47
48		default:
49	1	throw new SyntaxErrorException();
50		}
51		}
52
53	36	return $data;
54		}
55
56	44	protected function parseBody($token = Token::TYPE_QUERY, $highLevel = true)
57		{
58	44	$fields = [];
59	44	$first = true;
60
61	44	if ($this->peek()->getType() == $token) {
62	14	$this->lex();
63	14	$this->eat(Token::TYPE_IDENTIFIER);
64		}
65
66	44	$this->lex();
67
68	44	while (!$this->match(Token::TYPE_RBRACE) && !$this->end()) {
69	41	if ($first) {
70	41	$first = false;
71		} else {
72	18	$this->eatMulti([Token::TYPE_COMMA]);
73		}
74
75	41	if ($this->match(Token::TYPE_FRAGMENT_REFERENCE)) {
76	6	$this->lex();
77
78	6	if ($this->eat(Token::TYPE_ON)) {
79	3	$fields[] = $this->parseBodyItem(Token::TYPE_TYPED_FRAGMENT, $highLevel);
80		} else {
81	6	$fields[] = $this->parseFragmentReference();
82		}
83		} else {
84	41	$fields[] = $this->parseBodyItem($token, $highLevel);
85		}
86		}
87
88	37	$this->expect(Token::TYPE_RBRACE);
89
90	37	return $fields;
91		}
92
93	42	protected function expect($type)
94		{
95	42	if ($this->match($type)) {
96	42	return $this->lex();
97		}
98
99	3	throw $this->createUnexpected($this->peek());
100		}
101
102	41	protected function expectMulti($types)
103		{
104	41	if ($this->matchMulti($types)) {
105	41	return $this->lex();
106		}
107
108	2	throw $this->createUnexpected($this->peek());
109		}
110
111	4	protected function parseReference()
112		{
113	4	$this->expectMulti([Token::TYPE_AMP, Token::TYPE_VARIABLE]);
114
115	4	if ($this->match(Token::TYPE_NUMBER) \|\| $this->match(Token::TYPE_IDENTIFIER)) {
116	3	return new Variable($this->lex()->getData());
117		}
118
119	1	throw $this->createUnexpected($this->peek());
120		}
121
122	3	protected function parseFragmentReference()
123		{
124	3	$name = $this->parseIdentifier();
125
126	3	return new FragmentReference($name);
127		}
128
129	41	protected function parseIdentifier()
130		{
131	41	return $this->expectMulti([
132	41	Token::TYPE_IDENTIFIER,
133	41	Token::TYPE_MUTATION,
134	41	Token::TYPE_QUERY,
135	41	Token::TYPE_FRAGMENT,
136	41	])->getData();
137		}
138
139	41	protected function parseBodyItem($type = Token::TYPE_QUERY, $highLevel = true)
140		{
141	41	$name = $this->parseIdentifier();
142	41	$alias = null;
143
144	41	if ($this->eat(Token::TYPE_COLON)) {
145	10	$alias = $name;
146	10	$name = $this->parseIdentifier();
147		}
148
149	41	$arguments = $this->match(Token::TYPE_LPAREN) ? $this->parseArgumentList() : [];
150
151	36	if ($this->match(Token::TYPE_LBRACE)) {
152	34	$fields = $this->parseBody($type, false);
153
154	32	if ($type == Token::TYPE_QUERY) {
155	31	return new Query($name, $alias, $arguments, $fields);
156	4	} elseif ($type == Token::TYPE_TYPED_FRAGMENT) {
157	3	return new TypedFragmentReference($name, $fields);
158		} else {
159	1	return new Mutation($name, $alias, $arguments, $fields);
160		}
161		} else {
162	36	if ($highLevel && $type == Token::TYPE_MUTATION) {
163	2	return new Mutation($name, $alias, $arguments);
164		}
165
166	34	return new Field($name, $alias);
167		}
168		}
169
170	20	protected function parseArgumentList()
171		{
172	20	$args = [];
173	20	$first = true;
174
175	20	$this->expect(Token::TYPE_LPAREN);
176
177	20	while (!$this->match(Token::TYPE_RPAREN) && !$this->end()) {
178	20	if ($first) {
179	20	$first = false;
180		} else {
181	3	$this->expect(Token::TYPE_COMMA);
182		}
183
184	20	$args[] = $this->parseArgument();
185		}
186
187	15	$this->expect(Token::TYPE_RPAREN);
188
189	15	return $args;
190		}
191
192	20	protected function parseArgument()
193		{
194	20	$name = $this->parseIdentifier();
195	20	$this->expect(Token::TYPE_COLON);
196	20	$value = $this->parseValue();
197
198	15	return new Argument($name, $value);
199		}
200
201	20	protected function parseValue()
202		{
203	20	switch ($this->lookAhead->getType()) {
204	20	case Token::TYPE_LSQUARE_BRACE:
205	3	return $this->parseList();
206
207	17	case Token::TYPE_LBRACE:
208	3	return $this->parseObject();
209
210	14	case Token::TYPE_AMP:
211	14	case Token::TYPE_VARIABLE:
212	4	return $this->parseReference();
213
214	11	case Token::TYPE_LT:
215	1	return $this->parseVariable();
216
217	10	case Token::TYPE_NUMBER:
218	8	case Token::TYPE_STRING:
219	4	case Token::TYPE_IDENTIFIER:
220	9	return new Literal($this->lex()->getData());
221
222	2	case Token::TYPE_NULL:
223	2	case Token::TYPE_TRUE:
224	1	case Token::TYPE_FALSE:
225	1	return new Literal($this->lex()->getData());
226		}
227
228	1	throw $this->createUnexpected($this->lookAhead);
229		}
230
231	4	protected function parseList($createType = true)
232		{
233	4	$this->eat(Token::TYPE_LSQUARE_BRACE);
234
235	4	$list = [];
236	4	while (!$this->match(Token::TYPE_RSQUARE_BRACE) && !$this->end()) {
237	4	$list[] = $this->parseListValue();
238
239	3	if ($this->lookAhead->getType() != Token::TYPE_RSQUARE_BRACE) {
240	3	$this->expect(Token::TYPE_COMMA);
241		}
242		}
243
244	3	$this->expect(Token::TYPE_RSQUARE_BRACE);
245
246	3	return $createType ? new InputList($list) : $list;
247		}
248
249	6	protected function parseListValue()
250		{
251	6	switch ($this->lookAhead->getType()) {
252	6	case Token::TYPE_NUMBER:
253	5	return $this->expect(Token::TYPE_NUMBER)->getData();
254
255	4	case Token::TYPE_STRING:
256	2	return $this->expect(Token::TYPE_STRING)->getData();
257
258	4	case Token::TYPE_LBRACE:
259	1	return $this->parseObject(false);
260
261	4	case Token::TYPE_LSQUARE_BRACE:
262	1	return $this->parseList(false);
263
264	3	case Token::TYPE_TRUE:
265	1	return $this->expect(Token::TYPE_TRUE)->getData();
266
267	3	case Token::TYPE_FALSE:
268	1	return $this->expect(Token::TYPE_FALSE)->getData();
269
270	3	case Token::TYPE_NULL:
271	2	return $this->expect(Token::TYPE_NULL)->getData();
272
273	1	case Token::TYPE_IDENTIFIER:
274		return $this->expect(Token::TYPE_IDENTIFIER)->getData();
275		}
276
277	1	throw new SyntaxErrorException('Can\'t parse argument');
278		}
279
280	3	protected function parseObject($createType = true)
281		{
282	3	$this->eat(Token::TYPE_LBRACE);
283
284	3	$object = [];
285	3	while (!$this->match(Token::TYPE_RBRACE) && !$this->end()) {
286	3	$key = $this->expect(Token::TYPE_STRING)->getData();
287	3	$this->expect(Token::TYPE_COLON);
288	3	$value = $this->parseListValue();
289
290	3	if ($this->peek()->getType() != Token::TYPE_RBRACE) {
291	3	$this->expect(Token::TYPE_COMMA);
292		}
293
294	3	$object[$key] = $value;
295		}
296
297	1	$this->eat(Token::TYPE_RBRACE);
298
299	1	return $createType ? new InputObject($object) : $object;
300		}
301
302	1	protected function parseVariable()
303		{
304	1	$this->expect(Token::TYPE_LT);
305	1	$name = $this->expect(Token::TYPE_IDENTIFIER)->getData();
306	1	$this->expect(Token::TYPE_GT);
307
308	1	return new Variable($name);
309		}
310
311	3	protected function parseFragment()
312		{
313	3	$this->lex();
314	3	$name = $this->parseIdentifier();
315
316	3	$this->eat(Token::TYPE_ON);
317
318	3	$model = $this->parseIdentifier();
319	3	$fields = $this->parseBody();
320
321	3	return new Fragment($name, $model, $fields);
322		}
323
324	43	protected function eat($type)
325		{
326	43	if ($this->match($type)) {
327	21	return $this->lex();
328		}
329
330	42	return null;
331		}
332
333	18	protected function eatMulti($types)
334		{
335	18	if ($this->matchMulti($types)) {
336	16	return $this->lex();
337		}
338
339	2	return null;
340		}
341
342	41	protected function matchMulti($types)
343		{
344	41	foreach ($types as $type) {
345	41	if ($this->peek()->getType() == $type) {
346	41	return true;
347		}
348		}
349
350	4	return false;
351		}
352
353	44	protected function match($type)
354		{
355	44	return $this->peek()->getType() === $type;
356		}
357		}

Youshido / GraphQL

Push — master ( 27dda5...bd0485 )

Parser F

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

20 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like