Parser::parseFragmentReference() - Code Metrics - Youshido/GraphQL - Measure and Improve Code Quality continuously with Scrutinizer

Parser::parseFragmentReference() A
last analyzed 2018-07-11 14:00 UTC

↳ Parent: Parser

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.9666
c	0
b	0
f	0
ccs	5
cts	5
cp	1
cc	1
nc	1
nop	0
crap	1

<?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\Exception\Parser\SyntaxErrorException;
use Youshido\GraphQL\Parser\Ast\Argument;
use Youshido\GraphQL\Parser\Ast\ArgumentValue\InputList;
use Youshido\GraphQL\Parser\Ast\ArgumentValue\InputObject;
use Youshido\GraphQL\Parser\Ast\ArgumentValue\Literal;
use Youshido\GraphQL\Parser\Ast\ArgumentValue\Variable;
use Youshido\GraphQL\Parser\Ast\ArgumentValue\VariableReference;
use Youshido\GraphQL\Parser\Ast\Directive;
use Youshido\GraphQL\Parser\Ast\Field;
use Youshido\GraphQL\Parser\Ast\Fragment;
use Youshido\GraphQL\Parser\Ast\FragmentReference;
use Youshido\GraphQL\Parser\Ast\Mutation;
use Youshido\GraphQL\Parser\Ast\Query;
use Youshido\GraphQL\Parser\Ast\TypedFragmentReference;

class Parser extends Tokenizer
{

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

    public function parse($source = null)
    {
        $this->init($source);

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

            switch ($tokenType) {
                case Token::TYPE_LBRACE:
                    foreach ($this->parseBody() as $query) {
                        $this->data['queries'][] = $query;
                    }

                    break;
                case Token::TYPE_QUERY:
                    $queries = $this->parseOperation(Token::TYPE_QUERY);
                    foreach ($queries as $query) {
                        $this->data['queries'][] = $query;
                    }

                    break;
                case Token::TYPE_MUTATION:
                    $mutations = $this->parseOperation(Token::TYPE_MUTATION);
                    foreach ($mutations as $query) {
                        $this->data['mutations'][] = $query;
                    }

                    break;

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

                    break;

                default:
                    throw new SyntaxErrorException('Incorrect request syntax', $this->getLocation());
            }
        }

        return $this->data;
    }

    private function init($source = null)

    {
        $this->initTokenizer($source);

        $this->data = [
            'queries'            => [],
            'mutations'          => [],
            'fragments'          => [],
            'fragmentReferences' => [],
            'variables'          => [],
            'variableReferences' => [],
        ];
    }

    protected function parseOperation($type = Token::TYPE_QUERY)
    {
        $operation  = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $directives = [];

        if ($this->matchMulti([Token::TYPE_QUERY, Token::TYPE_MUTATION])) {
            $this->lex();

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

            if ($this->match(Token::TYPE_LPAREN)) {
                $this->parseVariables();
            }

            if ($this->match(Token::TYPE_AT)) {
                $directives = $this->parseDirectiveList();
            }

        }

        $this->lex();

        $fields = [];

        while (!$this->match(Token::TYPE_RBRACE) && !$this->end()) {
            $this->eatMulti([Token::TYPE_COMMA]);

            $operation = $this->parseBodyItem($type, true);
            $operation->setDirectives($directives);

            $fields[] = $operation;
        }

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

        return $fields;
    }

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

        $this->lex();

        while (!$this->match(Token::TYPE_RBRACE) && !$this->end()) {
            $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 parseVariables()
    {
        $this->eat(Token::TYPE_LPAREN);

        while (!$this->match(Token::TYPE_RPAREN) && !$this->end()) {
            $this->eat(Token::TYPE_COMMA);

            $variableToken = $this->eat(Token::TYPE_VARIABLE);
            $nameToken     = $this->eatIdentifierToken();
            $this->eat(Token::TYPE_COLON);

            $isArray              = false;
            $arrayElementNullable = true;

            if ($this->match(Token::TYPE_LSQUARE_BRACE)) {
                $isArray = true;

                $this->eat(Token::TYPE_LSQUARE_BRACE);
                $type = $this->eatIdentifierToken()->getData();

                if ($this->match(Token::TYPE_REQUIRED)) {
                    $arrayElementNullable = false;
                    $this->eat(Token::TYPE_REQUIRED);
                }

                $this->eat(Token::TYPE_RSQUARE_BRACE);
            } else {
                $type = $this->eatIdentifierToken()->getData();
            }

            $required = false;
            if ($this->match(Token::TYPE_REQUIRED)) {
                $required = true;
                $this->eat(Token::TYPE_REQUIRED);
            }

            $variable = new Variable(
                $nameToken->getData(),
                $type,
                $required,
                $isArray,
                $arrayElementNullable,
                new Location($variableToken->getLine(), $variableToken->getColumn())
            );

            if ($this->match(Token::TYPE_EQUAL)) {
                $this->eat(Token::TYPE_EQUAL);
                $variable->setDefaultValue($this->parseValue());
            }

            $this->data['variables'][] = $variable;
        }

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

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

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

    protected function parseVariableReference()
    {
        $startToken = $this->expectMulti([Token::TYPE_VARIABLE]);

        if ($this->match(Token::TYPE_NUMBER) || $this->match(Token::TYPE_IDENTIFIER) || $this->match(Token::TYPE_QUERY)) {
            $name = $this->lex()->getData();

            $variable = $this->findVariable($name);
            if ($variable) {
                $variable->setUsed(true);
            }

            $variableReference = new VariableReference($name, $variable, new Location($startToken->getLine(), $startToken->getColumn()));

            $this->data['variableReferences'][] = $variableReference;

            return $variableReference;
        }

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

    protected function findVariable($name)
    {
        foreach ((array) $this->data['variables'] as $variable) {
            /** @var $variable Variable */
            if ($variable->getName() === $name) {
                return $variable;
            }
        }

        return null;
    }

    protected function parseFragmentReference()
    {
        $nameToken         = $this->eatIdentifierToken();
        $fragmentReference = new FragmentReference($nameToken->getData(), new Location($nameToken->getLine(), $nameToken->getColumn()));

        $this->data['fragmentReferences'][] = $fragmentReference;

        return $fragmentReference;
    }

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

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

        if ($this->eat(Token::TYPE_COLON)) {
            $alias     = $nameToken->getData();
            $nameToken = $this->eatIdentifierToken();
        }

        $bodyLocation = new Location($nameToken->getLine(), $nameToken->getColumn());
        $arguments    = $this->match(Token::TYPE_LPAREN) ? $this->parseArgumentList() : [];
        $directives   = $this->match(Token::TYPE_AT) ? $this->parseDirectiveList() : [];

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

            if (!$fields) {

                throw $this->createUnexpectedTokenTypeException($this->lookAhead->getType());
            }

            if ($type === Token::TYPE_QUERY) {

                return new Query($nameToken->getData(), $alias, $arguments, $fields, $directives, $bodyLocation);
            } elseif ($type === Token::TYPE_TYPED_FRAGMENT) {
                return new TypedFragmentReference($nameToken->getData(), $fields, $directives, $bodyLocation);
            } else {
                return new Mutation($nameToken->getData(), $alias, $arguments, $fields, $directives, $bodyLocation);
            }
        } else {

            if ($highLevel && $type === Token::TYPE_MUTATION) {
                return new Mutation($nameToken->getData(), $alias, $arguments, [], $directives, $bodyLocation);
            } elseif ($highLevel && $type === Token::TYPE_QUERY) {
                return new Query($nameToken->getData(), $alias, $arguments, [], $directives, $bodyLocation);
            }

            return new Field($nameToken->getData(), $alias, $arguments, $directives, $bodyLocation);
        }
    }

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

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

        while (!$this->match(Token::TYPE_RPAREN) && !$this->end()) {
            $this->eat(Token::TYPE_COMMA);
            $args[] = $this->parseArgument();
        }

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

        return $args;
    }

    protected function parseArgument()

    {
        $nameToken = $this->eatIdentifierToken();
        $this->expect(Token::TYPE_COLON);
        $value = $this->parseValue();

        return new Argument($nameToken->getData(), $value, new Location($nameToken->getLine(), $nameToken->getColumn()));
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    protected function parseDirectiveList()
    {
        $directives = [];

        while ($this->match(Token::TYPE_AT)) {
            $directives[] = $this->parseDirective();
            $this->eat(Token::TYPE_COMMA);
        }

        return $directives;
    }

    protected function parseDirective()

    {
        $this->expect(Token::TYPE_AT);

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

        return new Directive($nameToken->getData(), $args, new Location($nameToken->getLine(), $nameToken->getColumn()));
    }

    /**
     * @return array|InputList|InputObject|Literal|VariableReference
     *
     * @throws SyntaxErrorException
     */
    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_VARIABLE:
                return $this->parseVariableReference();

            case Token::TYPE_NUMBER:
            case Token::TYPE_STRING:
            case Token::TYPE_IDENTIFIER:
            case Token::TYPE_NULL:
            case Token::TYPE_TRUE:
            case Token::TYPE_FALSE:
                $token = $this->lex();

                return new Literal($token->getData(), new Location($token->getLine(), $token->getColumn()));
        }

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

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

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

            $this->eat(Token::TYPE_COMMA);
        }

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

        return $createType ? new InputList($list, new Location($startToken->getLine(), $startToken->getColumn())) : $list;
    }

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

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

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

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

        throw new SyntaxErrorException('Can\'t parse argument', $this->getLocation());
    }

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

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

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

            $object[$key] = $value;
        }

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

        return $createType ? new InputObject($object, new Location($startToken->getLine(), $startToken->getColumn())) : $object;
    }

    protected function parseFragment()
    {
        $this->lex();
        $nameToken = $this->eatIdentifierToken();

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

        $model = $this->eatIdentifierToken();

        $directives = $this->match(Token::TYPE_AT) ? $this->parseDirectiveList() : [];

        $fields = $this->parseBody(Token::TYPE_QUERY, false);

        return new Fragment($nameToken->getData(), $model->getData(), $directives, $fields, new Location($nameToken->getLine(), $nameToken->getColumn()));
    }

    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 ((array) $types as $type) {
            if ($this->peek()->getType() === $type) {
                return true;
            }
        }

        return false;
    }
}


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
12			use Youshido\GraphQL\Exception\Parser\SyntaxErrorException;
13			use Youshido\GraphQL\Parser\Ast\Argument;
14			use Youshido\GraphQL\Parser\Ast\ArgumentValue\InputList;
15			use Youshido\GraphQL\Parser\Ast\ArgumentValue\InputObject;
16			use Youshido\GraphQL\Parser\Ast\ArgumentValue\Literal;
17			use Youshido\GraphQL\Parser\Ast\ArgumentValue\Variable;
18			use Youshido\GraphQL\Parser\Ast\ArgumentValue\VariableReference;
19			use Youshido\GraphQL\Parser\Ast\Directive;
20			use Youshido\GraphQL\Parser\Ast\Field;
21			use Youshido\GraphQL\Parser\Ast\Fragment;
22			use Youshido\GraphQL\Parser\Ast\FragmentReference;
23			use Youshido\GraphQL\Parser\Ast\Mutation;
24			use Youshido\GraphQL\Parser\Ast\Query;
25			use Youshido\GraphQL\Parser\Ast\TypedFragmentReference;
26
27			class Parser extends Tokenizer
28			{
29
30			/** @var array */
31			private $data = [];
32
33	107		public function parse($source = null)
34			{
35	107		$this->init($source);
36
37	107		while (!$this->end()) {
38	106		$tokenType = $this->peek()->getType();
39
40			switch ($tokenType) {
41	106		case Token::TYPE_LBRACE:
42	57		foreach ($this->parseBody() as $query) {
43	52		$this->data['queries'][] = $query;
44	53		}
45
46	53		break;
47	54		case Token::TYPE_QUERY:
48	32		$queries = $this->parseOperation(Token::TYPE_QUERY);
49	32		foreach ($queries as $query) {
50	30		$this->data['queries'][] = $query;
51	32		}
52
53	32		break;
54	30		case Token::TYPE_MUTATION:
55	17		$mutations = $this->parseOperation(Token::TYPE_MUTATION);
56	12		foreach ($mutations as $query) {
57	12		$this->data['mutations'][] = $query;
58	12		}
59
60	12		break;
61
62	13		case Token::TYPE_FRAGMENT:
63	12		$this->data['fragments'][] = $this->parseFragment();
64
65	12		break;
66
67	1		default:
68	1		throw new SyntaxErrorException('Incorrect request syntax', $this->getLocation());
69	1		}
70	96		}
71
72	97		return $this->data;
73			}
74
75	107	View Code Duplication	private function init($source = null)
			0 ignored issues – show Duplication introduced 2017-07-31 11:08 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
76			{
77	107		$this->initTokenizer($source);
78
79	107		$this->data = [
80	107		'queries' => [],
81	107		'mutations' => [],
82	107		'fragments' => [],
83	107		'fragmentReferences' => [],
84	107		'variables' => [],
85	107		'variableReferences' => [],
86			];
87	107		}
88
89	49		protected function parseOperation($type = Token::TYPE_QUERY)
90			{
91	49		$operation = null;
			0 ignored issues – show Unused Code introduced 2017-08-10 02:45 UTC by Report Bug Copy Issue Report `$operation` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
92	49		$directives = [];
93
94	49		if ($this->matchMulti([Token::TYPE_QUERY, Token::TYPE_MUTATION])) {
95	49		$this->lex();
96
97	49		$this->eat(Token::TYPE_IDENTIFIER);
98
99	49		if ($this->match(Token::TYPE_LPAREN)) {
100	13		$this->parseVariables();
101	13		}
102
103	49		if ($this->match(Token::TYPE_AT)) {
104			$directives = $this->parseDirectiveList();
105			}
106
107	49		}
108
109	49		$this->lex();
110
111	49		$fields = [];
112
113	49		while (!$this->match(Token::TYPE_RBRACE) && !$this->end()) {
114	47		$this->eatMulti([Token::TYPE_COMMA]);
115
116	47		$operation = $this->parseBodyItem($type, true);
117	42		$operation->setDirectives($directives);
118
119	42		$fields[] = $operation;
120	42		}
121
122	44		$this->expect(Token::TYPE_RBRACE);
123
124	44		return $fields;
125			}
126
127	85		protected function parseBody($token = Token::TYPE_QUERY, $highLevel = true)
128			{
129	85		$fields = [];
130
131	85		$this->lex();
132
133	85		while (!$this->match(Token::TYPE_RBRACE) && !$this->end()) {
134	84		$this->eatMulti([Token::TYPE_COMMA]);
135
136	84		if ($this->match(Token::TYPE_FRAGMENT_REFERENCE)) {
137	14		$this->lex();
138
139	14		if ($this->eat(Token::TYPE_ON)) {
140	4		$fields[] = $this->parseBodyItem(Token::TYPE_TYPED_FRAGMENT, $highLevel);
141	4		} else {
142	12		$fields[] = $this->parseFragmentReference();
143			}
144	14		} else {
145	83		$fields[] = $this->parseBodyItem($token, $highLevel);
146			}
147	80		}
148
149	81		$this->expect(Token::TYPE_RBRACE);
150
151	81		return $fields;
152			}
153
154	13		protected function parseVariables()
155			{
156	13		$this->eat(Token::TYPE_LPAREN);
157
158	13		while (!$this->match(Token::TYPE_RPAREN) && !$this->end()) {
159	13		$this->eat(Token::TYPE_COMMA);
160
161	13		$variableToken = $this->eat(Token::TYPE_VARIABLE);
162	13		$nameToken = $this->eatIdentifierToken();
163	13		$this->eat(Token::TYPE_COLON);
164
165	13		$isArray = false;
166	13		$arrayElementNullable = true;
167
168	13		if ($this->match(Token::TYPE_LSQUARE_BRACE)) {
169	3		$isArray = true;
170
171	3		$this->eat(Token::TYPE_LSQUARE_BRACE);
172	3		$type = $this->eatIdentifierToken()->getData();
173
174	3		if ($this->match(Token::TYPE_REQUIRED)) {
175	2		$arrayElementNullable = false;
176	2		$this->eat(Token::TYPE_REQUIRED);
177	2		}
178
179	3		$this->eat(Token::TYPE_RSQUARE_BRACE);
180	3		} else {
181	12		$type = $this->eatIdentifierToken()->getData();
182			}
183
184	13		$required = false;
185	13		if ($this->match(Token::TYPE_REQUIRED)) {
186	2		$required = true;
187	2		$this->eat(Token::TYPE_REQUIRED);
188	2		}
189
190	13		$variable = new Variable(
191	13		$nameToken->getData(),
192	13		$type,
193	13		$required,
194	13		$isArray,
195	13		$arrayElementNullable,
196	13		new Location($variableToken->getLine(), $variableToken->getColumn())
197	13		);
198
199	13		if ($this->match(Token::TYPE_EQUAL)) {
200	1		$this->eat(Token::TYPE_EQUAL);
201	1		$variable->setDefaultValue($this->parseValue());
202	1		}
203
204	13		$this->data['variables'][] = $variable;
205	13		}
206
207	13		$this->expect(Token::TYPE_RPAREN);
208	13		}
209
210	102		protected function expectMulti($types)
211			{
212	102		if ($this->matchMulti($types)) {
213	102		return $this->lex();
214			}
215
216	2		throw $this->createUnexpectedException($this->peek());
217			}
218
219	12		protected function parseVariableReference()
220			{
221	12		$startToken = $this->expectMulti([Token::TYPE_VARIABLE]);
222
223	12		if ($this->match(Token::TYPE_NUMBER) \|\| $this->match(Token::TYPE_IDENTIFIER) \|\| $this->match(Token::TYPE_QUERY)) {
224	12		$name = $this->lex()->getData();
225
226	12		$variable = $this->findVariable($name);
227	12		if ($variable) {
228	12		$variable->setUsed(true);
229	12		}
230
231	12		$variableReference = new VariableReference($name, $variable, new Location($startToken->getLine(), $startToken->getColumn()));
232
233	12		$this->data['variableReferences'][] = $variableReference;
234
235	12		return $variableReference;
236			}
237
238			throw $this->createUnexpectedException($this->peek());
239			}
240
241	12		protected function findVariable($name)
242			{
243	12		foreach ((array) $this->data['variables'] as $variable) {
244			/** @var $variable Variable */
245	12		if ($variable->getName() === $name) {
246	12		return $variable;
247			}
248	3		}
249
250			return null;
251			}
252
253	12		protected function parseFragmentReference()
254			{
255	12		$nameToken = $this->eatIdentifierToken();
256	12		$fragmentReference = new FragmentReference($nameToken->getData(), new Location($nameToken->getLine(), $nameToken->getColumn()));
257
258	12		$this->data['fragmentReferences'][] = $fragmentReference;
259
260	12		return $fragmentReference;
261			}
262
263	102		protected function eatIdentifierToken()
264			{
265	102		return $this->expectMulti([
266	102		Token::TYPE_IDENTIFIER,
267	102		Token::TYPE_MUTATION,
268	102		Token::TYPE_QUERY,
269	102		Token::TYPE_FRAGMENT,
270	102		]);
271			}
272
273	102		protected function parseBodyItem($type = Token::TYPE_QUERY, $highLevel = true)
274			{
275	102		$nameToken = $this->eatIdentifierToken();
276	102		$alias = null;
277
278	102		if ($this->eat(Token::TYPE_COLON)) {
279	20		$alias = $nameToken->getData();
280	20		$nameToken = $this->eatIdentifierToken();
281	20		}
282
283	102		$bodyLocation = new Location($nameToken->getLine(), $nameToken->getColumn());
284	102		$arguments = $this->match(Token::TYPE_LPAREN) ? $this->parseArgumentList() : [];
285	95		$directives = $this->match(Token::TYPE_AT) ? $this->parseDirectiveList() : [];
286
287	95		if ($this->match(Token::TYPE_LBRACE)) {
288	66		$fields = $this->parseBody($type === Token::TYPE_TYPED_FRAGMENT ? Token::TYPE_QUERY : $type, false);
289
290	65		if (!$fields) {
			0 ignored issues – show Bug Best Practice introduced 2016-11-01 14:21 UTC by Report Bug Copy Issue Report The expression `$fields` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
291	3		throw $this->createUnexpectedTokenTypeException($this->lookAhead->getType());
292			}
293
294	64	View Code Duplication	if ($type === Token::TYPE_QUERY) {
			0 ignored issues – show Duplication introduced 2016-05-21 01:18 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
295	62		return new Query($nameToken->getData(), $alias, $arguments, $fields, $directives, $bodyLocation);
296	7		} elseif ($type === Token::TYPE_TYPED_FRAGMENT) {
297	4		return new TypedFragmentReference($nameToken->getData(), $fields, $directives, $bodyLocation);
298			} else {
299	3		return new Mutation($nameToken->getData(), $alias, $arguments, $fields, $directives, $bodyLocation);
300			}
301		View Code Duplication	} else {
			0 ignored issues – show Duplication introduced 2016-05-21 01:18 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
302	93		if ($highLevel && $type === Token::TYPE_MUTATION) {
303	10		return new Mutation($nameToken->getData(), $alias, $arguments, [], $directives, $bodyLocation);
304	84		} elseif ($highLevel && $type === Token::TYPE_QUERY) {
305	24		return new Query($nameToken->getData(), $alias, $arguments, [], $directives, $bodyLocation);
306			}
307
308	64		return new Field($nameToken->getData(), $alias, $arguments, $directives, $bodyLocation);
309			}
310			}
311
312	60		protected function parseArgumentList()
313			{
314	60		$args = [];
315
316	60		$this->expect(Token::TYPE_LPAREN);
317
318	60		while (!$this->match(Token::TYPE_RPAREN) && !$this->end()) {
319	60		$this->eat(Token::TYPE_COMMA);
320	60		$args[] = $this->parseArgument();
321	55		}
322
323	54		$this->expect(Token::TYPE_RPAREN);
324
325	53		return $args;
326			}
327
328	60	View Code Duplication	protected function parseArgument()
			0 ignored issues – show Duplication introduced 2017-07-31 11:08 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
329			{
330	60		$nameToken = $this->eatIdentifierToken();
331	60		$this->expect(Token::TYPE_COLON);
332	59		$value = $this->parseValue();
333
334	55		return new Argument($nameToken->getData(), $value, new Location($nameToken->getLine(), $nameToken->getColumn()));
			0 ignored issues – show Bug introduced 2016-11-19 05:02 UTC by Report Bug Copy Issue Report It seems like `$value` defined by `$this->parseValue()` on line `332` can also be of type `array`; however, `Youshido\GraphQL\Parser\...Argument::__construct()` does only seem to accept `object<Youshido\GraphQL\...erfaces\ValueInterface>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
335			}
336
337			protected function parseDirectiveList()
338			{
339			$directives = [];
340
341			while ($this->match(Token::TYPE_AT)) {
342			$directives[] = $this->parseDirective();
343			$this->eat(Token::TYPE_COMMA);
344			}
345
346			return $directives;
347			}
348
349		View Code Duplication	protected function parseDirective()
			0 ignored issues – show Duplication introduced 2017-07-31 11:08 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
350			{
351			$this->expect(Token::TYPE_AT);
352
353			$nameToken = $this->eatIdentifierToken();
354			$args = $this->match(Token::TYPE_LPAREN) ? $this->parseArgumentList() : [];
355
356			return new Directive($nameToken->getData(), $args, new Location($nameToken->getLine(), $nameToken->getColumn()));
357			}
358
359			/**
360			* @return array\|InputList\|InputObject\|Literal\|VariableReference
361			*
362			* @throws SyntaxErrorException
363			*/
364	59		protected function parseValue()
365			{
366	59		switch ($this->lookAhead->getType()) {
367	59		case Token::TYPE_LSQUARE_BRACE:
368	11		return $this->parseList();
369
370	48		case Token::TYPE_LBRACE:
371	8		return $this->parseObject();
372
373	40		case Token::TYPE_VARIABLE:
374	12		return $this->parseVariableReference();
375
376	33		case Token::TYPE_NUMBER:
377	33		case Token::TYPE_STRING:
378	33		case Token::TYPE_IDENTIFIER:
379	33		case Token::TYPE_NULL:
380	33		case Token::TYPE_TRUE:
381	33		case Token::TYPE_FALSE:
382	32		$token = $this->lex();
383
384	32		return new Literal($token->getData(), new Location($token->getLine(), $token->getColumn()));
385	1		}
386
387	1		throw $this->createUnexpectedException($this->lookAhead);
388			}
389
390	13		protected function parseList($createType = true)
391			{
392	13		$startToken = $this->eat(Token::TYPE_LSQUARE_BRACE);
393
394	13		$list = [];
395	13		while (!$this->match(Token::TYPE_RSQUARE_BRACE) && !$this->end()) {
396	13		$list[] = $this->parseListValue();
397
398	12		$this->eat(Token::TYPE_COMMA);
399	12		}
400
401	12		$this->expect(Token::TYPE_RSQUARE_BRACE);
402
403	12		return $createType ? new InputList($list, new Location($startToken->getLine(), $startToken->getColumn())) : $list;
404			}
405
406	19		protected function parseListValue()
407			{
408	19		switch ($this->lookAhead->getType()) {
409	19		case Token::TYPE_NUMBER:
410	19		case Token::TYPE_STRING:
411	19		case Token::TYPE_TRUE:
412	19		case Token::TYPE_FALSE:
413	19		case Token::TYPE_NULL:
414	19		case Token::TYPE_IDENTIFIER:
415	18		return $this->expect($this->lookAhead->getType())->getData();
416
417	5		case Token::TYPE_VARIABLE:
418			return $this->parseVariableReference();
419
420	5		case Token::TYPE_LBRACE:
421	4		return $this->parseObject(true);
422
423	3		case Token::TYPE_LSQUARE_BRACE:
424	2		return $this->parseList(false);
425	1		}
426
427	1		throw new SyntaxErrorException('Can\'t parse argument', $this->getLocation());
428			}
429
430	9		protected function parseObject($createType = true)
431			{
432	9		$startToken = $this->eat(Token::TYPE_LBRACE);
433
434	9		$object = [];
435	9		while (!$this->match(Token::TYPE_RBRACE) && !$this->end()) {
436	9		$key = $this->expectMulti([Token::TYPE_STRING, Token::TYPE_IDENTIFIER])->getData();
437	9		$this->expect(Token::TYPE_COLON);
438	9		$value = $this->parseListValue();
439
440	9		$this->eat(Token::TYPE_COMMA);
441
442	9		$object[$key] = $value;
443	9		}
444
445	7		$this->eat(Token::TYPE_RBRACE);
446
447	7		return $createType ? new InputObject($object, new Location($startToken->getLine(), $startToken->getColumn())) : $object;
448			}
449
450	12		protected function parseFragment()
451			{
452	12		$this->lex();
453	12		$nameToken = $this->eatIdentifierToken();
454
455	12		$this->eat(Token::TYPE_ON);
456
457	12		$model = $this->eatIdentifierToken();
458
459	12		$directives = $this->match(Token::TYPE_AT) ? $this->parseDirectiveList() : [];
460
461	12		$fields = $this->parseBody(Token::TYPE_QUERY, false);
462
463	12		return new Fragment($nameToken->getData(), $model->getData(), $directives, $fields, new Location($nameToken->getLine(), $nameToken->getColumn()));
464			}
465
466	104		protected function eat($type)
467			{
468	104		if ($this->match($type)) {
469	56		return $this->lex();
470			}
471
472	102		return null;
473			}
474
475	102		protected function eatMulti($types)
476			{
477	102		if ($this->matchMulti($types)) {
478			return $this->lex();
479			}
480
481	102		return null;
482			}
483
484	104		protected function matchMulti($types)
485			{
486	104		foreach ((array) $types as $type) {
487	104		if ($this->peek()->getType() === $type) {
488	104		return true;
489			}
490	102		}
491
492	102		return false;
493			}
494			}
495

Youshido / GraphQL

Parser::parseFragmentReference() A last analyzed 2018-07-11 14:00 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Parser::parseFragmentReference() A
last analyzed 2018-07-11 14:00 UTC