Parser::parseValue() - Code Metrics - Inspection of "Merge pull request #1 from hansott/feature-schema-..." - hansott/graphql-language - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b0b79e...9ac4d8 )

by Hans

created 2017-09-23 18:45 UTC

Parser::parseValue() C

↳ Parent: Parser

Complexity

Conditions	11
Paths	11

Size

Total Lines	47
Code Lines	24

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	13
CRAP Score	22.6475

Importance

Changes

Metric	Value
dl	0
loc	47
ccs	13
cts	24
cp	0.5417
rs	5.2653
c	0
b	0
f	0
cc	11
eloc	24
nc	11
nop	0
crap	22.6475

How to fix Complexity

<?php

namespace HansOtt\GraphQL\Schema;

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

final class Parser extends ParserShared
{
    private $objects;
    private $enums;
    private $unions;
    private $interfaces;
    private $inputObjects;

    protected function getNameFor($tokenType)
    {
        return Token::getNameFor($tokenType);
    }

    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 maybeParseNullType(Type $type)
    {
        if ($this->accept(Token::T_EXCLAMATION)) {
            return new TypeNonNull($type, $type->getLocation());
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        return $type;
    }

    private function parseType()

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

        if ($this->is(Token::T_NAME)) {
            return $this->maybeParseNullType(
                $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 parseObject()

    {
        $location = $this->expect(Token::T_BRACE_LEFT)->location;
        $fields = array();
        while ($this->scanner->eof() === false) {
            if ($this->accept(Token::T_BRACE_RIGHT)) {
                return new ValueObject($fields, $location);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

        throw $this->getParseError('Unclosed brace of object value');
    }

    private function parseList()

    {
        $location = $this->expect(Token::T_BRACKET_LEFT)->location;
        $items = array();
        while ($this->scanner->eof() === false) {
            if ($this->accept(Token::T_BRACKET_RIGHT)) {
                return new ValueList($items, $location);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

        throw $this->getParseError('Unclosed bracket of list');

    }

    private function parseValue()
    {
        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 parseFieldArguments()
    {
        if ($this->accept(Token::T_PAREN_LEFT) === false) {
            return array();
        }

        $arguments = array();
        while ($this->scanner->eof() === false) {
            if ($this->accept(Token::T_PAREN_RIGHT)) {
                return $arguments;
            }

            $nameToken = $this->expect(Token::T_NAME);
            $this->expect(Token::T_COLON);
            $type = $this->parseType();
            $defaultValue = null;

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

            $arguments[] = new Argument(
                $nameToken->value,
                $type,
                $defaultValue,
                $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 $arguments;
    }

    private function parseField($forInputObject)

    {
        $nameToken = $this->expect(Token::T_NAME);

        $arguments = array();
        if ($forInputObject === false) {
            $arguments = $this->parseFieldArguments();
        }

        $this->expect(Token::T_COLON);
        $type = $this->parseType();

        return new Field(
            $nameToken->value,
            $type,
            $arguments,
            $nameToken->location
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

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

        $interface = null;
        if ($implementsToken = $this->accept(Token::T_NAME)) {
            if ($implementsToken->value !== 'implements') {
                throw $this->getParseError("Expected \"implements\" but instead found \"{$implementsToken->value}\"");
            }
            $interface = $this->expect(Token::T_NAME)->value;
        }

        $this->expect(Token::T_BRACE_LEFT);
        $fields = array();
        while ($this->scanner->eof() === false) {
            if ($this->accept(Token::T_BRACE_RIGHT)) {
                return new DeclarationObject(
                    $name,
                    $fields,
                    $interface,
                    $location
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

            $fields[] = $this->parseField(false);
            $this->accept(Token::T_COMMA);
        }

        throw $this->getParseError('Expected an object field but instead reached end');
    }

    private function parseInputObjectDeclaration()

    {
        $location = $this->expect(Token::T_NAME)->location;
        $name = $this->expect(Token::T_NAME)->value;
        $this->expect(Token::T_BRACE_LEFT);
        $fields = array();
        while ($this->scanner->eof() === false) {
            if ($this->accept(Token::T_BRACE_RIGHT)) {
                return new DeclarationInputObject(
                    $name,
                    $fields,
                    $location
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

            $fields[] = $this->parseField(true);
            $this->accept(Token::T_COMMA);
        }

        throw $this->getParseError('Expected an input object field but instead reached end');
    }

    private function parseEnumDeclaration()

    {
        $location = $this->expect(Token::T_NAME)->location;
        $name = $this->expect(Token::T_NAME)->value;
        $this->expect(Token::T_BRACE_LEFT);
        $values = array();
        while ($this->scanner->eof() === false) {
            if ($this->accept(Token::T_BRACE_RIGHT)) {
                return new DeclarationEnum(
                    $name,
                    $values,
                    $location
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

            $values[] = $this->expect(Token::T_NAME)->value;
            $this->accept(Token::T_COMMA);
        }

        throw $this->getParseError('Expected an enumeration value but instead reached end');
    }

    private function parseInterfaceDeclaration()

    {
        $location = $this->expect(Token::T_NAME)->location;
        $name = $this->expect(Token::T_NAME)->value;
        $this->expect(Token::T_BRACE_LEFT);
        $fields = array();
        while ($this->scanner->eof() === false) {
            if ($this->accept(Token::T_BRACE_RIGHT)) {
                return new DeclarationInterface(
                    $name,
                    $fields,
                    $location
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

            $fields[] = $this->parseField(false);
            $this->accept(Token::T_COMMA);
        }

        throw $this->getParseError('Expected an interface field but instead reached end');
    }

    private function parseUnionDeclaration()
    {
        $location = $this->expect(Token::T_NAME)->location;
        $name = $this->expect(Token::T_NAME)->value;
        $this->expect(Token::T_EQUAL);
        $members = array();
        while ($this->scanner->eof() === false) {
            if ($this->is(Token::T_NAME) === false) {
                return new DeclarationUnion(
                    $name,
                    $members,
                    $location
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

            $members[] = $this->expect(Token::T_NAME)->value;

            if ($this->accept(Token::T_PIPE) === false) {
                return new DeclarationUnion(
                    $name,
                    $members,
                    $location
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        throw $this->getParseError('Expected an interface field but instead reached end');
    }

    private function parseDeclaration()
    {
        $message = 'Expected a type declaration';

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

        $token = $this->scanner->peek();
        switch ($token->value) {
            case 'type':
                return $this->parseObjectDeclaration();
            case 'input':
                return $this->parseInputObjectDeclaration();
            case 'enum':
                return $this->parseEnumDeclaration();
            case 'interface':
                return $this->parseInterfaceDeclaration();
            case 'union':
                return $this->parseUnionDeclaration();
        }

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

    private function parseSchema()
    {
        $declarations = array();
        while ($this->scanner->eof() === false) {
            $declarations[] = $this->parseDeclaration();
        }

        return new Schema($declarations);
    }

    /**
     * @param string $schema
     *
     * @return Schema
     */
    public function parse($schema)
    {
        $tokens = $this->lexer->lex($schema);
        $scanner = new ScannerGeneric($tokens);
        $this->scanner = new ScannerTokens($scanner);
        $this->objects = array();
        $this->enums = array();
        $this->unions = array();
        $this->interfaces = array();
        $this->inputObjects = array();
        $declaration = $this->parseSchema();

        return $declaration;
    }
}


1		<?php
2
3		namespace HansOtt\GraphQL\Schema;
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		private $objects;
12		private $enums;
13		private $unions;
14		private $interfaces;
15		private $inputObjects;
16
17	3	protected function getNameFor($tokenType)
18		{
19	3	return Token::getNameFor($tokenType);
20		}
21
22	3	private function parseListType()
23		{
24	3	$location = $this->expect(Token::T_BRACKET_LEFT)->location;
25	3	$type = $this->parseType();
26	3	$this->accept(Token::T_BRACKET_RIGHT);
27
28	3	return new TypeList($type, $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\Schema\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...
29		}
30
31	6	private function parseNamedType()
32		{
33	6	$nameToken = $this->expect(Token::T_NAME);
34	6	$type = new TypeNamed($nameToken->value, $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\Schema\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...
35
36	6	return $type;
37		}
38

hansott / graphql-language

Push — master ( b0b79e...9ac4d8 )

Parser::parseValue() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like