Parser::parseDefinition() - Code Metrics - Inspection of "master" - hansott/graphql-language - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#2)

by Hans

created 2017-12-01 19:35 UTC

Parser::parseDefinition() C

↳ Parent: Parser

Complexity

Conditions	11
Paths	11

Size

Total Lines	77
Code Lines	45

Duplication

Lines	42
Ratio	54.55 %

Code Coverage

Tests	24
CRAP Score	26.125

Importance

Changes

Metric	Value
dl	42
loc	77
ccs	24
cts	48
cp	0.5
rs	5.3974
c	0
b	0
f	0
cc	11
eloc	45
nc	11
nop	0
crap	26.125

How to fix Long Method Complexity

<?php

namespace HansOtt\GraphQL\Query;

use HansOtt\GraphQL\Shared\ScannerTokens;
use HansOtt\GraphQL\Shared\ScannerGeneric;
use HansOtt\GraphQL\Shared\Parser as ParserShared;

final class Parser extends ParserShared
{
    protected function getNameFor($tokenType)
    {
        return Token::getNameFor($tokenType);
    }

    private function parseObject()

    {
        $location = $this->expect(Token::T_BRACE_LEFT)->location;
        $fields = array();

        while (true) {
            if ($this->scanner->eof()) {
                throw $this->getParseError('Unclosed brace of object value');
            }

            if ($this->accept(Token::T_BRACE_RIGHT)) {
                break;
            }

            $nameToken = $this->expect(Token::T_NAME);
            $this->expect(Token::T_COLON);
            $fields[] = new ValueObjectField($nameToken->value, $this->parseValue(), $nameToken->location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->accept(Token::T_COMMA);
        }

        return new ValueObject($fields, $location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    private function parseList()

    {
        $location = $this->expect(Token::T_BRACKET_LEFT)->location;
        $items = array();

        while (true) {
            if ($this->scanner->eof()) {
                throw $this->getParseError('Unclosed bracket of list');
            }

            if ($this->accept(Token::T_BRACKET_RIGHT)) {
                break;
            }

            $items[] = $this->parseValue();
            $this->accept(Token::T_COMMA);
        }

        return new ValueList($items, $location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    private function parseVariable()
    {
        $location = $this->expect(Token::T_DOLLAR)->location;
        $name = $this->expect(Token::T_NAME)->value;

        return new ValueVariable($name, $location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    private function parseValue()
    {
        if ($this->is(Token::T_DOLLAR)) {
            return $this->parseVariable();
        }

        if ($string = $this->accept(Token::T_STRING)) {
            return new ValueString($string->value, $string->location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        if ($true = $this->accept(Token::T_TRUE)) {
            return new ValueBoolean(true, $true->location);
        }

        if ($false = $this->accept(Token::T_FALSE)) {
            return new ValueBoolean(false, $false->location);
        }

        if ($null = $this->accept(Token::T_NULL)) {
            return new ValueNull($null->location);
        }

        if ($int = $this->accept(Token::T_INT)) {
            return new ValueInt($int->value, $int->location);
        }

        if ($float = $this->accept(Token::T_FLOAT)) {
            return new ValueFloat($float->value, $float->location);
        }

        if ($name = $this->accept(Token::T_NAME)) {
            return new ValueEnum($name->value, $name->location);
        }

        if ($this->is(Token::T_BRACKET_LEFT)) {
            return $this->parseList();
        }

        if ($this->is(Token::T_BRACE_LEFT)) {
            return $this->parseObject();
        }

        $message = 'Expected a value';

        if ($this->scanner->eof()) {
            throw $this->getParseError($message . ' but instead reached end');
        }

        $token = $this->scanner->peek();
        throw $this->getParseError($message . " but instead found \"{$token->getName()}\" with value \"{$token->value}\"");
    }

    private function parseArgument()
    {
        $nameToken = $this->expect(Token::T_NAME);
        $this->expect(Token::T_COLON);
        $value = $this->parseValue();

        return new Argument($nameToken->value, $value, $nameToken->location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    private function parseArgumentList()

    {
        $arguments = array();

        if ($this->is(Token::T_PAREN_LEFT) === false) {
            return $arguments;
        }

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

        while (true) {
            if ($this->scanner->eof()) {
                throw $this->getParseError('Unclosed brace of argument list');
            }

            if ($this->accept(Token::T_PAREN_RIGHT)) {
                break;
            }

            $arguments[] = $this->parseArgument();
            $this->accept(Token::T_COMMA);
        }

        return $arguments;
    }

    private function parseField()
    {
        $nameToken = $this->expect(Token::T_NAME);
        $name = $nameToken->value;

        $alias = null;
        if ($this->is(Token::T_COLON)) {
            $this->expect(Token::T_COLON);
            $aliasToken = $this->expect(Token::T_NAME);
            $alias = $name;
            $name = $aliasToken->value;
        }

        $arguments = $this->parseArgumentList();
        $directives = $this->parseDirectiveList();

        $selectionSet = null;
        if ($this->is(Token::T_BRACE_LEFT)) {
            $selectionSet = $this->parseSelectionSet();
        }

        return new SelectionField($alias, $name, $arguments, $directives, $selectionSet, $nameToken->location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    private function parseFragment()
    {
        $location = $this->expect(Token::T_SPREAD)->location;
        $fragmentName = $this->expect(Token::T_NAME)->value;

        if ($fragmentName !== 'on') {
            return new SelectionFragmentSpread($fragmentName, $location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        $this->scanner->back();
        $typeCondition = $this->parseTypeCondition();
        $directives = $this->parseDirectiveList();
        $selectionSet = $this->parseSelectionSet();

        return new SelectionInlineFragment($typeCondition, $directives, $selectionSet, $location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    private function parseSelection()

    {
        if ($this->is(Token::T_SPREAD)) {
            return $this->parseFragment();
        }

        if ($this->is(Token::T_NAME)) {
            return $this->parseField();
        }

        $message = 'Expected a field, a fragment spread or an inline fragment';

        if ($this->scanner->eof()) {
            throw $this->getParseError($message . ' but instead reached end');
        }

        $token = $this->scanner->peek();
        throw $this->getParseError($message . " but instead found \"{$token->getName()}\" with value \"{$token->value}\"");
    }

    private function parseSelectionSet()

    {
        $location = $this->expect(Token::T_BRACE_LEFT)->location;

        /** @var Selection[] $selections */
        $selections = array();
        while (true) {
            if ($this->scanner->eof()) {
                throw $this->getParseError('Unclosed brace of selection set');
            }

            if ($this->accept(Token::T_BRACE_RIGHT)) {
                break;
            }

            $selections[] = $this->parseSelection();
        }

        return new SelectionSet($selections, $location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    private function parseTypeCondition()
    {
        $nameToken = $this->expect(Token::T_NAME);
        $on = $nameToken->value;
        if ($on !== 'on') {
            $tokenNameName = Token::getNameFor(Token::T_NAME);
            throw $this->getParseError("Expected a type condition but instead found \"{$tokenNameName}\" with value \"{$on}\"");
        }

        $type = $this->parseNamedType();

        return new TypeCondition($type, $nameToken->location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    private function parseListType()
    {
        $location = $this->expect(Token::T_BRACKET_LEFT)->location;
        $type = $this->parseType();
        $this->accept(Token::T_BRACKET_RIGHT);

        return new TypeList($type, $location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    private function parseNamedType()
    {
        $nameToken = $this->expect(Token::T_NAME);
        $type = new TypeNamed($nameToken->value, $nameToken->location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        return $type;
    }

    private function parseType()
    {
        $type = null;
        if ($this->is(Token::T_BRACKET_LEFT)) {
            $type = $this->parseListType();
        } elseif ($this->is(Token::T_NAME)) {
            $type = $this->parseNamedType();
        }

        if ($type !== null) {
            if ($this->accept(Token::T_EXCLAMATION)) {
                return new TypeNonNull($type, $type->location);
            }
            return $type;
        }

        $message = 'Expected a type';

        if ($this->scanner->eof()) {
            throw $this->getParseError($message . ' but instead reached end');
        }

        $token = $this->scanner->peek();
        throw $this->getParseError($message . " but instead found \"{$token->getName()}\" with value \"{$token->value}\"");
    }

    private function parseDirective()
    {
        $location = $this->expect(Token::T_AT)->location;
        $name = $this->expect(Token::T_NAME)->value;
        $arguments = $this->parseArgumentList();

        return new Directive($name, $arguments, $location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    private function parseDirectiveList()
    {
        $directives = array();
        while ($this->is(Token::T_AT)) {
            $directives[] = $this->parseDirective();
        }

        return $directives;
    }

    private function parseVariableDefinition()

    {
        $variable = $this->parseVariable();
        $this->expect(Token::T_COLON);
        $type = $this->parseType();
        $defaultValue = null;

        if ($this->accept(Token::T_EQUAL)) {
            $defaultValue = $this->parseValue();
        }

        return new VariableDefinition($variable, $type, $defaultValue, $variable->location);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

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

    private function parseVariableDefinitionList()

    {
        $definitions = array();

        if ($this->is(Token::T_PAREN_LEFT) === false) {
            return $definitions;
        }

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

        while (true) {
            if ($this->scanner->eof()) {
                throw $this->getParseError('Unclosed parenthesis of variable definition list');
            }

            if ($this->accept(Token::T_PAREN_RIGHT)) {
                break;
            }

            $definitions[] = $this->parseVariableDefinition();
            $this->accept(Token::T_COMMA);
        }

        return $definitions;
    }

    private function parseDefinition()
    {
        if ($this->is(Token::T_FRAGMENT)) {
            $location = $this->expect(Token::T_FRAGMENT)->location;

            $name = $this->expect(Token::T_NAME)->value;
            if ($name === 'on') {
                throw $this->getParseError('A fragment cannot be named "on"');
            }

            $typeCondition = $this->parseTypeCondition();
            $directives = $this->parseDirectiveList();
            $selectionSet = $this->parseSelectionSet();

            return new Fragment($name, $typeCondition, $directives, $selectionSet, $location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        if ($this->is(Token::T_MUTATION)) {

            $location = $this->expect(Token::T_MUTATION)->location;

            $name = null;
            if ($this->is(Token::T_NAME)) {
                $name = $this->expect(Token::T_NAME)->value;
            }

            $variables = $this->parseVariableDefinitionList();
            $directives = $this->parseDirectiveList();
            $selectionSet = $this->parseSelectionSet();

            return new OperationMutation($name, $variables, $directives, $selectionSet, $location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        if ($this->is(Token::T_SUBSCRIPTION)) {

            $location = $this->expect(Token::T_SUBSCRIPTION)->location;

            $name = null;
            if ($this->is(Token::T_NAME)) {
                $name = $this->expect(Token::T_NAME)->value;
            }

            $variables = $this->parseVariableDefinitionList();
            $directives = $this->parseDirectiveList();
            $selectionSet = $this->parseSelectionSet();

            return new OperationSubscription($name, $variables, $directives, $selectionSet, $location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        if ($this->is(Token::T_QUERY)) {

            $location = $this->expect(Token::T_QUERY)->location;

            $name = null;
            if ($this->is(Token::T_NAME)) {
                $name = $this->expect(Token::T_NAME)->value;
            }

            $variables = $this->parseVariableDefinitionList();
            $directives = $this->parseDirectiveList();
            $selectionSet = $this->parseSelectionSet();

            return new OperationQuery($name, $variables, $directives, $selectionSet, $location);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        if ($this->is(Token::T_BRACE_LEFT)) {
            $selectionSet = $this->parseSelectionSet();

            return new OperationQuery(null, array(), array(), $selectionSet, $selectionSet->location);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

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

        $message = 'Expected a query, a query shorthand, a mutation or a subscription operation';

        if ($this->scanner->eof()) {
            throw $this->getParseError($message . ' but instead reached end');
        }

        $token = $this->scanner->peek();
        throw $this->getParseError($message . " but instead found \"{$token->getName()}\" with value \"{$token->value}\"");
    }

    private function parseDocument()
    {
        /** @var Definition[] $definitions */
        $definitions = array();
        while ($this->scanner->eof() === false) {
            $definitions[] = $this->parseDefinition();
        }

        return new Document($definitions);
    }

    /**
     * @param string $query
     *
     * @throws \HansOtt\GraphQL\Shared\SyntaxError
     *
     * @return Document
     */
    public function parse($query)
    {
        $tokens = $this->lexer->lex($query);
        $scanner = new ScannerGeneric($tokens);
        $this->scanner = new ScannerTokens($scanner);
        $document = $this->parseDocument();

        return $document;
    }
}


1			<?php
2
3			namespace HansOtt\GraphQL\Query;
4
5			use HansOtt\GraphQL\Shared\ScannerTokens;
6			use HansOtt\GraphQL\Shared\ScannerGeneric;
7			use HansOtt\GraphQL\Shared\Parser as ParserShared;
8
9			final class Parser extends ParserShared
10			{
11	6		protected function getNameFor($tokenType)
12			{
13	6		return Token::getNameFor($tokenType);
14			}
15
16	6	View Code Duplication	private function parseObject()
			0 ignored issues – show Duplication introduced 2017-09-23 18:42 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...
17			{
18	3		$location = $this->expect(Token::T_BRACE_LEFT)->location;
19	3		$fields = array();
20
21	3		while (true) {
22	3		if ($this->scanner->eof()) {
23			throw $this->getParseError('Unclosed brace of object value');
24			}
25
26	3		if ($this->accept(Token::T_BRACE_RIGHT)) {
27	6		break;
28			}
29
30	3		$nameToken = $this->expect(Token::T_NAME);
31	3		$this->expect(Token::T_COLON);
32	3		$fields[] = new ValueObjectField($nameToken->value, $this->parseValue(), $nameToken->location);
			0 ignored issues – show Documentation introduced 2017-09-23 18:42 UTC by Report Bug Copy Issue Report `$nameToken->location` is of type `object<HansOtt\GraphQL\Shared\Location>`, but the function expects a `null\|object<HansOtt\GraphQL\Query\Location>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
33	3		$this->accept(Token::T_COMMA);
34	3		}
35
36	3		return new ValueObject($fields, $location);
			0 ignored issues – show Documentation introduced 2017-09-23 18:42 UTC by Report Bug Copy Issue Report `$location` is of type `object<HansOtt\GraphQL\Shared\Location>`, but the function expects a `null\|object<HansOtt\GraphQL\Query\Location>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
37			}

hansott / graphql-language

Pull Request — master (#2)

Parser::parseDefinition() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like