SchemaPluginBase - Code Metrics - Inspection of "Preparations for SDL schemas." - drupal-graphql/graphql - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 8.x-3.x (#653)

by Sebastian

created 2018-08-27 11:41 UTC

SchemaPluginBase B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	491
Duplicated Lines	4.89 %

Coupling/Cohesion

Components	4
Dependencies	6

Importance

Changes

Metric	Value
dl	24
loc	491
rs	8.64
c	0
b	0
f	0
wmc	47
lcom	4
cbo	6

28 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	14	1
A	__construct()	0	21	1
A	getSchema()	0	38	3
A	validateSchema()	0	3	1
A	getServer()	0	42	3
A	hasFields()	0	3	1
A	hasMutations()	0	3	1
A	hasSubscriptions()	0	3	1
A	hasType()	0	3	1
A	getFields()	0	12	2
A	getMutations()	0	3	1
A	getSubscriptions()	0	3	1
A	getTypes()	0	5	1
A	getSubTypes()	0	4	2
A	resolveType()	0	18	6
A	getType()	0	15	5
A	processMutations()	0	3	1
A	processSubscriptions()	0	3	1
A	processFields()	0	3	1
A	processArguments()	0	7	1
A	processType()	0	7	1
A	buildType()	0	9	2
A	buildField()	8	8	2
A	buildMutation()	8	8	2
A	buildSubscription()	8	8	2
A	getCacheContexts()	0	3	1
A	getCacheTags()	0	3	1
A	getCacheMaxAge()	0	3	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 SchemaPluginBase 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 SchemaPluginBase, and based on these observations, apply Extract Interface, too.

<?php

namespace Drupal\graphql\Plugin\GraphQL\Schemas;

use Drupal\Component\Plugin\PluginBase;
use Drupal\Core\Cache\CacheableDependencyInterface;
use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
use Drupal\Core\Session\AccountProxyInterface;
use Drupal\graphql\GraphQL\Execution\ResolveContext;
use Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface;
use Drupal\graphql\Plugin\FieldPluginManager;
use Drupal\graphql\Plugin\MutationPluginManager;
use Drupal\graphql\Plugin\SubscriptionPluginManager;
use Drupal\graphql\Plugin\SchemaBuilderInterface;
use Drupal\graphql\Plugin\SchemaPluginInterface;
use Drupal\graphql\Plugin\TypePluginManagerAggregator;
use GraphQL\Language\AST\DocumentNode;
use GraphQL\Server\OperationParams;
use GraphQL\Server\ServerConfig;
use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\ResolveInfo;
use GraphQL\Type\Schema;
use GraphQL\Type\SchemaConfig;
use GraphQL\Validator\DocumentValidator;
use Symfony\Component\DependencyInjection\ContainerInterface;

abstract class SchemaPluginBase extends PluginBase implements SchemaPluginInterface, SchemaBuilderInterface, ContainerFactoryPluginInterface, CacheableDependencyInterface {

  /**
   * The field plugin manager.
   *
   * @var \Drupal\graphql\Plugin\FieldPluginManager
   */
  protected $fieldManager;

  /**
   * The mutation plugin manager.
   *
   * @var \Drupal\graphql\Plugin\MutationPluginManager
   */
  protected $mutationManager;

  /**
   * The subscription plugin manager.
   *
   * @var \Drupal\graphql\Plugin\SubscriptionPluginManager
   */
  protected $subscriptionManager;

  /**
   * The type manager aggregator service.
   *
   * @var \Drupal\graphql\Plugin\TypePluginManagerAggregator
   */
  protected $typeManagers;

  /**
   * Static cache of field definitions.
   *
   * @var array
   */
  protected $fields = [];

  /**
   * Static cache of mutation definitions.
   *
   * @var array
   */
  protected $mutations = [];

  /**
   * Static cache of subscription definitions.
   *
   * @var array
   */
  protected $subscriptions = [];

  /**
   * Static cache of type instances.
   *
   * @var array
   */
  protected $types = [];

  /**
   * The service parameters
   *
   * @var array
   */
  protected $parameters;

  /**
   * The query provider service.
   *
   * @var \Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface
   */
  protected $queryProvider;

  /**
   * The current user.
   *
   * @var \Drupal\Core\Session\AccountProxyInterface
   */
  protected $currentUser;

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
    return new static(
      $configuration,
      $plugin_id,
      $plugin_definition,
      $container->get('plugin.manager.graphql.field'),
      $container->get('plugin.manager.graphql.mutation'),
      $container->get('plugin.manager.graphql.subscription'),
      $container->get('graphql.type_manager_aggregator'),
      $container->get('graphql.query_provider'),
      $container->get('current_user'),
      $container->getParameter('graphql.config')
    );
  }

  /**
   * SchemaPluginBase constructor.
   *
   * @param array $configuration
   *   The plugin configuration array.
   * @param string $pluginId
   *   The plugin id.
   * @param array $pluginDefinition
   *   The plugin definition array.
   * @param \Drupal\graphql\Plugin\FieldPluginManager $fieldManager
   *   The field plugin manager.
   * @param \Drupal\graphql\Plugin\MutationPluginManager $mutationManager
   *   The mutation plugin manager.
   * @param \Drupal\graphql\Plugin\SubscriptionPluginManager $subscriptionManager
   *   The subscription plugin manager.
   * @param \Drupal\graphql\Plugin\TypePluginManagerAggregator $typeManagers
   *   The type manager aggregator service.
   * @param \Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface $queryProvider
   *   The query provider service.
   * @param \Drupal\Core\Session\AccountProxyInterface $currentUser
   *   The current user.
   * @param array $parameters
   */
  public function __construct(
    $configuration,
    $pluginId,
    $pluginDefinition,
    FieldPluginManager $fieldManager,
    MutationPluginManager $mutationManager,
    SubscriptionPluginManager $subscriptionManager,
    TypePluginManagerAggregator $typeManagers,
    QueryProviderInterface $queryProvider,
    AccountProxyInterface $currentUser,
    array $parameters
  ) {
    parent::__construct($configuration, $pluginId, $pluginDefinition);
    $this->fieldManager = $fieldManager;
    $this->mutationManager = $mutationManager;
    $this->subscriptionManager = $subscriptionManager;
    $this->typeManagers = $typeManagers;
    $this->queryProvider = $queryProvider;
    $this->currentUser = $currentUser;
    $this->parameters = $parameters;
  }

  /**
   * {@inheritdoc}
   */
  public function getSchema() {
    $config = new SchemaConfig();

    if ($this->hasMutations()) {
      $config->setMutation(new ObjectType([
        'name' => 'MutationRoot',
        'fields' => function () {
          return $this->getMutations();
        },
      ]));
    }

    if ($this->hasSubscriptions()) {
      $config->setSubscription(new ObjectType([
        'name' => 'SubscriptionRoot',
        'fields' => function () {
          return $this->getSubscriptions();
        },
      ]));
    }

    $config->setQuery(new ObjectType([
      'name' => 'QueryRoot',
      'fields' => function () {
        return $this->getFields('Root');
      },
    ]));

    $config->setTypes(function () {
      return $this->getTypes();
    });

    $config->setTypeLoader(function ($name) {
      return $this->getType($name);
    });

    return new Schema($config);
  }

  /**
   * {@inheritdoc}
   */
  public function validateSchema() {
    return NULL;
  }

  /**
   * {@inheritdoc}
   */
  public function getServer() {
    // If the current user has appropriate permissions, allow to bypass
    // the secure fields restriction.
    $globals['bypass field security'] = $this->currentUser->hasPermission('bypass graphql field security');
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}

    // Create the server config.
    $config = ServerConfig::create();

    // Each document (e.g. in a batch query) gets its own resolve context. This
    // allows us to collect the cache metadata and contextual values (e.g.
    // inheritance for language) for each query separately.
    $config->setContext(function ($params, $document, $operation) use ($globals) {

      // Each document (e.g. in a batch query) gets its own resolve context. This
      // allows us to collect the cache metadata and contextual values (e.g.
      // inheritance for language) for each query separately.
      $context = new ResolveContext($globals);
      $context->addCacheTags(['graphql_response']);
      if ($this instanceof CacheableDependencyInterface) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
        $context->addCacheableDependency($this);
      }

      return $context;
    });

    $config->setValidationRules(function (OperationParams $params, DocumentNode $document, $operation) {

      if (isset($params->queryId)) {
        // Assume that pre-parsed documents are already validated. This allows
        // us to store pre-validated query documents e.g. for persisted queries
        // effectively improving performance by skipping run-time validation.
        return [];
      }

      return array_values(DocumentValidator::defaultRules());
    });

    $config->setPersistentQueryLoader([$this->queryProvider, 'getQuery']);
    $config->setQueryBatching(TRUE);
    $config->setDebug(!!$this->parameters['development']);
    $config->setSchema($this->getSchema());

    return $config;
  }

  /**
  /**
   * {@inheritdoc}
   */
  public function hasFields($type) {
    return isset($this->pluginDefinition['field_association_map'][$type]);
  }

  /**
   * {@inheritdoc}
   */
  public function hasMutations() {
    return !empty($this->pluginDefinition['mutation_map']);
  }

  /**
   * {@inheritdoc}
   */
  public function hasSubscriptions() {
    return !empty($this->pluginDefinition['subscription_map']);
  }

  /**
   * {@inheritdoc}
   */
  public function hasType($name) {
    return isset($this->pluginDefinition['type_map'][$name]);
  }

  /**
   * {@inheritdoc}
   */
  public function getFields($type) {
    $association = $this->pluginDefinition['field_association_map'];
    $fields = $this->pluginDefinition['field_map'];

    if (isset($association[$type])) {
      return $this->processFields(array_map(function ($id) use ($fields) {
        return $fields[$id];
      }, $association[$type]));
    }

    return [];
  }

  /**
   * {@inheritdoc}
   */
  public function getMutations() {
    return $this->processMutations($this->pluginDefinition['mutation_map']);
  }

  /**
   * {@inheritdoc}
   */
  public function getSubscriptions() {
    return $this->processSubscriptions($this->pluginDefinition['subscription_map']);
  }

  /**
   * {@inheritdoc}
   */
  public function getTypes() {
    return array_map(function ($name) {
      return $this->getType($name);
    }, array_keys($this->pluginDefinition['type_map']));
  }

  /**
   * {@inheritdoc}
   */
  public function getSubTypes($name) {
    $association = $this->pluginDefinition['type_association_map'];
    return isset($association[$name]) ? $association[$name] : [];
  }

  /**
   * {@inheritdoc}
   */
  public function resolveType($name, $value, ResolveContext $context, ResolveInfo $info) {
    $association = $this->pluginDefinition['type_association_map'];
    $types = $this->pluginDefinition['type_map'];
    if (!isset($association[$name])) {
      return NULL;
    }

    foreach ($association[$name] as $type) {
      // TODO: Try to avoid loading the type for the check. Consider to make it static!
      if (isset($types[$type]) && $instance = $this->buildType($types[$type])) {
        if ($instance->isTypeOf($value, $context, $info)) {
          return $instance;
        }
      }
    }

    return NULL;
  }

  /**
   * {@inheritdoc}
   */
  public function getType($name) {
    $types = $this->pluginDefinition['type_map'];
    $references = $this->pluginDefinition['type_reference_map'];
    if (isset($types[$name])) {
      return $this->buildType($this->pluginDefinition['type_map'][$name]);
    }

    do {
      if (isset($references[$name])) {
        return $this->buildType($types[$references[$name]]);
      }
    } while (($pos = strpos($name, ':')) !== FALSE && $name = substr($name, 0, $pos));

    throw new \LogicException(sprintf('Missing type %s.', $name));
  }

  /**
   * {@inheritdoc}
   */
  public function processMutations($mutations) {
    return array_map([$this, 'buildMutation'], $mutations);
  }

  /**
   * {@inheritdoc}
   */
  public function processSubscriptions($subscriptions) {
    return array_map([$this, 'buildSubscription'], $subscriptions);
  }

  /**
   * {@inheritdoc}
   */
  public function processFields($fields) {
    return array_map([$this, 'buildField'], $fields);
  }

  /**
   * {@inheritdoc}
   */
  public function processArguments($args) {
    return array_map(function ($arg) {
      return [
        'type' => $this->processType($arg['type']),
      ] + $arg;
    }, $args);
  }

  /**
   * {@inheritdoc}
   */
  public function processType($type) {
    list($type, $decorators) = $type;

    return array_reduce($decorators, function ($type, $decorator) {
      return $decorator($type);
    }, $this->getType($type));
  }

  /**
   * Retrieves the type instance for the given reference.
   *
   * @param array $type
   *   The type reference.
   *
   * @return \GraphQL\Type\Definition\Type
   *   The type instance.
   */
  protected function buildType($type) {
    if (!isset($this->types[$type['id']])) {
      $creator = [$type['class'], 'createInstance'];
      $manager = $this->typeManagers->getTypeManager($type['type']);
      $this->types[$type['id']] = $creator($this, $manager, $type['definition'], $type['id']);
    }

    return $this->types[$type['id']];
  }

  /**
   * Retrieves the field definition for a given field reference.
   *
   * @param array $field
   *   The type reference.
   *
   * @return array
   *   The field definition.
   */
  protected function buildField($field) {

    if (!isset($this->fields[$field['id']])) {
      $creator = [$field['class'], 'createInstance'];
      $this->fields[$field['id']] = $creator($this, $this->fieldManager, $field['definition'], $field['id']);
    }

    return $this->fields[$field['id']];
  }

  /**
   * Retrieves the mutation definition for a given field reference.
   *
   * @param array $mutation
   *   The mutation reference.
   *
   * @return array
   *   The mutation definition.
   */
  protected function buildMutation($mutation) {

    if (!isset($this->mutations[$mutation['id']])) {
      $creator = [$mutation['class'], 'createInstance'];
      $this->mutations[$mutation['id']] = $creator($this, $this->mutationManager, $mutation['definition'], $mutation['id']);
    }

    return $this->mutations[$mutation['id']];
  }

  /**
   * Retrieves the subscription definition for a given field reference.
   *
   * @param array $mutation
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
   *   The subscription reference.
   *
   * @return array
   *   The subscription definition.
   */
  protected function buildSubscription($subscription) {

    if (!isset($this->subscriptions[$subscription['id']])) {
      $creator = [$subscription['class'], 'createInstance'];
      $this->subscriptions[$subscription['id']] = $creator($this, $this->subscriptionManager, $subscription['definition'], $subscription['id']);
    }

    return $this->subscriptions[$subscription['id']];
  }

  /**
   * {@inheritdoc}
   */
  public function getCacheContexts() {
    return [];
  }

  /**
   * {@inheritdoc}
   */
  public function getCacheTags() {
    return $this->pluginDefinition['schema_cache_tags'];
  }

  /**
   * {@inheritdoc}
   */
  public function getCacheMaxAge() {
    return $this->pluginDefinition['schema_cache_max_age'];
  }
}


Pull Request — 8.x-3.x (#653)

SchemaPluginBase B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

28 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

1. Missing dependencies

2. Missing use statement

1		<?php
2
3		namespace Drupal\graphql\Plugin\GraphQL\Schemas;
4
5		use Drupal\Component\Plugin\PluginBase;
6		use Drupal\Core\Cache\CacheableDependencyInterface;
7		use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
8		use Drupal\Core\Session\AccountProxyInterface;
9		use Drupal\graphql\GraphQL\Execution\ResolveContext;
10		use Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface;
11		use Drupal\graphql\Plugin\FieldPluginManager;
12		use Drupal\graphql\Plugin\MutationPluginManager;
13		use Drupal\graphql\Plugin\SubscriptionPluginManager;
14		use Drupal\graphql\Plugin\SchemaBuilderInterface;
15		use Drupal\graphql\Plugin\SchemaPluginInterface;
16		use Drupal\graphql\Plugin\TypePluginManagerAggregator;
17		use GraphQL\Language\AST\DocumentNode;
18		use GraphQL\Server\OperationParams;
19		use GraphQL\Server\ServerConfig;
20		use GraphQL\Type\Definition\ObjectType;
21		use GraphQL\Type\Definition\ResolveInfo;
22		use GraphQL\Type\Schema;
23		use GraphQL\Type\SchemaConfig;
24		use GraphQL\Validator\DocumentValidator;
25		use Symfony\Component\DependencyInjection\ContainerInterface;
26
27		abstract class SchemaPluginBase extends PluginBase implements SchemaPluginInterface, SchemaBuilderInterface, ContainerFactoryPluginInterface, CacheableDependencyInterface {
28
29		/**
30		* The field plugin manager.
31		*
32		* @var \Drupal\graphql\Plugin\FieldPluginManager
33		*/
34		protected $fieldManager;
35
36		/**
37		* The mutation plugin manager.
38		*
39		* @var \Drupal\graphql\Plugin\MutationPluginManager
40		*/
41		protected $mutationManager;
42
43		/**
44		* The subscription plugin manager.
45		*
46		* @var \Drupal\graphql\Plugin\SubscriptionPluginManager
47		*/
48		protected $subscriptionManager;
49
50		/**
51		* The type manager aggregator service.
52		*
53		* @var \Drupal\graphql\Plugin\TypePluginManagerAggregator
54		*/
55		protected $typeManagers;
56
57		/**
58		* Static cache of field definitions.
59		*
60		* @var array
61		*/
62		protected $fields = [];
63
64		/**
65		* Static cache of mutation definitions.
66		*
67		* @var array
68		*/
69		protected $mutations = [];
70
71		/**
72		* Static cache of subscription definitions.
73		*
74		* @var array
75		*/
76		protected $subscriptions = [];
77
78		/**
79		* Static cache of type instances.
80		*
81		* @var array
82		*/
83		protected $types = [];
84
85		/**
86		* The service parameters
87		*
88		* @var array
89		*/
90		protected $parameters;
91
92		/**
93		* The query provider service.
94		*
95		* @var \Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface
96		*/
97		protected $queryProvider;
98
99		/**
100		* The current user.
101		*
102		* @var \Drupal\Core\Session\AccountProxyInterface
103		*/
104		protected $currentUser;
105
106		/**
107		* {@inheritdoc}
108		*/
109		public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
110		return new static(
111		$configuration,
112		$plugin_id,
113		$plugin_definition,
114		$container->get('plugin.manager.graphql.field'),
115		$container->get('plugin.manager.graphql.mutation'),
116		$container->get('plugin.manager.graphql.subscription'),
117		$container->get('graphql.type_manager_aggregator'),
118		$container->get('graphql.query_provider'),
119		$container->get('current_user'),
120		$container->getParameter('graphql.config')
121		);
122		}
123
124		/**
125		* SchemaPluginBase constructor.
126		*
127		* @param array $configuration
128		* The plugin configuration array.
129		* @param string $pluginId
130		* The plugin id.
131		* @param array $pluginDefinition
132		* The plugin definition array.
133		* @param \Drupal\graphql\Plugin\FieldPluginManager $fieldManager
134		* The field plugin manager.
135		* @param \Drupal\graphql\Plugin\MutationPluginManager $mutationManager
136		* The mutation plugin manager.
137		* @param \Drupal\graphql\Plugin\SubscriptionPluginManager $subscriptionManager
138		* The subscription plugin manager.
139		* @param \Drupal\graphql\Plugin\TypePluginManagerAggregator $typeManagers
140		* The type manager aggregator service.
141		* @param \Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface $queryProvider
142		* The query provider service.
143		* @param \Drupal\Core\Session\AccountProxyInterface $currentUser
144		* The current user.
145		* @param array $parameters
146		*/
147		public function __construct(
148		$configuration,
149		$pluginId,
150		$pluginDefinition,
151		FieldPluginManager $fieldManager,
152		MutationPluginManager $mutationManager,
153		SubscriptionPluginManager $subscriptionManager,
154		TypePluginManagerAggregator $typeManagers,
155		QueryProviderInterface $queryProvider,
156		AccountProxyInterface $currentUser,
157		array $parameters
158		) {
159		parent::__construct($configuration, $pluginId, $pluginDefinition);
160		$this->fieldManager = $fieldManager;
161		$this->mutationManager = $mutationManager;
162		$this->subscriptionManager = $subscriptionManager;
163		$this->typeManagers = $typeManagers;
164		$this->queryProvider = $queryProvider;
165		$this->currentUser = $currentUser;
166		$this->parameters = $parameters;
167		}
168
169		/**
170		* {@inheritdoc}
171		*/
172		public function getSchema() {
173		$config = new SchemaConfig();
174
175		if ($this->hasMutations()) {
176		$config->setMutation(new ObjectType([
177		'name' => 'MutationRoot',
178		'fields' => function () {
179		return $this->getMutations();
180		},
181		]));
182		}
183
184		if ($this->hasSubscriptions()) {
185		$config->setSubscription(new ObjectType([
186		'name' => 'SubscriptionRoot',
187		'fields' => function () {
188		return $this->getSubscriptions();
189		},
190		]));
191		}
192
193		$config->setQuery(new ObjectType([
194		'name' => 'QueryRoot',
195		'fields' => function () {
196		return $this->getFields('Root');
197		},
198		]));
199
200		$config->setTypes(function () {
201		return $this->getTypes();
202		});
203
204		$config->setTypeLoader(function ($name) {
205		return $this->getType($name);
206		});
207
208		return new Schema($config);
209		}
210
211		/**
212		* {@inheritdoc}
213		*/
214		public function validateSchema() {
215		return NULL;
216		}
217
218		/**
219		* {@inheritdoc}
220		*/
221		public function getServer() {
222		// If the current user has appropriate permissions, allow to bypass
223		// the secure fields restriction.
224		$globals['bypass field security'] = $this->currentUser->hasPermission('bypass graphql field security');
		0 ignored issues – show Coding Style Comprehensibility introduced 2018-08-27 09:38 UTC by Report Bug Copy Issue Report `$globals` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$globals = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
225
226		// Create the server config.
227		$config = ServerConfig::create();
228
229		// Each document (e.g. in a batch query) gets its own resolve context. This
230		// allows us to collect the cache metadata and contextual values (e.g.
231		// inheritance for language) for each query separately.
232		$config->setContext(function ($params, $document, $operation) use ($globals) {
		0 ignored issues – show Unused Code introduced 2018-08-27 10:14 UTC by Report Bug Copy Issue Report The parameter `$params` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2018-08-27 10:14 UTC by Report Bug Copy Issue Report The parameter `$document` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2018-08-27 10:14 UTC by Report Bug Copy Issue Report The parameter `$operation` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
233		// Each document (e.g. in a batch query) gets its own resolve context. This
234		// allows us to collect the cache metadata and contextual values (e.g.
235		// inheritance for language) for each query separately.
236		$context = new ResolveContext($globals);
237		$context->addCacheTags(['graphql_response']);
238		if ($this instanceof CacheableDependencyInterface) {
		0 ignored issues – show Bug introduced 2017-10-17 14:57 UTC by Report Bug Copy Issue Report The class `Drupal\Core\Cache\CacheableDependencyInterface` does not exist. Did you forget a USE statement, or did you not list all dependencies? This error could be the result of: 1. Missing dependencies PHP Analyzer uses your `composer.json` file (if available) to determine the dependencies of your project and to determine all the available classes and functions. It expects the `composer.json` to be in the root folder of your repository. Are you sure this class is defined by one of your dependencies, or did you maybe not list a dependency in either the `require` or `require-dev` section? 2. Missing use statement PHP does not complain about undefined classes in `ìnstanceof` checks. For example, the following PHP code will work perfectly fine: if ($x instanceof DoesNotExist) { // Do something. } If you have not tested against this specific condition, such errors might go unnoticed. Loading history...
239		$context->addCacheableDependency($this);
240		}
241
242		return $context;
243		});
244
245		$config->setValidationRules(function (OperationParams $params, DocumentNode $document, $operation) {
		0 ignored issues – show Unused Code introduced 2018-02-24 19:21 UTC by Report Bug Copy Issue Report The parameter `$document` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2018-02-24 19:21 UTC by Report Bug Copy Issue Report The parameter `$operation` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
246		if (isset($params->queryId)) {
247		// Assume that pre-parsed documents are already validated. This allows
248		// us to store pre-validated query documents e.g. for persisted queries
249		// effectively improving performance by skipping run-time validation.
250		return [];
251		}
252
253		return array_values(DocumentValidator::defaultRules());
254		});
255
256		$config->setPersistentQueryLoader([$this->queryProvider, 'getQuery']);
257		$config->setQueryBatching(TRUE);
258		$config->setDebug(!!$this->parameters['development']);
259		$config->setSchema($this->getSchema());
260
261		return $config;
262		}
263
264		/**
265		/**
266		* {@inheritdoc}
267		*/
268		public function hasFields($type) {
269		return isset($this->pluginDefinition['field_association_map'][$type]);
270		}
271
272		/**
273		* {@inheritdoc}
274		*/
275		public function hasMutations() {
276		return !empty($this->pluginDefinition['mutation_map']);
277		}
278
279		/**
280		* {@inheritdoc}
281		*/
282		public function hasSubscriptions() {
283		return !empty($this->pluginDefinition['subscription_map']);
284		}
285
286		/**
287		* {@inheritdoc}
288		*/
289		public function hasType($name) {
290		return isset($this->pluginDefinition['type_map'][$name]);
291		}
292
293		/**
294		* {@inheritdoc}
295		*/
296		public function getFields($type) {
297		$association = $this->pluginDefinition['field_association_map'];
298		$fields = $this->pluginDefinition['field_map'];
299
300		if (isset($association[$type])) {
301		return $this->processFields(array_map(function ($id) use ($fields) {
302		return $fields[$id];
303		}, $association[$type]));
304		}
305
306		return [];
307		}
308
309		/**
310		* {@inheritdoc}
311		*/
312		public function getMutations() {
313		return $this->processMutations($this->pluginDefinition['mutation_map']);
314		}
315
316		/**
317		* {@inheritdoc}
318		*/
319		public function getSubscriptions() {
320		return $this->processSubscriptions($this->pluginDefinition['subscription_map']);
321		}
322
323		/**
324		* {@inheritdoc}
325		*/
326		public function getTypes() {
327		return array_map(function ($name) {
328		return $this->getType($name);
329		}, array_keys($this->pluginDefinition['type_map']));
330		}
331
332		/**
333		* {@inheritdoc}
334		*/
335		public function getSubTypes($name) {
336		$association = $this->pluginDefinition['type_association_map'];
337		return isset($association[$name]) ? $association[$name] : [];
338		}
339
340		/**
341		* {@inheritdoc}
342		*/
343		public function resolveType($name, $value, ResolveContext $context, ResolveInfo $info) {
344		$association = $this->pluginDefinition['type_association_map'];
345		$types = $this->pluginDefinition['type_map'];
346		if (!isset($association[$name])) {
347		return NULL;
348		}
349
350		foreach ($association[$name] as $type) {
351		// TODO: Try to avoid loading the type for the check. Consider to make it static!
352		if (isset($types[$type]) && $instance = $this->buildType($types[$type])) {
353		if ($instance->isTypeOf($value, $context, $info)) {
354		return $instance;
355		}
356		}
357		}
358
359		return NULL;
360		}
361
362		/**
363		* {@inheritdoc}
364		*/
365		public function getType($name) {
366		$types = $this->pluginDefinition['type_map'];
367		$references = $this->pluginDefinition['type_reference_map'];
368		if (isset($types[$name])) {
369		return $this->buildType($this->pluginDefinition['type_map'][$name]);
370		}
371
372		do {
373		if (isset($references[$name])) {
374		return $this->buildType($types[$references[$name]]);
375		}
376		} while (($pos = strpos($name, ':')) !== FALSE && $name = substr($name, 0, $pos));
377
378		throw new \LogicException(sprintf('Missing type %s.', $name));
379		}
380
381		/**
382		* {@inheritdoc}
383		*/
384		public function processMutations($mutations) {
385		return array_map([$this, 'buildMutation'], $mutations);
386		}
387
388		/**
389		* {@inheritdoc}
390		*/
391		public function processSubscriptions($subscriptions) {
392		return array_map([$this, 'buildSubscription'], $subscriptions);
393		}
394
395		/**
396		* {@inheritdoc}
397		*/
398		public function processFields($fields) {
399		return array_map([$this, 'buildField'], $fields);
400		}
401
402		/**
403		* {@inheritdoc}
404		*/
405		public function processArguments($args) {
406		return array_map(function ($arg) {
407		return [
408		'type' => $this->processType($arg['type']),
409		] + $arg;
410		}, $args);
411		}
412
413		/**
414		* {@inheritdoc}
415		*/
416		public function processType($type) {
417		list($type, $decorators) = $type;
418
419		return array_reduce($decorators, function ($type, $decorator) {
420		return $decorator($type);
421		}, $this->getType($type));
422		}
423
424		/**
425		* Retrieves the type instance for the given reference.
426		*
427		* @param array $type
428		* The type reference.
429		*
430		* @return \GraphQL\Type\Definition\Type
431		* The type instance.
432		*/
433		protected function buildType($type) {
434		if (!isset($this->types[$type['id']])) {
435		$creator = [$type['class'], 'createInstance'];
436		$manager = $this->typeManagers->getTypeManager($type['type']);
437		$this->types[$type['id']] = $creator($this, $manager, $type['definition'], $type['id']);
438		}
439
440		return $this->types[$type['id']];
441		}
442
443		/**
444		* Retrieves the field definition for a given field reference.
445		*
446		* @param array $field
447		* The type reference.
448		*
449		* @return array
450		* The field definition.
451		*/
452	View Code Duplication	protected function buildField($field) {
		0 ignored issues – show Duplication introduced 2018-02-18 14:32 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...
453		if (!isset($this->fields[$field['id']])) {
454		$creator = [$field['class'], 'createInstance'];
455		$this->fields[$field['id']] = $creator($this, $this->fieldManager, $field['definition'], $field['id']);
456		}
457
458		return $this->fields[$field['id']];
459		}
460
461		/**
462		* Retrieves the mutation definition for a given field reference.
463		*
464		* @param array $mutation
465		* The mutation reference.
466		*
467		* @return array
468		* The mutation definition.
469		*/
470	View Code Duplication	protected function buildMutation($mutation) {
		0 ignored issues – show Duplication introduced 2018-02-18 14:32 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...
471		if (!isset($this->mutations[$mutation['id']])) {
472		$creator = [$mutation['class'], 'createInstance'];
473		$this->mutations[$mutation['id']] = $creator($this, $this->mutationManager, $mutation['definition'], $mutation['id']);
474		}
475
476		return $this->mutations[$mutation['id']];
477		}
478
479		/**
480		* Retrieves the subscription definition for a given field reference.
481		*
482		* @param array $mutation
		0 ignored issues – show Bug introduced 2018-05-21 21:48 UTC by Report Bug Copy Issue Report There is no parameter named `$mutation`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
483		* The subscription reference.
484		*
485		* @return array
486		* The subscription definition.
487		*/
488	View Code Duplication	protected function buildSubscription($subscription) {
		0 ignored issues – show Duplication introduced 2018-05-21 21:48 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...
489		if (!isset($this->subscriptions[$subscription['id']])) {
490		$creator = [$subscription['class'], 'createInstance'];
491		$this->subscriptions[$subscription['id']] = $creator($this, $this->subscriptionManager, $subscription['definition'], $subscription['id']);
492		}
493
494		return $this->subscriptions[$subscription['id']];
495		}
496
497		/**
498		* {@inheritdoc}
499		*/
500		public function getCacheContexts() {
501		return [];
502		}
503
504		/**
505		* {@inheritdoc}
506		*/
507		public function getCacheTags() {
508		return $this->pluginDefinition['schema_cache_tags'];
509		}
510
511		/**
512		* {@inheritdoc}
513		*/
514		public function getCacheMaxAge() {
515		return $this->pluginDefinition['schema_cache_max_age'];
516		}
517		}
518

drupal-graphql / graphql

Pull Request — 8.x-3.x (#653)

SchemaPluginBase B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

28 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

1. Missing dependencies

2. Missing use statement

Duplication Side-by-Side

Filter issues like