FieldCollector::collectFields() - Code Metrics - Inspection of "Execution strategies" - digiaonline/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#321)

by Christoffer

created 2018-11-09 08:18 UTC

FieldCollector::collectFields() B

↳ Parent: FieldCollector

Complexity

Conditions	9
Paths	9

Size

Total Lines	53
Code Lines	23

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	9
eloc	23
nc	9
nop	4
dl	0
loc	53
rs	8.0555
c	0
b	0
f	0

How to fix Long Method

<?php

namespace Digia\GraphQL\Execution\Strategy;

use Digia\GraphQL\Error\InvalidTypeException;
use Digia\GraphQL\Error\InvariantException;
use Digia\GraphQL\Execution\ExecutionContext;
use Digia\GraphQL\Execution\ExecutionException;
use Digia\GraphQL\Execution\ValuesResolver;
use Digia\GraphQL\Language\Node\FieldNode;
use Digia\GraphQL\Language\Node\FragmentDefinitionNode;
use Digia\GraphQL\Language\Node\FragmentSpreadNode;
use Digia\GraphQL\Language\Node\InlineFragmentNode;
use Digia\GraphQL\Language\Node\NodeInterface;
use Digia\GraphQL\Language\Node\SelectionSetNode;
use Digia\GraphQL\Type\Definition\AbstractTypeInterface;
use Digia\GraphQL\Type\Definition\Directive;
use Digia\GraphQL\Type\Definition\ObjectType;
use Digia\GraphQL\Util\ConversionException;
use Digia\GraphQL\Util\TypeASTConverter;

class FieldCollector
{
    /**
     * @var ExecutionContext
     */
    protected $context;

    /**
     * @var Directive
     */
    protected $skipDirective;

    /**
     * @var Directive
     */
    protected $includeDirective;

    /**
     * @var ValuesResolver
     */
    protected $valuesResolver;

    /**
     * FieldCollector constructor.
     * @param ExecutionContext $context
     * @param ValuesResolver   $valuesResolver
     */
    public function __construct(ExecutionContext $context, ValuesResolver $valuesResolver)
    {
        $this->context          = $context;
        $this->skipDirective    = SkipDirective();
        $this->includeDirective = IncludeDirective();
        $this->valuesResolver   = $valuesResolver;
    }

    /**
     * @param ObjectType       $runtimeType
     * @param SelectionSetNode $selectionSet
     * @param array            $fields
     * @param array            $visitedFragmentNames
     * @return array
     * @throws InvalidTypeException
     * @throws ExecutionException
     * @throws InvariantException
     * @throws ConversionException
     */
    public function collectFields(
        ObjectType $runtimeType,
        SelectionSetNode $selectionSet,
        array &$fields,
        array &$visitedFragmentNames
    ): array {
        foreach ($selectionSet->getSelections() as $selection) {
            // Check if this Node should be included first
            if (!$this->shouldIncludeNode($selection)) {
                continue;
            }

            // Collect fields
            if ($selection instanceof FieldNode) {
                $fieldName = $selection->getAliasOrNameValue();

                if (!isset($fields[$fieldName])) {
                    $fields[$fieldName] = [];
                }

                $fields[$fieldName][] = $selection;

                continue;
            }

            if ($selection instanceof InlineFragmentNode) {
                if (!$this->doesFragmentConditionMatch($selection, $runtimeType)) {
                    continue;
                }

                $this->collectFields($runtimeType, $selection->getSelectionSet(), $fields, $visitedFragmentNames);
                $this->collectFields($runtimeType, /** @scrutinizer ignore-type */ $selection->getSelectionSet(), $fields, $visitedFragmentNames);

                continue;
            }

            if ($selection instanceof FragmentSpreadNode) {
                $fragmentName = $selection->getNameValue();

                if (isset($visitedFragmentNames[$fragmentName])) {
                    continue;
                }

                $visitedFragmentNames[$fragmentName] = true;

                $fragment = $this->context->getFragments()[$fragmentName];

                $this->collectFields($runtimeType, $fragment->getSelectionSet(), $fields, $visitedFragmentNames);

                continue;
            }
        }

        return $fields;
    }

    /**
     * @param NodeInterface $node
     * @return bool
     * @throws ExecutionException
     * @throws InvalidTypeException
     * @throws InvariantException
     */
    protected function shouldIncludeNode(NodeInterface $node): bool
    {
        $contextVariables = $this->context->getVariableValues();

        $skip = $this->valuesResolver->coerceDirectiveValues($this->skipDirective, $node, $contextVariables);

        if ($skip && $skip['if'] === true) {
            return false;
        }

        $include = $this->valuesResolver->coerceDirectiveValues($this->includeDirective, $node, $contextVariables);

        if ($include && $include['if'] === false) {
            return false;
        }

        return true;
    }

    /**
     * @param FragmentDefinitionNode|InlineFragmentNode $fragment
     * @param ObjectType                                $type
     * @return bool
     * @throws InvariantException
     * @throws ConversionException
     */
    protected function doesFragmentConditionMatch($fragment, ObjectType $type): bool
    {
        $typeConditionNode = $fragment->getTypeCondition();

        if (null === $typeConditionNode) {
            return true;
        }

        $conditionalType = TypeASTConverter::convert($this->context->getSchema(), $typeConditionNode);

        if ($type === $conditionalType) {

            return true;
        }

        if ($conditionalType instanceof AbstractTypeInterface) {
            return $this->context->getSchema()->isPossibleType($conditionalType, $type);
        }

        return false;
    }
}


digiaonline / graphql-php

Pull Request — master (#321)

FieldCollector::collectFields() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like