Parser - Code Metrics - hansott/graphql-language - Measure and Improve Code Quality continuously with Scrutinizer

Parser F
last analyzed 2017-12-14 14:18 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	384
Duplicated Lines	35.94 %

Coupling/Cohesion

Components	1
Dependencies	28

Test Coverage

Coverage

88.03%

Importance

Changes

Metric	Value
wmc	61
lcom	1
cbo	28
dl	138
loc	384
ccs	206
cts	234
cp	0.8803
rs	1.3043
c	0
b	0
f	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	getNameFor()	0	4	1
A	parseListType()	0	8	1
A	parseNamedType()	0	7	1
A	maybeParseNullType()	0	8	2
B	parseType()	23	23	4
A	parseObject()	17	17	3
B	parseFieldArguments()	0	33	5
A	parseField()	19	19	2
B	parseObjectDeclaration()	0	31	5
A	parseInputObjectDeclaration()	21	21	3
A	parseEnumDeclaration()	21	21	3
A	parseInterfaceDeclaration()	21	21	3
A	parseList()	16	16	3
C	parseValue()	0	47	11
B	parseUnionDeclaration()	0	30	4
C	parseDeclaration()	0	24	7
A	parseSchema()	0	9	2
A	parse()	0	14	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Parser often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Parser, and based on these observations, apply Extract Interface, too.

<?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->is(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);
                );
            }

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

        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	6	private function parseListType()
23		{
24	6	$location = $this->expect(Token::T_BRACKET_LEFT)->location;
25	6	$type = $this->parseType();
26	6	$this->accept(Token::T_BRACKET_RIGHT);
27
28	6	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	9	private function parseNamedType()
32		{
33	9	$nameToken = $this->expect(Token::T_NAME);
34	9	$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	9	return $type;
37		}
38

hansott / graphql-language

Parser F last analyzed 2017-12-14 14:18 UTC