NamespaceDefinitionExtension::buildConfig() - Code Metrics - Inspection of "Add support for CollectionType form in mutations" - ynloultratech/graphql-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( e85a2d...ea8174 )

by Rafael

created 2017-12-28 22:45 UTC

NamespaceDefinitionExtension::buildConfig() A

↳ Parent: NamespaceDefinitionExtension

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	4
cts	4
cp	1
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	4
nc	1
nop	1
crap	1

<?php
/*******************************************************************************
 *  This file is part of the GraphQL Bundle package.
 *
 *  (c) YnloUltratech <[email protected]>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 ******************************************************************************/

namespace Ynlo\GraphQLBundle\Definition\Extension;

use Doctrine\Common\Util\Inflector;
use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
use Ynlo\GraphQLBundle\Definition\DefinitionInterface;
use Ynlo\GraphQLBundle\Definition\ExecutableDefinitionInterface;
use Ynlo\GraphQLBundle\Definition\FieldDefinition;
use Ynlo\GraphQLBundle\Definition\FieldsAwareDefinitionInterface;
use Ynlo\GraphQLBundle\Definition\MutationDefinition;
use Ynlo\GraphQLBundle\Definition\NodeAwareDefinitionInterface;
use Ynlo\GraphQLBundle\Definition\ObjectDefinition;
use Ynlo\GraphQLBundle\Definition\ObjectDefinitionInterface;
use Ynlo\GraphQLBundle\Definition\Registry\Endpoint;
use Ynlo\GraphQLBundle\Model\NodeInterface;
use Ynlo\GraphQLBundle\Resolver\EmptyObjectResolver;

/**
 * This extension configure namespace in definitions
 * using definition node and bundle in the node
 */
class NamespaceDefinitionExtension extends AbstractDefinitionExtension
{
    /**
     * @var array
     */
    protected $globalConfig = [];

    /**
     * PaginationDefinitionExtension constructor.
     *
     * @param array $config
     */
    public function __construct($config = [])
    {
        $this->globalConfig = $config;
    }

    /**
     * {@inheritDoc}
     */
    public function buildConfig(ArrayNodeDefinition $root)
    {
        $root
            ->info('Enable/Disable namespace for queries and mutations')
            ->canBeDisabled()
            ->children();
    }

    /**
     * {@inheritdoc}
     */
    public function configure(DefinitionInterface $definition, Endpoint $endpoint, array $config)
    {
        $node = null;
        $nodeClass = null;

        if (!($config['enabled'] ?? true)) {
            return;
        }

        if (($this->globalConfig['nodes']['enabled'] ?? false) && $definition instanceof NodeAwareDefinitionInterface && $definition->getNode()) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $node = $definition->getNode();

            if (class_exists($node)) {
                $nodeClass = $node;
            } else {
                $nodeClass = $endpoint->getClassForType($node);
            }

            if (!is_a($nodeClass, NodeInterface::class, true)) {
                return;
            }

            if (isset($this->globalConfig['nodes']['aliases'][$node])) {
                $node = $this->globalConfig['nodes']['aliases'][$node];
            }

            if ($node && in_array($node, $this->globalConfig['nodes']['ignore'])) {
                $node = null;
            }
        }

        $bundle = null;
        if ($this->globalConfig['bundles']['enabled'] ?? false) {
            if ($node && $nodeClass) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                if ($endpoint->hasType($node) && $nodeClass) {
                    preg_match_all('/\\\\?(\w+Bundle)\\\\/', $nodeClass, $matches);
                    if ($matches) {
                        $bundle = current(array_reverse($matches[1]));
                    }

                    if (isset($this->globalConfig['bundles']['aliases'][$bundle])) {
                        $bundle = $this->globalConfig['bundles']['aliases'][$bundle];
                    }

                    if ($bundle && in_array($bundle, $this->globalConfig['bundles']['ignore'])) {
                        $bundle = null;
                    }

                    if ($bundle) {
                        $bundle = preg_replace('/Bundle$/', null, $bundle);
                    }
                }
            }
        }

        if ($bundle || $node) {
            $definition->setMeta('namespace', ['bundle' => $bundle, 'node' => $node]);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function configureEndpoint(Endpoint $endpoint)
    {
        $groupByBundle = $this->globalConfig['bundles']['enabled'] ?? false;
        $groupByNode = $this->globalConfig['bundles']['enabled'] ?? false;
        if ($groupByBundle || $groupByNode) {
            $endpoint->setQueries($this->namespaceDefinitions($endpoint->allQueries(), $endpoint));
            $endpoint->setMutations($this->namespaceDefinitions($endpoint->allMutations(), $endpoint));
        }
    }

    /**
     * @param array    $definitions
     * @param Endpoint $endpoint
     *
     * @return array
     */
    private function namespaceDefinitions($definitions, Endpoint $endpoint)
    {
        $namespacedDefinitions = [];
        /** @var DefinitionInterface $definition */
        foreach ($definitions as $definition) {
            if (!$definition->hasMeta('namespace') || !$definition->getMeta('namespace')) {
                $namespacedDefinitions[] = $definition;
                continue;
            }

            $root = null;
            $parent = null;
            $namespace = $definition->getMeta('namespace');
            if ($bundle = $namespace['bundle'] ?? null) {
                $bundleQuerySuffix = $this->globalConfig['bundle']['query_suffix'] ?? 'BundleQuery';
                $bundleMutationSuffix = $this->globalConfig['bundle']['mutation_suffix'] ?? 'BundleMutation';

                $name = lcfirst($bundle);
                $typeName = ucfirst($name).(($definition instanceof MutationDefinition) ? $bundleMutationSuffix : $bundleQuerySuffix);
                $root = $this->createRootNamespace(get_class($definition), $name, $typeName, $endpoint);
                $parent = $endpoint->getType($root->getType());
            }

            if ($nodeName = $namespace['node'] ?? null) {
                if ($endpoint->hasTypeForClass($nodeName)) {
                    $nodeName = $endpoint->getTypeForClass($nodeName);
                }

                $name = Inflector::pluralize(lcfirst($nodeName));

                $querySuffix = $this->globalConfig['nodes']['query_suffix'] ?? 'Query';
                $mutationSuffix = $this->globalConfig['nodes']['mutation_suffix'] ?? 'Mutation';

                $typeName = ucfirst($nodeName).(($definition instanceof MutationDefinition) ? $mutationSuffix : $querySuffix);
                if (!$root) {
                    $root = $this->createRootNamespace(get_class($definition), $name, $typeName, $endpoint);
                    $parent = $endpoint->getType($root->getType());
                } elseif ($parent) {
                    $parent = $this->createChildNamespace($parent, $name, $typeName, $endpoint);
                }

                //remove node suffix on namespaced definitions
                $definition->setName(preg_replace(sprintf("/(\w+)%s$/", $nodeName), '$1', $definition->getName()));
                $definition->setName(preg_replace(sprintf("/(\w+)%s$/", Inflector::pluralize($nodeName)), '$1', $definition->getName()));

            }

            if ($root && $parent) {
                $this->addDefinitionToNamespace($parent, $definition);
                $namespacedDefinitions[] = $root;
            }
        }

        return $namespacedDefinitions;
    }

    /**
     * @param FieldsAwareDefinitionInterface $fieldsAwareDefinition
     * @param ExecutableDefinitionInterface  $definition
     */
    private function addDefinitionToNamespace(FieldsAwareDefinitionInterface $fieldsAwareDefinition, ExecutableDefinitionInterface $definition)
    {
        $field = new FieldDefinition();
        $field->setName($definition->getName());
        $field->setType($definition->getType());
        $field->setResolver($definition->getResolver());
        $field->setArguments($definition->getArguments());
        $field->setList($definition->isList());
        $field->setMetas($definition->getMetas());
        $field->setNode($definition->getNode());
        $fieldsAwareDefinition->addField($field);
    }

    /**
     * @param ObjectDefinitionInterface $parent   parent definition to add a child field
     * @param string                    $name     name of the field
     * @param string                    $typeName name of the type to create
     * @param Endpoint                  $endpoint Endpoint instance to extract definitions
     *
     * @return ObjectDefinition
     */
    private function createChildNamespace(ObjectDefinitionInterface $parent, $name, $typeName, Endpoint $endpoint): ObjectDefinition
    {
        $child = new FieldDefinition();
        $child->setName($name);
        $child->setResolver(EmptyObjectResolver::class);

        $type = new ObjectDefinition();
        $type->setName($typeName);
        if ($endpoint->hasType($type->getName())) {
            $type = $endpoint->getType($type->getName());
        } else {
            $endpoint->add($type);
        }

        $child->setType($type->getName());
        $parent->addField($child);

        return $type;

    }

    /**
     * @param string   $rootType Class of the root type to create QueryDefinition or MutationDefinition
     * @param string   $name     name of the root field
     * @param string   $typeName name for the root type
     * @param Endpoint $endpoint Endpoint interface to extract existent definitions
     *
     * @return ExecutableDefinitionInterface
     */
    private function createRootNamespace($rootType, $name, $typeName, Endpoint $endpoint): ExecutableDefinitionInterface
    {
        /** @var ExecutableDefinitionInterface $rootDefinition */
        $rootDefinition = new $rootType();
        $rootDefinition->setName($name);
        $rootDefinition->setResolver(EmptyObjectResolver::class);

        $type = new ObjectDefinition();
        $type->setName($typeName);
        if ($endpoint->hasType($type->getName())) {
            $type = $endpoint->getType($type->getName());
        } else {
            $endpoint->add($type);
        }

        $rootDefinition->setType($type->getName());

        return $rootDefinition;
    }
}


1		<?php
2		/*******************************************************************************
3		* This file is part of the GraphQL Bundle package.
4		*
5		* (c) YnloUltratech <[email protected]>
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		******************************************************************************/
10
11		namespace Ynlo\GraphQLBundle\Definition\Extension;
12
13		use Doctrine\Common\Util\Inflector;
14		use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
15		use Ynlo\GraphQLBundle\Definition\DefinitionInterface;
16		use Ynlo\GraphQLBundle\Definition\ExecutableDefinitionInterface;
17		use Ynlo\GraphQLBundle\Definition\FieldDefinition;
18		use Ynlo\GraphQLBundle\Definition\FieldsAwareDefinitionInterface;
19		use Ynlo\GraphQLBundle\Definition\MutationDefinition;
20		use Ynlo\GraphQLBundle\Definition\NodeAwareDefinitionInterface;
21		use Ynlo\GraphQLBundle\Definition\ObjectDefinition;
22		use Ynlo\GraphQLBundle\Definition\ObjectDefinitionInterface;
23		use Ynlo\GraphQLBundle\Definition\Registry\Endpoint;
24		use Ynlo\GraphQLBundle\Model\NodeInterface;
25		use Ynlo\GraphQLBundle\Resolver\EmptyObjectResolver;
26
27		/**
28		* This extension configure namespace in definitions
29		* using definition node and bundle in the node
30		*/
31		class NamespaceDefinitionExtension extends AbstractDefinitionExtension
32		{
33		/**
34		* @var array
35		*/
36		protected $globalConfig = [];
37
38		/**
39		* PaginationDefinitionExtension constructor.
40		*
41		* @param array $config
42		*/
43	21	public function __construct($config = [])
44		{
45	21	$this->globalConfig = $config;
46	21	}
47
48		/**
49		* {@inheritDoc}
50		*/
51	21	public function buildConfig(ArrayNodeDefinition $root)
52		{
53		$root
54	21	->info('Enable/Disable namespace for queries and mutations')
55	21	->canBeDisabled()
56	21	->children();
57	21	}
58
59		/**
60		* {@inheritdoc}
61		*/
62	21	public function configure(DefinitionInterface $definition, Endpoint $endpoint, array $config)
63		{
64	21	$node = null;
65	21	$nodeClass = null;
66
67	21	if (!($config['enabled'] ?? true)) {
68		return;
69		}
70
71	21	if (($this->globalConfig['nodes']['enabled'] ?? false) && $definition instanceof NodeAwareDefinitionInterface && $definition->getNode()) {
		0 ignored issues – show Bug Best Practice introduced 2017-12-14 17:33 UTC by Report Bug Copy Issue Report The expression `$definition->getNode()` of type `null\|string` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
72	21	$node = $definition->getNode();
73
74	21	if (class_exists($node)) {
75		$nodeClass = $node;
76		} else {
77	21	$nodeClass = $endpoint->getClassForType($node);
78		}
79
80	21	if (!is_a($nodeClass, NodeInterface::class, true)) {
81		return;
82		}
83
84	21	if (isset($this->globalConfig['nodes']['aliases'][$node])) {
85		$node = $this->globalConfig['nodes']['aliases'][$node];
86		}
87
88	21	if ($node && in_array($node, $this->globalConfig['nodes']['ignore'])) {
89	21	$node = null;
90		}
91		}
92
93	21	$bundle = null;
94	21	if ($this->globalConfig['bundles']['enabled'] ?? false) {
95	21	if ($node && $nodeClass) {
		0 ignored issues – show Bug Best Practice introduced 2017-12-19 20:46 UTC by Report Bug Copy Issue Report The expression `$nodeClass` of type `null\|string` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
96	21	if ($endpoint->hasType($node) && $nodeClass) {
97	21	preg_match_all('/\\\\?(\w+Bundle)\\\\/', $nodeClass, $matches);
98	21	if ($matches) {
99	21	$bundle = current(array_reverse($matches[1]));
100		}
101
102	21	if (isset($this->globalConfig['bundles']['aliases'][$bundle])) {
103		$bundle = $this->globalConfig['bundles']['aliases'][$bundle];
104		}
105
106	21	if ($bundle && in_array($bundle, $this->globalConfig['bundles']['ignore'])) {
107	21	$bundle = null;
108		}
109
110	21	if ($bundle) {
111		$bundle = preg_replace('/Bundle$/', null, $bundle);
112		}
113		}
114		}
115		}
116
117	21	if ($bundle \|\| $node) {
118	21	$definition->setMeta('namespace', ['bundle' => $bundle, 'node' => $node]);
119		}
120	21	}
121
122		/**
123		* {@inheritDoc}
124		*/
125	21	public function configureEndpoint(Endpoint $endpoint)
126		{
127	21	$groupByBundle = $this->globalConfig['bundles']['enabled'] ?? false;
128	21	$groupByNode = $this->globalConfig['bundles']['enabled'] ?? false;
129	21	if ($groupByBundle \|\| $groupByNode) {
130	21	$endpoint->setQueries($this->namespaceDefinitions($endpoint->allQueries(), $endpoint));
131	21	$endpoint->setMutations($this->namespaceDefinitions($endpoint->allMutations(), $endpoint));
132		}
133	21	}
134
135		/**
136		* @param array $definitions
137		* @param Endpoint $endpoint
138		*
139		* @return array
140		*/
141	21	private function namespaceDefinitions($definitions, Endpoint $endpoint)
142		{
143	21	$namespacedDefinitions = [];
144		/** @var DefinitionInterface $definition */
145	21	foreach ($definitions as $definition) {
146	21	if (!$definition->hasMeta('namespace') \|\| !$definition->getMeta('namespace')) {
147	21	$namespacedDefinitions[] = $definition;
148	21	continue;
149		}
150
151	21	$root = null;
152	21	$parent = null;
153	21	$namespace = $definition->getMeta('namespace');
154	21	if ($bundle = $namespace['bundle'] ?? null) {
155		$bundleQuerySuffix = $this->globalConfig['bundle']['query_suffix'] ?? 'BundleQuery';
156		$bundleMutationSuffix = $this->globalConfig['bundle']['mutation_suffix'] ?? 'BundleMutation';
157
158		$name = lcfirst($bundle);
159		$typeName = ucfirst($name).(($definition instanceof MutationDefinition) ? $bundleMutationSuffix : $bundleQuerySuffix);
160		$root = $this->createRootNamespace(get_class($definition), $name, $typeName, $endpoint);
161		$parent = $endpoint->getType($root->getType());
162		}
163
164	21	if ($nodeName = $namespace['node'] ?? null) {
165	21	if ($endpoint->hasTypeForClass($nodeName)) {
166		$nodeName = $endpoint->getTypeForClass($nodeName);
167		}
168
169	21	$name = Inflector::pluralize(lcfirst($nodeName));
170
171	21	$querySuffix = $this->globalConfig['nodes']['query_suffix'] ?? 'Query';
172	21	$mutationSuffix = $this->globalConfig['nodes']['mutation_suffix'] ?? 'Mutation';
173
174	21	$typeName = ucfirst($nodeName).(($definition instanceof MutationDefinition) ? $mutationSuffix : $querySuffix);
175	21	if (!$root) {
176	21	$root = $this->createRootNamespace(get_class($definition), $name, $typeName, $endpoint);
177	21	$parent = $endpoint->getType($root->getType());
178		} elseif ($parent) {
179		$parent = $this->createChildNamespace($parent, $name, $typeName, $endpoint);
180		}
181
182		//remove node suffix on namespaced definitions
183	21	$definition->setName(preg_replace(sprintf("/(\w+)%s$/", $nodeName), '$1', $definition->getName()));
184	21	$definition->setName(preg_replace(sprintf("/(\w+)%s$/", Inflector::pluralize($nodeName)), '$1', $definition->getName()));
185
186		}
187
188	21	if ($root && $parent) {
189	21	$this->addDefinitionToNamespace($parent, $definition);
190	21	$namespacedDefinitions[] = $root;
191		}
192		}
193
194	21	return $namespacedDefinitions;
195		}
196
197		/**
198		* @param FieldsAwareDefinitionInterface $fieldsAwareDefinition
199		* @param ExecutableDefinitionInterface $definition
200		*/
201	21	private function addDefinitionToNamespace(FieldsAwareDefinitionInterface $fieldsAwareDefinition, ExecutableDefinitionInterface $definition)
202		{
203	21	$field = new FieldDefinition();
204	21	$field->setName($definition->getName());
205	21	$field->setType($definition->getType());
206	21	$field->setResolver($definition->getResolver());
207	21	$field->setArguments($definition->getArguments());
208	21	$field->setList($definition->isList());
209	21	$field->setMetas($definition->getMetas());
210	21	$field->setNode($definition->getNode());
211	21	$fieldsAwareDefinition->addField($field);
212	21	}
213
214		/**
215		* @param ObjectDefinitionInterface $parent parent definition to add a child field
216		* @param string $name name of the field
217		* @param string $typeName name of the type to create
218		* @param Endpoint $endpoint Endpoint instance to extract definitions
219		*
220		* @return ObjectDefinition
221		*/
222		private function createChildNamespace(ObjectDefinitionInterface $parent, $name, $typeName, Endpoint $endpoint): ObjectDefinition
223		{
224		$child = new FieldDefinition();
225		$child->setName($name);
226		$child->setResolver(EmptyObjectResolver::class);
227
228		$type = new ObjectDefinition();
229		$type->setName($typeName);
230		if ($endpoint->hasType($type->getName())) {
231		$type = $endpoint->getType($type->getName());
232		} else {
233		$endpoint->add($type);
234		}
235
236		$child->setType($type->getName());
237		$parent->addField($child);
238
239		return $type;
		0 ignored issues – show Bug Best Practice introduced 2017-12-18 16:22 UTC by Report Bug Copy Issue Report The expression `return $type` could return the type `Ynlo\GraphQLBundle\Definition\DefinitionInterface` which includes types incompatible with the type-hinted return `Ynlo\GraphQLBundle\Definition\ObjectDefinition`. Consider adding an additional type-check to rule them out. Loading history...
240		}
241
242		/**
243		* @param string $rootType Class of the root type to create QueryDefinition or MutationDefinition
244		* @param string $name name of the root field
245		* @param string $typeName name for the root type
246		* @param Endpoint $endpoint Endpoint interface to extract existent definitions
247		*
248		* @return ExecutableDefinitionInterface
249		*/
250	21	private function createRootNamespace($rootType, $name, $typeName, Endpoint $endpoint): ExecutableDefinitionInterface
251		{
252		/** @var ExecutableDefinitionInterface $rootDefinition */
253	21	$rootDefinition = new $rootType();
254	21	$rootDefinition->setName($name);
255	21	$rootDefinition->setResolver(EmptyObjectResolver::class);
256
257	21	$type = new ObjectDefinition();
258	21	$type->setName($typeName);
259	21	if ($endpoint->hasType($type->getName())) {
260	21	$type = $endpoint->getType($type->getName());
261		} else {
262	21	$endpoint->add($type);
263		}
264
265	21	$rootDefinition->setType($type->getName());
266
267	21	return $rootDefinition;
268		}
269		}
270

ynloultratech / graphql-bundle

Push — master ( e85a2d...ea8174 )

NamespaceDefinitionExtension::buildConfig() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like