HansOtt\GraphQL\Query\Parser

Complexity

Total Complexity

83

Size/Duplication

Total Lines	488
Duplicated Lines	37.91 %

Coupling/Cohesion

Components	1
Dependencies	31

Test Coverage

Coverage

83.64%

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	accept()	10	10	2
A	is()	10	10	2
A	parseVariable()	0	7	1
A	parseArgument()	0	8	1
A	parseField()	0	22	3
A	parseNamedType()	0	11	2
A	parseDirective()	0	8	1
A	parseDirectiveList()	0	9	2
A	parseVariableDefinition()	0	13	2
A	parseDocument()	0	9	2
A	parse()	0	8	1
A	getParseError()	0	9	2
A	expect()	0	11	2
B	parseObject()	0	22	4
A	parseList()	20	20	4
C	parseValue()	0	51	12
B	parseArgumentList()	25	25	5
A	parseSelection()	19	19	4
A	parseSelectionSet()	19	19	4
A	parseTypeCondition()	0	12	2
A	parseListType()	20	20	4
A	parseType()	19	19	4
B	parseVariableDefinitionList()	25	25	5
C	parseDefinition()	18	67	9
A	parseFragment()	0	16	2

<?php

namespace HansOtt\GraphQL\Query;

final class Parser
{
    /**
     * @var ScannerTokens
     */
    private $scanner;
    private $lexer;

    public function __construct(Lexer $lexer)
    {
        $this->lexer = $lexer;
    }

    private function getParseError($message)
    {
        $token = $this->scanner->getLastToken();
        if ($this->scanner->eof() === false) {
            $token = $this->scanner->peek();
        }

        return new ParseError($message . " (line {$token->line}, column {$token->column})");
    }

    private function expect($tokenType)
    {
        $token = $this->scanner->next();

        if ($token->type !== $tokenType) {
            $expectedToken = Token::getNameFor($tokenType);
            throw $this->getParseError("Expected \"{$expectedToken}\" but instead found \"{$token->getName()}\" with value \"{$token->value}\"");
        }

        return $token;
    }

    private function accept($tokenType)

This method seems to be duplicated in your project.

    {
        $token = $this->scanner->peek();

        if ($token->type !== $tokenType) {
            return false;
        }

        return $this->scanner->next();
    }

    private function is($tokenType)

This method seems to be duplicated in your project.

    {
        if ($this->scanner->eof()) {
            return false;
        }

        $token = $this->scanner->peek();

        return $token->type === $tokenType;
    }

    private function parseObject()
    {
        $this->expect(Token::T_BRACE_LEFT);
        $fields = array();

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

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

            $name = $this->expect(Token::T_NAME)->value;
            $this->expect(Token::T_COLON);
            $fields[] = new ValueObjectField($name, $this->parseValue());
            $this->accept(Token::T_COMMA);
        }

        return new ValueObject($fields);
    }

    private function parseList()

This method seems to be duplicated in your project.

    {
        $this->expect(Token::T_BRACKET_LEFT);
        $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);
    }

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

        return new ValueVariable($name);
    }

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

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

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

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

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

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

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

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

        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()
    {
        $name = $this->expect(Token::T_NAME)->value;
        $this->expect(Token::T_COLON);
        $value = $this->parseValue();

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

    private function parseArgumentList()

This method seems to be duplicated in your project.

    {
        $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()
    {
        $name = $this->expect(Token::T_NAME)->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);
    }

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

        if ($fragmentName !== 'on') {
            return new SelectionFragmentSpread($fragmentName);
        }

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

        return new SelectionInlineFragment($typeCondition, $directives, $selectionSet);
    }

    private function parseSelection()

This method seems to be duplicated in your project.

    {
        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()

This method seems to be duplicated in your project.

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

        $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);
    }

    private function parseTypeCondition()
    {
        $on = $this->expect(Token::T_NAME)->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);

It seems like $type defined by $this->parseNamedType() on line 289 can also be of type object<HansOtt\GraphQL\Query\TypeNonNull>; however, HansOtt\GraphQL\Query\TypeCondition::__construct() does only seem to accept object<HansOtt\GraphQL\Query\TypeNamed>, maybe add an additional type check?

    }

    private function parseListType()

This method seems to be duplicated in your project.

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

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

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

            $types[] = $this->parseType();
            $this->accept(Token::T_COMMA);
        }

        return new TypeList($types);
    }

    private function parseNamedType()
    {
        $name = $this->expect(Token::T_NAME)->value;
        $type = new TypeNamed($name);

        if ($this->accept(Token::T_EXCLAMATION)) {
            return new TypeNonNull($type);
        }

        return $type;
    }

    private function parseType()

This method seems to be duplicated in your project.

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

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

        $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()
    {
        $this->expect(Token::T_AT);
        $name = $this->expect(Token::T_NAME)->value;
        $arguments = $this->parseArgumentList();

        return new Directive($name, $arguments);
    }

    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);
    }

    private function parseVariableDefinitionList()

This method seems to be duplicated in your project.

    {
        $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)) {
            $this->expect(Token::T_FRAGMENT);

            $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);
        }

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

This code seems to be duplicated across your project.

            $this->expect(Token::T_MUTATION);
            $name = $this->expect(Token::T_NAME)->value;
            $variables = $this->parseVariableDefinitionList();
            $directives = $this->parseDirectiveList();
            $selectionSet = $this->parseSelectionSet();

            return new OperationMutation($name, $variables, $directives, $selectionSet);
        }

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

This code seems to be duplicated across your project.

            $this->expect(Token::T_SUBSCRIPTION);
            $name = $this->expect(Token::T_NAME)->value;
            $variables = $this->parseVariableDefinitionList();
            $directives = $this->parseDirectiveList();
            $selectionSet = $this->parseSelectionSet();

            return new OperationSubscription($name, $variables, $directives, $selectionSet);
        }

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

            $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);
        }

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

            return new OperationQuery(null, array(), array(), $selectionSet);
        }

        $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()
    {
        $definitions = array();
        while ($this->scanner->eof() === false) {
            $definitions[] = $this->parseDefinition();
        }

        return new Document($definitions);
    }

    public function parse($query)
    {
        $tokens = $this->lexer->lex($query);
        $scanner = new ScannerGeneric($tokens);
        $this->scanner = new ScannerTokens($scanner);

        return $this->parseDocument();
    }
}