GraphQLParser - Code Metrics - Inspection of "Merge branch '0.11'" - overblog/GraphQLBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 921329...8d19ff )

by Jérémiah

created 2018-05-31 09:06 UTC

GraphQLParser C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	287
Duplicated Lines	6.97 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

97.96%

Importance

Changes

Metric	Value
wmc	55
lcom	1
cbo	5
dl	20
loc	287
ccs	144
cts	147
cp	0.9796
rs	6.8
c	0
b	0
f	0

15 Methods

Rating	Name	Duplication	Size	Complexity
C	parse()	0	30	7
A	mustOverrideConfig()	0	4	1
C	typeDefinitionToConfig()	0	43	8
A	throwUnsupportedDefinitionNode()	0	10	1
A	addTypeFields()	0	16	3
A	addFieldArguments()	0	14	3
A	addInterfaces()	10	10	3
A	addTypes()	10	10	3
A	addValues()	0	11	3
A	addType()	0	6	2
A	addDescription()	0	9	3
A	addDefaultValue()	0	6	2
A	astTypeNodeToString()	0	19	4
D	astValueNodeToConfig()	0	26	9
A	cleanAstDescription()	0	9	3

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 GraphQLParser 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 GraphQLParser, and based on these observations, apply Extract Interface, too.

<?php

namespace Overblog\GraphQLBundle\Config\Parser;

use GraphQL\Language\AST\DefinitionNode;
use GraphQL\Language\AST\FieldDefinitionNode;
use GraphQL\Language\AST\InputValueDefinitionNode;
use GraphQL\Language\AST\NameNode;
use GraphQL\Language\AST\Node;
use GraphQL\Language\AST\NodeKind;
use GraphQL\Language\AST\TypeNode;
use GraphQL\Language\AST\ValueNode;
use GraphQL\Language\Parser;
use Symfony\Component\Config\Resource\FileResource;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;

class GraphQLParser implements ParserInterface
{
    /** @var self */
    private static $parser;

    const DEFINITION_TYPE_MAPPING = [
        NodeKind::OBJECT_TYPE_DEFINITION => 'object',
        NodeKind::INTERFACE_TYPE_DEFINITION => 'interface',
        NodeKind::ENUM_TYPE_DEFINITION => 'enum',
        NodeKind::UNION_TYPE_DEFINITION => 'union',
        NodeKind::INPUT_OBJECT_TYPE_DEFINITION => 'input-object',
        NodeKind::SCALAR_TYPE_DEFINITION => 'custom-scalar',
    ];

    /**
     * {@inheritdoc}
     */
    public static function parse(\SplFileInfo $file, ContainerBuilder $container)
    {
        $container->addResource(new FileResource($file->getRealPath()));
        $content = trim(file_get_contents($file->getPathname()));
        $typesConfig = [];

        // allow empty files
        if (empty($content)) {
            return [];
        }
        if (!self::$parser) {
            self::$parser = new static();
        }
        try {
            $ast = Parser::parse($content);
        } catch (\Exception $e) {
            throw new InvalidArgumentException(sprintf('An error occurred while parsing the file "%s".', $file), $e->getCode(), $e);
        }

        foreach ($ast->definitions as $typeDef) {
            if (isset($typeDef->name) && $typeDef->name instanceof NameNode) {
                $typeConfig = self::$parser->typeDefinitionToConfig($typeDef);
                $typesConfig[$typeDef->name->value] = $typeConfig;
            } else {
                self::throwUnsupportedDefinitionNode($typeDef);
            }
        }

        return $typesConfig;
    }

    public static function mustOverrideConfig()
    {
        throw new \RuntimeException('Config entry must be override with ResolverMap to be used.');
    }

    protected function typeDefinitionToConfig(DefinitionNode $typeDef)
    {
        if (isset($typeDef->kind)) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            switch ($typeDef->kind) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                case NodeKind::OBJECT_TYPE_DEFINITION:
                case NodeKind::INTERFACE_TYPE_DEFINITION:
                case NodeKind::INPUT_OBJECT_TYPE_DEFINITION:
                case NodeKind::ENUM_TYPE_DEFINITION:
                case NodeKind::UNION_TYPE_DEFINITION:
                    $config = [];
                    $this->addTypeFields($typeDef, $config);
                    $this->addDescription($typeDef, $config);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    $this->addInterfaces($typeDef, $config);
                    $this->addTypes($typeDef, $config);
                    $this->addValues($typeDef, $config);

                    return [
                        'type' => self::DEFINITION_TYPE_MAPPING[$typeDef->kind],
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                        'config' => $config,
                    ];

                case NodeKind::SCALAR_TYPE_DEFINITION:
                    $mustOverride = [__CLASS__, 'mustOverrideConfig'];
                    $config = [
                        'serialize' => $mustOverride,
                        'parseValue' => $mustOverride,
                        'parseLiteral' => $mustOverride,
                    ];
                    $this->addDescription($typeDef, $config);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

                    return [
                        'type' => self::DEFINITION_TYPE_MAPPING[$typeDef->kind],
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                        'config' => $config,
                    ];
                    break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

                default:
                    self::throwUnsupportedDefinitionNode($typeDef);
            }
        }

        self::throwUnsupportedDefinitionNode($typeDef);
    }

    private static function throwUnsupportedDefinitionNode(DefinitionNode $typeDef)
    {
        $path = explode('\\', get_class($typeDef));
        throw new InvalidArgumentException(
            sprintf(
                '%s definition is not supported right now.',
                preg_replace('@DefinitionNode$@', '', array_pop($path))
            )
        );
    }

    /**
     * @param DefinitionNode $typeDef
     * @param array          $config
     */
    private function addTypeFields(DefinitionNode $typeDef, array &$config)
    {
        if (!empty($typeDef->fields)) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $fields = [];
            /** @var FieldDefinitionNode|InputValueDefinitionNode $fieldDef */
            foreach ($typeDef->fields as $fieldDef) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                $fieldName = $fieldDef->name->value;
                $fields[$fieldName] = [];
                $this->addType($fieldDef, $fields[$fieldName]);
                $this->addDescription($fieldDef, $fields[$fieldName]);
                $this->addDefaultValue($fieldDef, $fields[$fieldName]);
                $this->addFieldArguments($fieldDef, $fields[$fieldName]);
            }
            $config['fields'] = $fields;
        }
    }

    /**
     * @param Node  $fieldDef
     * @param array $fieldConf
     */
    private function addFieldArguments(Node $fieldDef, array &$fieldConf)
    {
        if (!empty($fieldDef->arguments)) {
            $arguments = [];
            foreach ($fieldDef->arguments as $definition) {

                $name = $definition->name->value;
                $arguments[$name] = [];
                $this->addType($definition, $arguments[$name]);
                $this->addDescription($definition, $arguments[$name]);
                $this->addDefaultValue($definition, $arguments[$name]);
            }
            $fieldConf['args'] = $arguments;
        }
    }

    /**
     * @param DefinitionNode $typeDef
     * @param array          $config
     */
    private function addInterfaces(DefinitionNode $typeDef, array &$config)

    {
        if (!empty($typeDef->interfaces)) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $interfaces = [];
            foreach ($typeDef->interfaces as $interface) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                $interfaces[] = $this->astTypeNodeToString($interface);
            }
            $config['interfaces'] = $interfaces;
        }
    }

    /**
     * @param DefinitionNode $typeDef
     * @param array          $config
     */
    private function addTypes(DefinitionNode $typeDef, array &$config)

    {
        if (!empty($typeDef->types)) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $types = [];
            foreach ($typeDef->types as $type) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                $types[] = $this->astTypeNodeToString($type);
            }
            $config['types'] = $types;
        }
    }

    /**
     * @param DefinitionNode $typeDef
     * @param array          $config
     */
    private function addValues(DefinitionNode $typeDef, array &$config)
    {
        if (!empty($typeDef->values)) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $values = [];
            foreach ($typeDef->values as $value) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                $values[$value->name->value] = ['value' => $value->name->value];
                $this->addDescription($value, $values[$value->name->value]);
            }
            $config['values'] = $values;
        }
    }

    /**
     * @param Node  $definition
     * @param array $config
     */
    private function addType(Node $definition, array &$config)
    {
        if (!empty($definition->type)) {
            $config['type'] = $this->astTypeNodeToString($definition->type);

        }
    }

    /**
     * @param Node  $definition
     * @param array $config
     */
    private function addDescription(Node $definition, array &$config)
    {
        if (
            !empty($definition->description)

            && $description = $this->cleanAstDescription($definition->description)
        ) {
            $config['description'] = $description;
        }
    }

    /**
     * @param Node  $definition
     * @param array $config
     */
    private function addDefaultValue(Node $definition, array &$config)
    {
        if (!empty($definition->defaultValue)) {
            $config['defaultValue'] = $this->astValueNodeToConfig($definition->defaultValue);

        }
    }

    private function astTypeNodeToString(TypeNode $typeNode)
    {
        $type = '';
        switch ($typeNode->kind) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            case NodeKind::NAMED_TYPE:
                $type = $typeNode->name->value;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                break;

            case NodeKind::NON_NULL_TYPE:
                $type = $this->astTypeNodeToString($typeNode->type).'!';
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                break;

            case NodeKind::LIST_TYPE:
                $type = '['.$this->astTypeNodeToString($typeNode->type).']';
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                break;
        }

        return $type;
    }

    private function astValueNodeToConfig(ValueNode $valueNode)
    {
        $config = null;
        switch ($valueNode->kind) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            case NodeKind::INT:
            case NodeKind::FLOAT:
            case NodeKind::STRING:
            case NodeKind::BOOLEAN:
            case NodeKind::ENUM:
                $config = $valueNode->value;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                break;

            case NodeKind::LST:
                $config = [];
                foreach ($valueNode->values as $node) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    $config[] = $this->astValueNodeToConfig($node);
                }
                break;

            case NodeKind::NULL:
                $config = null;
                break;
        }

        return $config;
    }

    private function cleanAstDescription($description)
    {
        if (property_exists($description, 'value')) {
            $description = $description->value;
        }
        $description = trim($description);

        return empty($description) ? null : $description;
    }
}


Scrutinizer GitHub App not installed

Push — master ( 921329...8d19ff )

GraphQLParser C

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

15 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1		<?php
2
3		namespace Overblog\GraphQLBundle\Config\Parser;
4
5		use GraphQL\Language\AST\DefinitionNode;
6		use GraphQL\Language\AST\FieldDefinitionNode;
7		use GraphQL\Language\AST\InputValueDefinitionNode;
8		use GraphQL\Language\AST\NameNode;
9		use GraphQL\Language\AST\Node;
10		use GraphQL\Language\AST\NodeKind;
11		use GraphQL\Language\AST\TypeNode;
12		use GraphQL\Language\AST\ValueNode;
13		use GraphQL\Language\Parser;
14		use Symfony\Component\Config\Resource\FileResource;
15		use Symfony\Component\DependencyInjection\ContainerBuilder;
16		use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
17
18		class GraphQLParser implements ParserInterface
19		{
20		/** @var self */
21		private static $parser;
22
23		const DEFINITION_TYPE_MAPPING = [
24		NodeKind::OBJECT_TYPE_DEFINITION => 'object',
25		NodeKind::INTERFACE_TYPE_DEFINITION => 'interface',
26		NodeKind::ENUM_TYPE_DEFINITION => 'enum',
27		NodeKind::UNION_TYPE_DEFINITION => 'union',
28		NodeKind::INPUT_OBJECT_TYPE_DEFINITION => 'input-object',
29		NodeKind::SCALAR_TYPE_DEFINITION => 'custom-scalar',
30		];
31
32		/**
33		* {@inheritdoc}
34		*/
35	5	public static function parse(\SplFileInfo $file, ContainerBuilder $container)
36		{
37	5	$container->addResource(new FileResource($file->getRealPath()));
38	5	$content = trim(file_get_contents($file->getPathname()));
39	5	$typesConfig = [];
40

overblog / GraphQLBundle

Scrutinizer GitHub App not installed

Push — master ( 921329...8d19ff )

GraphQLParser C

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

15 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like