ValidationContext::getFragmentSpreads() - Code Metrics - Inspection of "WIP: Validation" - digiaonline/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#45)

by Christoffer
created 2018-03-10 09:08 UTC
ValidationContext::getFragmentSpreads() B

↳ Parent: ValidationContext
Complexity

Conditions	6
Paths	2
Size

Total Lines	27
Code Lines	13
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	6
eloc	13
nc	2
nop	1
dl	0
loc	27
rs	8.439
c	0
b	0
f	0
<?php

namespace Digia\GraphQL\Validation;

use Digia\GraphQL\Error\ValidationException;
use Digia\GraphQL\Language\AST\Node\DocumentNode;
use Digia\GraphQL\Language\AST\Node\FieldNode;
use Digia\GraphQL\Language\AST\Node\FragmentDefinitionNode;
use Digia\GraphQL\Language\AST\Node\FragmentSpreadNode;
use Digia\GraphQL\Language\AST\Node\NodeInterface;
use Digia\GraphQL\Language\AST\Node\OperationDefinitionNode;
use Digia\GraphQL\Language\AST\Node\SelectionNodeInterface;
use Digia\GraphQL\Language\AST\Node\SelectionSetNode;
use Digia\GraphQL\Language\AST\Node\VariableDefinitionNode;
use Digia\GraphQL\Language\AST\Node\VariableNode;
use Digia\GraphQL\Language\AST\Visitor\AcceptVisitorTrait;
use Digia\GraphQL\Language\AST\Visitor\TypeInfoVisitor;
use Digia\GraphQL\Language\AST\Visitor\Visitor;
use Digia\GraphQL\Type\Definition\Argument;
use Digia\GraphQL\Type\Definition\Directive;
use Digia\GraphQL\Type\Definition\Field;
use Digia\GraphQL\Type\Definition\TypeInterface;
use Digia\GraphQL\Type\SchemaInterface;
use Digia\GraphQL\Util\TypeInfo;

class ValidationContext
{
    /**
     * @var SchemaInterface
     */
    protected $schema;

    /**
     * @var DocumentNode
     */
    protected $documentNode;

    /**
     * @var TypeInfo
     */
    protected $typeInfo;

    /**
     * @var array|ValidationException[]
     */
    protected $errors = [];

    /**
     * @var array|FragmentDefinitionNode[]
     */
    protected $fragments = [];

    /**
     * @var array
     */
    protected $fragmentSpreads = [];

    /**
     * @var array
     */
    protected $variableUsages = [];

    /**
     * @var array
     */
    protected $recursiveVariableUsages = [];

    /**
     * @var array
     */
    protected $recursivelyReferencedFragment = [];

    /**
     * ValidationContext constructor.
     * @param SchemaInterface $schema
     * @param DocumentNode    $documentNode
     * @param TypeInfo        $typeInfo
     */
    public function __construct(SchemaInterface $schema, DocumentNode $documentNode, TypeInfo $typeInfo)
    {
        $this->schema       = $schema;
        $this->documentNode = $documentNode;
        $this->typeInfo     = $typeInfo;
    }

    /**
     * @param ValidationException $error
     */
    public function reportError(ValidationException $error): void
    {
        $this->errors[] = $error;
    }

    /**
     * @return array|ValidationException[]
     */
    public function getErrors(): array
    {
        return $this->errors;
    }

    /**
     * @return TypeInterface|null
     */
    public function getParentType(): ?TypeInterface
    {
        return $this->typeInfo->getParentType();

    }

    /**
     * @return Field|null
     */
    public function getFieldDefinition(): ?Field
    {
        return $this->typeInfo->getFieldDefinition();
    }

    /**
     * @return SchemaInterface
     */
    public function getSchema(): SchemaInterface
    {
        return $this->schema;
    }

    /**
     * @return Argument|null
     */
    public function getArgument(): ?Argument
    {
        return $this->typeInfo->getArgument();
    }

    /**
     * @return Directive|null
     */
    public function getDirective(): ?Directive
    {
        return $this->typeInfo->getDirective();
    }

    /**
     * @param string $name
     * @return FragmentDefinitionNode|null
     */
    public function getFragment(string $name): ?FragmentDefinitionNode
    {
        if (empty($this->fragments)) {
            $this->fragments = array_reduce($this->documentNode->getDefinitions(), function ($fragments, $definition) {
                if ($definition instanceof FragmentDefinitionNode) {
                    $fragments[$definition->getNameValue()] = $definition;
                }
                return $fragments;
            }, []);
        }

        return $this->fragments[$name] ?? null;
    }

    /**
     * @param SelectionSetNode $selectionSet
     * @return array|FragmentSpreadNode[]
     */
    public function getFragmentSpreads(SelectionSetNode $selectionSet): array
    {
        $spreads = $this->fragmentSpreads[(string)$selectionSet] ?? null;

        if (null === $spreads) {
            $spreads = [];

            $setsToVisit = [$selectionSet];

            while (!empty($setsToVisit)) {
                /** @var SelectionSetNode $set */
                $set = array_pop($setsToVisit);

                /** @var FieldNode $selection */
                foreach ($set->getSelections() as $selection) {
                    if ($selection instanceof FragmentSpreadNode) {
                        $spreads[] = $selection;
                    } elseif ($selection->hasSelectionSet()) {
                        $setsToVisit[] = $selection->getSelectionSet();
                    }
                }
            }

            $this->fragmentSpreads[(string)$selectionSet] = $spreads;
        }

        return $spreads;
    }

    /**
     * @param OperationDefinitionNode $operation
     * @return array
     */
    public function getRecursiveVariableUsages(OperationDefinitionNode $operation): array
    {
        $usages = $this->recursiveVariableUsages[(string)$operation] ?? null;

        if (null === $usages) {
            $usages = $this->getVariableUsages($operation);
            $fragments = $this->getRecursivelyReferencedFragments($operation);

            foreach ($fragments as $fragment) {
                $usages[] = $this->getVariableUsages($fragment);
            }

            $this->recursiveVariableUsages[(string)$operation] = $usages;
        }

        return $usages;
    }

    /**
     * @param OperationDefinitionNode|FragmentDefinitionNode $node
     * @return array
     */
    public function getVariableUsages(NodeInterface $node): array
    {
        $usages = $this->variableUsages[(string)$node] ?? null;

        if (null === $usages) {
            $usages = [];
            $typeInfo = new TypeInfo($this->schema);
            $visitor = new TypeInfoVisitor($typeInfo, new Visitor(
                function (NodeInterface $node) use (&$usages, $typeInfo): ?NodeInterface
                {
                    if ($node instanceof VariableDefinitionNode) {
                        return null;
                    }

                    if ($node instanceof VariableNode) {
                        $usages[] = ['node' => $node, 'type' => $typeInfo->getInputType()];
                    }

                    return $node;
                }
            ));

            $node->accept($visitor);
                   accept($visitor);

            $this->variableUsages[(string)$node] = $usages;
        }

        return $usages;
    }

    /**
     * @param OperationDefinitionNode $operation
     * @return array|FragmentDefinitionNode[]
     */
    public function getRecursivelyReferencedFragments(OperationDefinitionNode $operation): array
    {
        $fragments = $this->recursivelyReferencedFragment[(string)$operation] ?? null;

        if (null === $fragments) {
            $fragments = [];
            $collectedNames = [];
            $nodesToVisit = [$operation->getSelectionSet()];

            while (!empty($nodesToVisit)) {
                $node = array_pop($nodesToVisit);
                $spreads = $this->getFragmentSpreads($node);

                foreach ($spreads as $spread) {
                    $fragmentName = $spread->getNameValue();

                    if (!isset($collectedNames[$fragmentName])) {
                        $collectedNames[$fragmentName] = true;
                        $fragment = $this->getFragment($fragmentName);

                        if (null !== $fragment) {
                            $fragments[] = $fragment;
                            $nodesToVisit[] = $fragment->getSelectionSet();
                        }
                    }
                }
            }

            $this->recursivelyReferencedFragment[(string)$operation] = $fragments;
        }

        return $fragments;
    }
}

digiaonline / graphql-php

Pull Request — master (#45)

ValidationContext::getFragmentSpreads() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
