DirectivesRule::validate() - Code Metrics - Inspection of "WIP: Schema validation" - digiaonline/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#118)

by Christoffer

created 2018-03-16 00:30 UTC

DirectivesRule::validate() B

↳ Parent: DirectivesRule

Complexity

Conditions	6
Paths	6

Size

Total Lines	58
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	58
rs	8.7274
c	0
b	0
f	0
cc	6
eloc	31
nc	6
nop	1

How to fix Long Method

<?php

namespace Digia\GraphQL\SchemaValidator\Rule;

use Digia\GraphQL\Error\ValidationException;
use Digia\GraphQL\Language\Node\DirectiveNode;
use Digia\GraphQL\SchemaValidator\ValidationContext;
use Digia\GraphQL\Type\Definition\Directive;
use function Digia\GraphQL\Type\isInputType;

class DirectivesRule extends AbstractRule
{
    use ValidatesNamesTrait;
    
    /**
     * @inheritdoc
     */
    public function validate(ValidationContext $context): void
    {
        $directives = $context->getSchema()->getDirectives();

        foreach ($directives as $directive) {
            if (!($directive instanceof Directive)) {
                $context->reportError(
                    new ValidationException(
                        \sprintf('Expected directive but got: %s.', $directive->getAstNode())
                    )
                );

                return;
            }

            // Ensure they are named correctly.
            $this->validateName($context, $directive);

            // TODO: Ensure proper locations.

            // Ensure the arguments are valid.
            $argumentNames = [];

            foreach ($directive->getArguments() as $argument) {
                $argumentName = $argument->getName();

                // Ensure they are named correctly.
                $this->validateName($context, $argument);

                // Ensure they are unique per directive.
                if (isset($argumentNames[$argumentName])) {
                    $context->reportError(
                        new ValidationException(
                            \sprintf(
                                'Argument @%s(%s:) can only be defined once.',
                                $directive->getName(),
                                $argumentName
                            ),
                            $this->getAllDirectiveArgumentNodes($directive, $argumentName)
                        )
                    );

                    continue;
                }

                $argumentNames[$argumentName] = true;

                // Ensure the type is an input type.
                if (!isInputType($argument->getType())) {
                    $context->reportError(
                        new ValidationException(
                            \sprintf(
                                'The type of @%s(%s:) must be Input Type but got: %s.',
                                $directive->getName(),
                                $argumentName,
                                (string)$argument->getType()
                            ),
                            $this->getAllDirectiveArgumentNodes($directive, $argumentName)
                        )
                    );
                }
            }
        }
    }

    /**
     * @param Directive $directive
     * @param string    $argumentName
     * @return array
     */
    protected function getAllDirectiveArgumentNodes(Directive $directive, string $argumentName)
    {
        $nodes = [];

        /** @var DirectiveNode $directiveNode */
        $directiveNode = $directive->getAstNode();

        if (null !== $directiveNode) {
            foreach ($directiveNode->getArguments() as $node) {
                if ($node->getNameValue() === $argumentName) {
                    $nodes[] = $node;
                }
            }
        }

        return $nodes;
    }
}


1			<?php
2
3			namespace Digia\GraphQL\SchemaValidator\Rule;
4
5			use Digia\GraphQL\Error\ValidationException;
6			use Digia\GraphQL\Language\Node\DirectiveNode;
7			use Digia\GraphQL\SchemaValidator\ValidationContext;
8			use Digia\GraphQL\Type\Definition\Directive;
9			use function Digia\GraphQL\Type\isInputType;
10
11			class DirectivesRule extends AbstractRule
12			{
13			use ValidatesNamesTrait;
14
15			/**
16			* @inheritdoc
17			*/
18			public function validate(ValidationContext $context): void
19			{
20			$directives = $context->getSchema()->getDirectives();
21
22			foreach ($directives as $directive) {
23			if (!($directive instanceof Directive)) {
24			$context->reportError(
25			new ValidationException(
26			\sprintf('Expected directive but got: %s.', $directive->getAstNode())
27			)
28			);
29
30			return;
31			}
32
33			// Ensure they are named correctly.
34			$this->validateName($context, $directive);
35
36			// TODO: Ensure proper locations.
37
38			// Ensure the arguments are valid.
39			$argumentNames = [];
40
41			foreach ($directive->getArguments() as $argument) {
42			$argumentName = $argument->getName();
43
44			// Ensure they are named correctly.
45			$this->validateName($context, $argument);
46
47			// Ensure they are unique per directive.
48			if (isset($argumentNames[$argumentName])) {
49			$context->reportError(
50			new ValidationException(
51			\sprintf(
52			'Argument @%s(%s:) can only be defined once.',
53			$directive->getName(),
54			$argumentName
55			),
56			$this->getAllDirectiveArgumentNodes($directive, $argumentName)
57			)
58			);
59
60			continue;
61			}
62
63			$argumentNames[$argumentName] = true;
64
65			// Ensure the type is an input type.
66			if (!isInputType($argument->getType())) {
67			$context->reportError(
68			new ValidationException(
69			\sprintf(
70			'The type of @%s(%s:) must be Input Type but got: %s.',
71			$directive->getName(),
72			$argumentName,
73			(string)$argument->getType()
74			),
75			$this->getAllDirectiveArgumentNodes($directive, $argumentName)
76			)
77			);
78			}
79			}
80			}
81			}
82
83			/**
84			* @param Directive $directive
85			* @param string $argumentName
86			* @return array
87			*/
88			protected function getAllDirectiveArgumentNodes(Directive $directive, string $argumentName)
89			{
90			$nodes = [];
91
92			/** @var DirectiveNode $directiveNode */
93			$directiveNode = $directive->getAstNode();
94
95			if (null !== $directiveNode) {
96			foreach ($directiveNode->getArguments() as $node) {
97			if ($node->getNameValue() === $argumentName) {
98			$nodes[] = $node;
99			}
100			}
101			}
102
103			return $nodes;
104			}
105			}
106

digiaonline / graphql-php

Pull Request — master (#118)

DirectivesRule::validate() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like