ProvidedRequiredArgumentsOnDirectives::getSDLVisitor() - Code Metrics - simPod/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

getSDLVisitor() C
last analyzed 2020-03-20 22:01 UTC

↳ Parent: ProvidedRequiredArgumentsOnDirectives

Complexity

Conditions	15
Paths	20

Size

Total Lines	72
Code Lines	45

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	30
CRAP Score	22.249

Importance

Changes

Metric	Value
eloc	45
dl	0
loc	72
ccs	30
cts	44
cp	0.6818
rs	5.9166
c	0
b	0
f	0
cc	15
nc	20
nop	1
crap	22.249

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace GraphQL\Validator\Rules;

use GraphQL\Error\Error;
use GraphQL\Language\AST\ArgumentNode;
use GraphQL\Language\AST\DirectiveDefinitionNode;
use GraphQL\Language\AST\DirectiveNode;
use GraphQL\Language\AST\NamedTypeNode;
use GraphQL\Language\AST\Node;
use GraphQL\Language\AST\NodeKind;
use GraphQL\Language\AST\NodeList;
use GraphQL\Language\AST\NonNullTypeNode;
use GraphQL\Type\Definition\Directive;
use GraphQL\Type\Definition\FieldArgument;
use GraphQL\Type\Definition\NonNull;
use GraphQL\Utils\Utils;
use GraphQL\Validator\SDLValidationContext;
use function array_filter;
use function is_array;
use function iterator_to_array;

/**
 * Provided required arguments on directives
 *
 * A directive is only valid if all required (non-null without a
 * default value) field arguments have been provided.
 */
class ProvidedRequiredArgumentsOnDirectives extends ValidationRule
{
    protected static function missingDirectiveArgMessage(string $directiveName, string $argName)
    {
        return 'Directive "' . $directiveName . '" argument "' . $argName . '" is required but ont provided.';
    }

    public function getSDLVisitor(SDLValidationContext $context)
    {
        $requiredArgsMap   = [];
        $schema            = $context->getSchema();
        $definedDirectives = $schema

            ? $schema->getDirectives()
            : Directive::getInternalDirectives();

        foreach ($definedDirectives as $directive) {
            $requiredArgsMap[$directive->name] = Utils::keyMap(
                array_filter($directive->args, static function (FieldArgument $arg) : bool {
                    return $arg->getType() instanceof NonNull && ! isset($arg->defaultValue);
                }),
                static function (FieldArgument $arg) : string {
                    return $arg->name;
                }
            );
        }

        $astDefinition = $context->getDocument()->definitions;
        foreach ($astDefinition as $def) {
            if (! ($def instanceof DirectiveDefinitionNode)) {
                continue;
            }

            if (is_array($def->arguments)) {
                $arguments = $def->arguments;
            } elseif ($def->arguments instanceof NodeList) {
                $arguments = iterator_to_array($def->arguments->getIterator());
            } else {
                $arguments = null;
            }

            $requiredArgsMap[$def->name->value] = Utils::keyMap(
                $arguments
                    ? array_filter($arguments, static function (Node $argument) : bool {
                        return $argument instanceof NonNullTypeNode &&
                            (
                                ! isset($argument->defaultValue) ||
                                $argument->defaultValue === null
                            );
                    })
                    : [],
                static function (NamedTypeNode $argument) : string {
                    return $argument->name->value;
                }
            );
        }

        return [
            NodeKind::DIRECTIVE => static function (DirectiveNode $directiveNode) use ($requiredArgsMap, $context) {
                $directiveName = $directiveNode->name->value;
                $requiredArgs  = $requiredArgsMap[$directiveName] ?? null;
                if (! $requiredArgs) {
                    return null;
                }

                $argNodes   = $directiveNode->arguments ?: [];
                $argNodeMap = Utils::keyMap(
                    $argNodes,
                    static function (ArgumentNode $arg) : string {
                        return $arg->name->value;
                    }
                );

                foreach ($requiredArgs as $argName => $arg) {
                    if (isset($argNodeMap[$argName])) {
                        continue;
                    }

                    $context->reportError(
                        new Error(static::missingDirectiveArgMessage($directiveName, $argName), [$directiveNode])
                    );
                }
            },
        ];
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace GraphQL\Validator\Rules;
6
7		use GraphQL\Error\Error;
8		use GraphQL\Language\AST\ArgumentNode;
9		use GraphQL\Language\AST\DirectiveDefinitionNode;
10		use GraphQL\Language\AST\DirectiveNode;
11		use GraphQL\Language\AST\NamedTypeNode;
12		use GraphQL\Language\AST\Node;
13		use GraphQL\Language\AST\NodeKind;
14		use GraphQL\Language\AST\NodeList;
15		use GraphQL\Language\AST\NonNullTypeNode;
16		use GraphQL\Type\Definition\Directive;
17		use GraphQL\Type\Definition\FieldArgument;
18		use GraphQL\Type\Definition\NonNull;
19		use GraphQL\Utils\Utils;
20		use GraphQL\Validator\SDLValidationContext;
21		use function array_filter;
22		use function is_array;
23		use function iterator_to_array;
24
25		/**
26		* Provided required arguments on directives
27		*
28		* A directive is only valid if all required (non-null without a
29		* default value) field arguments have been provided.
30		*/
31		class ProvidedRequiredArgumentsOnDirectives extends ValidationRule
32		{
33		protected static function missingDirectiveArgMessage(string $directiveName, string $argName)
34		{
35		return 'Directive "' . $directiveName . '" argument "' . $argName . '" is required but ont provided.';
36		}
37
38	207	public function getSDLVisitor(SDLValidationContext $context)
39		{
40	207	$requiredArgsMap = [];
41	207	$schema = $context->getSchema();
42	207	$definedDirectives = $schema
		0 ignored issues – show introduced 2019-09-07 11:16 UTC by Report Bug Copy Issue Report `$schema` is of type `GraphQL\Type\Schema`, thus it always evaluated to `true`. Loading history...
43	64	? $schema->getDirectives()
44	207	: Directive::getInternalDirectives();
45
46	207	foreach ($definedDirectives as $directive) {
47	207	$requiredArgsMap[$directive->name] = Utils::keyMap(
48		array_filter($directive->args, static function (FieldArgument $arg) : bool {
49	207	return $arg->getType() instanceof NonNull && ! isset($arg->defaultValue);
50	207	}),
51		static function (FieldArgument $arg) : string {
52	206	return $arg->name;
53	207	}
54		);
55		}
56
57	207	$astDefinition = $context->getDocument()->definitions;
58	207	foreach ($astDefinition as $def) {
59	207	if (! ($def instanceof DirectiveDefinitionNode)) {
60	188	continue;
61		}
62
63	37	if (is_array($def->arguments)) {
64		$arguments = $def->arguments;
65	37	} elseif ($def->arguments instanceof NodeList) {
66	37	$arguments = iterator_to_array($def->arguments->getIterator());
67		} else {
68		$arguments = null;
69		}
70
71	37	$requiredArgsMap[$def->name->value] = Utils::keyMap(
72	37	$arguments
73		? array_filter($arguments, static function (Node $argument) : bool {
74	9	return $argument instanceof NonNullTypeNode &&
75		(
76		! isset($argument->defaultValue) \|\|
77	9	$argument->defaultValue === null
78		);
79	9	})
80	37	: [],
81		static function (NamedTypeNode $argument) : string {
82		return $argument->name->value;
83	37	}
84		);
85		}
86
87		return [
88		NodeKind::DIRECTIVE => static function (DirectiveNode $directiveNode) use ($requiredArgsMap, $context) {
89	17	$directiveName = $directiveNode->name->value;
90	17	$requiredArgs = $requiredArgsMap[$directiveName] ?? null;
91	17	if (! $requiredArgs) {
92	17	return null;
93		}
94
95		$argNodes = $directiveNode->arguments ?: [];
96		$argNodeMap = Utils::keyMap(
97		$argNodes,
98		static function (ArgumentNode $arg) : string {
99		return $arg->name->value;
100		}
101		);
102
103		foreach ($requiredArgs as $argName => $arg) {
104		if (isset($argNodeMap[$argName])) {
105		continue;
106		}
107
108		$context->reportError(
109		new Error(static::missingDirectiveArgMessage($directiveName, $argName), [$directiveNode])
110		);
111		}
112	207	},
113		];
114		}
115		}
116

simPod / graphql-php

GitHub Access Token became invalid

getSDLVisitor() C last analyzed 2020-03-20 22:01 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

getSDLVisitor() C
last analyzed 2020-03-20 22:01 UTC