GraphQLParser - Code Metrics - Inspection of "Graphql schema language configuration" - overblog/GraphQLBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#254)

by Jérémiah

created 2017-11-30 07:52 UTC

GraphQLParser B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	250
Duplicated Lines	12 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes

Metric	Value
wmc	48
lcom	1
cbo	5
dl	30
loc	250
ccs	126
cts	126
cp	1
rs	8.4864
c	0
b	0
f	0

13 Methods

Rating	Name	Duplication	Size	Complexity
B	parse()	0	27	5
B	typeDefinitionToConfig()	0	29	6
A	addTypeFields()	0	16	3
A	addFieldArguments()	0	15	3
A	addInterfaces()	10	10	3
A	addTypes()	10	10	3
A	addValues()	10	10	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	6	2

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\FieldDefinitionNode;
use GraphQL\Language\AST\InputValueDefinitionNode;
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',
    ];

    /**
     * {@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);
        }

        /** @var Node $typeDef */
        foreach ($ast->definitions as $typeDef) {
            $typeConfig = self::$parser->typeDefinitionToConfig($typeDef);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $typesConfig[$typeDef->name->value] = $typeConfig;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

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

        return $typesConfig;
    }

    protected function typeDefinitionToConfig(Node $typeDef)
    {
        switch ($typeDef->kind) {
            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);
                $this->addInterfaces($typeDef, $config);
                $this->addTypes($typeDef, $config);
                $this->addValues($typeDef, $config);

                return [
                    'type' => self::DEFINITION_TYPE_MAPPING[$typeDef->kind],
                    'config' => $config,
                ];

            default:
                throw new InvalidArgumentException(
                    sprintf(
                        '%s definition is not supported right now.',
                        preg_replace('@Definition$@', '', $typeDef->kind)
                    )
                );
        }
    }

    /**
     * @param Node  $typeDef
     * @param array $config
     */
    private function addTypeFields(Node $typeDef, array &$config)
    {
        if (!empty($typeDef->fields)) {
            $fields = [];
            /** @var FieldDefinitionNode|InputValueDefinitionNode $fieldDef */
            foreach ($typeDef->fields as $fieldDef) {

                $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 = [];
            /** @var InputValueDefinitionNode $definition */
            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['arguments'] = $arguments;
        }
    }

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

    {
        if (!empty($typeDef->interfaces)) {
            $interfaces = [];
            foreach ($typeDef->interfaces as $interface) {

                $interfaces[] = $this->astTypeNodeToString($interface);
            }
            $config['interfaces'] = $interfaces;
        }
    }

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

    {
        if (!empty($typeDef->types)) {
            $types = [];
            foreach ($typeDef->types as $type) {

                $types[] = $this->astTypeNodeToString($type);
            }
            $config['types'] = $types;
        }
    }

    /**
     * @param Node  $typeDef
     * @param array $config
     */
    private function addValues(Node $typeDef, array &$config)

    {
        if (!empty($typeDef->values)) {
            $values = [];
            foreach ($typeDef->values as $value) {

                $values[] = ['value' => $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 InputValueDefinitionNode|FieldDefinitionNode $definition
     * @param array                                        $config
     */
    private function addDefaultValue($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)
    {
        $description = trim($description);

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


Scrutinizer GitHub App not installed

Pull Request — master (#254)

GraphQLParser B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

13 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

1			<?php
2
3			namespace Overblog\GraphQLBundle\Config\Parser;
4
5			use GraphQL\Language\AST\FieldDefinitionNode;
6			use GraphQL\Language\AST\InputValueDefinitionNode;
7			use GraphQL\Language\AST\Node;
8			use GraphQL\Language\AST\NodeKind;
9			use GraphQL\Language\AST\TypeNode;
10			use GraphQL\Language\AST\ValueNode;
11			use GraphQL\Language\Parser;
12			use Symfony\Component\Config\Resource\FileResource;
13			use Symfony\Component\DependencyInjection\ContainerBuilder;
14			use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
15
16			class GraphQLParser implements ParserInterface
17			{
18			/** @var self */
19			private static $parser;
20
21			const DEFINITION_TYPE_MAPPING = [
22			NodeKind::OBJECT_TYPE_DEFINITION => 'object',
23			NodeKind::INTERFACE_TYPE_DEFINITION => 'interface',
24			NodeKind::ENUM_TYPE_DEFINITION => 'enum',
25			NodeKind::UNION_TYPE_DEFINITION => 'union',
26			NodeKind::INPUT_OBJECT_TYPE_DEFINITION => 'input-object',
27			];
28
29			/**
30			* {@inheritdoc}
31			*/
32	6		public static function parse(\SplFileInfo $file, ContainerBuilder $container)
33			{
34	6		$container->addResource(new FileResource($file->getRealPath()));
35	6		$content = trim(file_get_contents($file->getPathname()));
36	6		$typesConfig = [];
37
38			// allow empty files
39	6		if (empty($content)) {
40	1		return [];
41			}
42	5		if (!self::$parser) {
43	1		self::$parser = new static();
44			}
45			try {
46	5		$ast = Parser::parse($content);
47	1		} catch (\Exception $e) {
48	1		throw new InvalidArgumentException(sprintf('An error occurred while parsing the file "%s".', $file), $e->getCode(), $e);
49			}
50
51			/** @var Node $typeDef */
52	4		foreach ($ast->definitions as $typeDef) {
53	4		$typeConfig = self::$parser->typeDefinitionToConfig($typeDef);
			0 ignored issues – show Documentation introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report `$typeDef` is of type `object<GraphQL\Language\AST\DefinitionNode>`, but the function expects a `object<GraphQL\Language\AST\Node>`. 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...
54	2		$typesConfig[$typeDef->name->value] = $typeConfig;
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report Accessing `name` on the interface `GraphQL\Language\AST\DefinitionNode` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
55			}
56
57	2		return $typesConfig;
58			}
59
60	4		protected function typeDefinitionToConfig(Node $typeDef)
61			{
62	4		switch ($typeDef->kind) {
63	4		case NodeKind::OBJECT_TYPE_DEFINITION:
64	4		case NodeKind::INTERFACE_TYPE_DEFINITION:
65	4		case NodeKind::INPUT_OBJECT_TYPE_DEFINITION:
66	4		case NodeKind::ENUM_TYPE_DEFINITION:
67	4		case NodeKind::UNION_TYPE_DEFINITION:
68	2		$config = [];
69	2		$this->addTypeFields($typeDef, $config);
70	2		$this->addDescription($typeDef, $config);
71	2		$this->addInterfaces($typeDef, $config);
72	2		$this->addTypes($typeDef, $config);
73	2		$this->addValues($typeDef, $config);
74
75			return [
76	2		'type' => self::DEFINITION_TYPE_MAPPING[$typeDef->kind],
77	2		'config' => $config,
78			];
79
80			default:
81	2		throw new InvalidArgumentException(
82	2		sprintf(
83	2		'%s definition is not supported right now.',
84	2		preg_replace('@Definition$@', '', $typeDef->kind)
85			)
86			);
87			}
88			}
89
90			/**
91			* @param Node $typeDef
92			* @param array $config
93			*/
94	2		private function addTypeFields(Node $typeDef, array &$config)
95			{
96	2		if (!empty($typeDef->fields)) {
97	2		$fields = [];
98			/** @var FieldDefinitionNode\|InputValueDefinitionNode $fieldDef */
99	2		foreach ($typeDef->fields as $fieldDef) {
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report The property `fields` does not seem to exist in `GraphQL\Language\AST\Node`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
100	2		$fieldName = $fieldDef->name->value;
101	2		$fields[$fieldName] = [];
102	2		$this->addType($fieldDef, $fields[$fieldName]);
103	2		$this->addDescription($fieldDef, $fields[$fieldName]);
104	2		$this->addDefaultValue($fieldDef, $fields[$fieldName]);
105	2		$this->addFieldArguments($fieldDef, $fields[$fieldName]);
106			}
107	2		$config['fields'] = $fields;
108			}
109	2		}
110
111			/**
112			* @param Node $fieldDef
113			* @param array $fieldConf
114			*/
115	2		private function addFieldArguments(Node $fieldDef, array &$fieldConf)
116			{
117	2		if (!empty($fieldDef->arguments)) {
118	1		$arguments = [];
119			/** @var InputValueDefinitionNode $definition */
120	1		foreach ($fieldDef->arguments as $definition) {
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report The property `arguments` does not seem to exist in `GraphQL\Language\AST\Node`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
121	1		$name = $definition->name->value;
122	1		$arguments[$name] = [];
123	1		$this->addType($definition, $arguments[$name]);
124	1		$this->addDescription($definition, $arguments[$name]);
125	1		$this->addDefaultValue($definition, $arguments[$name]);
126			}
127	1		$fieldConf['arguments'] = $arguments;
128			}
129	2		}
130
131			/**
132			* @param Node $typeDef
133			* @param array $config
134			*/
135	2	View Code Duplication	private function addInterfaces(Node $typeDef, array &$config)
			0 ignored issues – show Duplication introduced 2017-11-30 08:02 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...
136			{
137	2		if (!empty($typeDef->interfaces)) {
138	2		$interfaces = [];
139	2		foreach ($typeDef->interfaces as $interface) {
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report The property `interfaces` does not seem to exist in `GraphQL\Language\AST\Node`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
140	2		$interfaces[] = $this->astTypeNodeToString($interface);
141			}
142	2		$config['interfaces'] = $interfaces;
143			}
144	2		}
145
146			/**
147			* @param Node $typeDef
148			* @param array $config
149			*/
150	2	View Code Duplication	private function addTypes(Node $typeDef, array &$config)
			0 ignored issues – show Duplication introduced 2017-11-30 08:02 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...
151			{
152	2		if (!empty($typeDef->types)) {
153	2		$types = [];
154	2		foreach ($typeDef->types as $type) {
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report The property `types` does not seem to exist in `GraphQL\Language\AST\Node`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
155	2		$types[] = $this->astTypeNodeToString($type);
156			}
157	2		$config['types'] = $types;
158			}
159	2		}
160
161			/**
162			* @param Node $typeDef
163			* @param array $config
164			*/
165	2	View Code Duplication	private function addValues(Node $typeDef, array &$config)
			0 ignored issues – show Duplication introduced 2017-11-30 08:02 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...
166			{
167	2		if (!empty($typeDef->values)) {
168	1		$values = [];
169	1		foreach ($typeDef->values as $value) {
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report The property `values` does not seem to exist in `GraphQL\Language\AST\Node`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
170	1		$values[] = ['value' => $value->name->value];
171			}
172	1		$config['values'] = $values;
173			}
174	2		}
175
176			/**
177			* @param Node $definition
178			* @param array $config
179			*/
180	2		private function addType(Node $definition, array &$config)
181			{
182	2		if (!empty($definition->type)) {
183	2		$config['type'] = $this->astTypeNodeToString($definition->type);
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report The property `type` does not seem to exist in `GraphQL\Language\AST\Node`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
184			}
185	2		}
186
187			/**
188			* @param Node $definition
189			* @param array $config
190			*/
191	2		private function addDescription(Node $definition, array &$config)
192			{
193			if (
194	2		!empty($definition->description)
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report The property `description` does not seem to exist in `GraphQL\Language\AST\Node`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
195	2		&& $description = $this->cleanAstDescription($definition->description)
196			) {
197	2		$config['description'] = $description;
198			}
199	2		}
200
201			/**
202			* @param InputValueDefinitionNode\|FieldDefinitionNode $definition
203			* @param array $config
204			*/
205	2		private function addDefaultValue($definition, array &$config)
206			{
207	2		if (!empty($definition->defaultValue)) {
208	2		$config['defaultValue'] = $this->astValueNodeToConfig($definition->defaultValue);
209			}
210	2		}
211
212	2		private function astTypeNodeToString(TypeNode $typeNode)
213			{
214	2		$type = '';
215	2		switch ($typeNode->kind) {
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report Accessing `kind` on the interface `GraphQL\Language\AST\TypeNode` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
216	2		case NodeKind::NAMED_TYPE:
217	2		$type = $typeNode->name->value;
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report Accessing `name` on the interface `GraphQL\Language\AST\TypeNode` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
218	2		break;
219
220	2		case NodeKind::NON_NULL_TYPE:
221	2		$type = $this->astTypeNodeToString($typeNode->type).'!';
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report Accessing `type` on the interface `GraphQL\Language\AST\TypeNode` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
222	2		break;
223
224	1		case NodeKind::LIST_TYPE:
225	1		$type = '['.$this->astTypeNodeToString($typeNode->type).']';
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report Accessing `type` on the interface `GraphQL\Language\AST\TypeNode` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
226	1		break;
227			}
228
229	2		return $type;
230			}
231
232	2		private function astValueNodeToConfig(ValueNode $valueNode)
233			{
234	2		$config = null;
235	2		switch ($valueNode->kind) {
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report Accessing `kind` on the interface `GraphQL\Language\AST\ValueNode` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
236	2		case NodeKind::INT:
237	1		case NodeKind::FLOAT:
238	1		case NodeKind::STRING:
239	1		case NodeKind::BOOLEAN:
240	1		case NodeKind::ENUM:
241	2		$config = $valueNode->value;
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report Accessing `value` on the interface `GraphQL\Language\AST\ValueNode` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
242	2		break;
243
244	1		case NodeKind::LST:
245	1		$config = [];
246	1		foreach ($valueNode->values as $node) {
			0 ignored issues – show Bug introduced 2017-11-30 08:02 UTC by Report Bug Copy Issue Report Accessing `values` on the interface `GraphQL\Language\AST\ValueNode` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
247	1		$config[] = $this->astValueNodeToConfig($node);
248			}
249	1		break;
250
251	1		case NodeKind::NULL:
252	1		$config = null;
253	1		break;
254			}
255
256	2		return $config;
257			}
258
259	2		private function cleanAstDescription($description)
260			{
261	2		$description = trim($description);
262
263	2		return empty($description) ? null : $description;
264			}
265			}
266

overblog / GraphQLBundle

Scrutinizer GitHub App not installed

Pull Request — master (#254)

GraphQLParser B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

13 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

Duplication Side-by-Side

Filter issues like