SpecificKindVisitor - Code Metrics - Inspection of "Schema extension through SDL" - digiaonline/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#272)

by Christoffer

created 2018-08-21 11:59 UTC

SpecificKindVisitor F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	792
Duplicated Lines	0 %

Importance

Changes

Metric	Value
eloc	91
dl	0
loc	792
rs	2
c	0
b	0
f	0
wmc	88

88 Methods

Rating	Name	Size	Complexity
A	leaveNode()	4	1
A	enterNode()	4	1
A	enterUnionTypeDefinition()	3	1
A	leaveNonNullType()	3	1
A	leaveSchemaDefinition()	3	1
A	enterFragmentDefinition()	3	1
A	leaveListValue()	3	1
A	leaveFragmentDefinition()	3	1
A	leaveInputObjectTypeDefinition()	3	1
A	leaveName()	3	1
A	leaveDocument()	3	1
A	enterObjectTypeDefinition()	3	1
A	enterSchemaExtension()	3	1
A	enterListType()	3	1
A	leaveEnumValue()	3	1
A	enterDirectiveDefinition()	3	1
A	leaveSchemaExtension()	3	1
A	enterStringValue()	3	1
A	enterObjectTypeExtension()	3	1
A	enterInputValueDefinition()	3	1
A	leaveScalarTypeDefinition()	3	1
A	leaveBooleanValue()	3	1
A	enterObjectField()	3	1
A	enterInlineFragment()	3	1
A	enterObjectValue()	3	1
A	enterScalarTypeDefinition()	3	1
A	enterBooleanValue()	3	1
A	leaveEnumTypeExtension()	3	1
A	enterOperationDefinition()	3	1
A	enterVariableDefinition()	3	1
A	leaveObjectTypeExtension()	3	1
A	enterField()	3	1
A	enterOperationTypeDefinition()	3	1
A	leaveEnumTypeDefinition()	3	1
A	enterNonNullType()	3	1
A	leaveObjectField()	3	1
A	leaveFieldDefinition()	3	1
A	enterDocument()	3	1
A	leaveOperationTypeDefinition()	3	1
A	enterNamedType()	3	1
A	leaveField()	3	1
A	leaveObjectTypeDefinition()	3	1
A	leaveNamedType()	3	1
A	leaveOperationDefinition()	3	1
A	enterNullValue()	3	1
A	leaveUnionTypeDefinition()	3	1
A	enterDirective()	3	1
A	leaveInputValueDefinition()	3	1
A	leaveInterfaceTypeExtension()	3	1
A	enterListValue()	3	1
A	leaveArgument()	3	1
A	leaveFragmentSpread()	3	1
A	enterEnumValueDefinition()	3	1
A	leaveInlineFragment()	3	1
A	leaveObjectValue()	3	1
A	enterEnumTypeDefinition()	3	1
A	leaveFloatValue()	3	1
A	enterUnionTypeExtension()	3	1
A	enterScalarTypeExtension()	3	1
A	leaveInterfaceTypeDefinition()	3	1
A	leaveVariable()	3	1
A	enterIntValue()	3	1
A	leaveDirective()	3	1
A	leaveEnumValueDefinition()	3	1
A	enterArgument()	3	1
A	leaveSelectionSet()	3	1
A	enterInterfaceTypeExtension()	3	1
A	leaveVariableDefinition()	3	1
A	leaveNullValue()	3	1
A	leaveUnionTypeExtension()	3	1
A	enterFragmentSpread()	3	1
A	enterEnumValue()	3	1
A	enterInputObjectTypeDefinition()	3	1
A	leaveScalarTypeExtension()	3	1
A	leaveDirectiveDefinition()	3	1
A	leaveInputObjectTypeExtension()	3	1
A	enterSchemaDefinition()	3	1
A	enterVariable()	3	1
A	leaveStringValue()	3	1
A	enterFloatValue()	3	1
A	leaveListType()	3	1
A	enterName()	3	1
A	enterInputObjectTypeExtension()	3	1
A	leaveIntValue()	3	1
A	enterInterfaceTypeDefinition()	3	1
A	enterEnumTypeExtension()	3	1
A	enterSelectionSet()	3	1
A	enterFieldDefinition()	3	1

How to fix Complexity

<?php

namespace Digia\GraphQL\Language\Visitor;

use Digia\GraphQL\Language\Node\ArgumentNode;
use Digia\GraphQL\Language\Node\BooleanValueNode;
use Digia\GraphQL\Language\Node\DirectiveDefinitionNode;
use Digia\GraphQL\Language\Node\DirectiveNode;
use Digia\GraphQL\Language\Node\DocumentNode;
use Digia\GraphQL\Language\Node\EnumTypeDefinitionNode;
use Digia\GraphQL\Language\Node\EnumTypeExtensionNode;
use Digia\GraphQL\Language\Node\EnumValueDefinitionNode;
use Digia\GraphQL\Language\Node\EnumValueNode;
use Digia\GraphQL\Language\Node\FieldDefinitionNode;
use Digia\GraphQL\Language\Node\FieldNode;
use Digia\GraphQL\Language\Node\FloatValueNode;
use Digia\GraphQL\Language\Node\FragmentDefinitionNode;
use Digia\GraphQL\Language\Node\FragmentSpreadNode;
use Digia\GraphQL\Language\Node\InlineFragmentNode;
use Digia\GraphQL\Language\Node\InputObjectTypeDefinitionNode;
use Digia\GraphQL\Language\Node\InputObjectTypeExtensionNode;
use Digia\GraphQL\Language\Node\InputValueDefinitionNode;
use Digia\GraphQL\Language\Node\InterfaceTypeDefinitionNode;
use Digia\GraphQL\Language\Node\InterfaceTypeExtensionNode;
use Digia\GraphQL\Language\Node\IntValueNode;
use Digia\GraphQL\Language\Node\ListTypeNode;
use Digia\GraphQL\Language\Node\ListValueNode;
use Digia\GraphQL\Language\Node\NamedTypeNode;
use Digia\GraphQL\Language\Node\NameNode;
use Digia\GraphQL\Language\Node\NodeInterface;
use Digia\GraphQL\Language\Node\NonNullTypeNode;
use Digia\GraphQL\Language\Node\NullValueNode;
use Digia\GraphQL\Language\Node\ObjectFieldNode;
use Digia\GraphQL\Language\Node\ObjectTypeDefinitionNode;
use Digia\GraphQL\Language\Node\ObjectTypeExtensionNode;
use Digia\GraphQL\Language\Node\ObjectValueNode;
use Digia\GraphQL\Language\Node\OperationDefinitionNode;
use Digia\GraphQL\Language\Node\OperationTypeDefinitionNode;
use Digia\GraphQL\Language\Node\ScalarTypeDefinitionNode;
use Digia\GraphQL\Language\Node\ScalarTypeExtensionNode;
use Digia\GraphQL\Language\Node\SchemaDefinitionNode;
use Digia\GraphQL\Language\Node\SchemaExtensionNode;
use Digia\GraphQL\Language\Node\SelectionSetNode;
use Digia\GraphQL\Language\Node\StringValueNode;
use Digia\GraphQL\Language\Node\UnionTypeDefinitionNode;
use Digia\GraphQL\Language\Node\UnionTypeExtensionNode;
use Digia\GraphQL\Language\Node\VariableDefinitionNode;
use Digia\GraphQL\Language\Node\VariableNode;

class SpecificKindVisitor implements VisitorInterface
{
    /**
     * @inheritdoc
     */
    public function enterNode(NodeInterface $node): ?NodeInterface
    {
        $enterMethod = 'enter' . $node->getKind();
        return $this->{$enterMethod}($node);
    }

    /**
     * @inheritdoc
     */
    public function leaveNode(NodeInterface $node): ?NodeInterface
    {
        $leaveMethod = 'leave' . $node->getKind();
        return $this->{$leaveMethod}($node);
    }

    /**
     * @param ArgumentNode $node
     * @return NodeInterface|null
     */
    protected function enterArgument(ArgumentNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ArgumentNode $node
     * @return NodeInterface|null
     */
    protected function leaveArgument(ArgumentNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param BooleanValueNode $node
     * @return NodeInterface|null
     */
    protected function enterBooleanValue(BooleanValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param BooleanValueNode $node
     * @return NodeInterface|null
     */
    protected function leaveBooleanValue(BooleanValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param DirectiveDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterDirectiveDefinition(DirectiveDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param DirectiveDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveDirectiveDefinition(DirectiveDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param DirectiveNode $node
     * @return NodeInterface|null
     */
    protected function enterDirective(DirectiveNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param DirectiveNode $node
     * @return NodeInterface|null
     */
    protected function leaveDirective(DirectiveNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param DocumentNode $node
     * @return NodeInterface|null
     */
    protected function enterDocument(DocumentNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param DocumentNode $node
     * @return NodeInterface|null
     */
    protected function leaveDocument(DocumentNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param EnumTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterEnumTypeDefinition(EnumTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param EnumTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveEnumTypeDefinition(EnumTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param EnumTypeExtensionNode $node
     * @return NodeInterface|null
     */
    protected function enterEnumTypeExtension(EnumTypeExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param EnumTypeExtensionNode $node
     * @return NodeInterface|null
     */
    protected function leaveEnumTypeExtension(EnumTypeExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param EnumValueDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterEnumValueDefinition(EnumValueDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param EnumValueDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveEnumValueDefinition(EnumValueDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param EnumValueNode $node
     * @return NodeInterface|null
     */
    protected function enterEnumValue(EnumValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param EnumValueNode $node
     * @return NodeInterface|null
     */
    protected function leaveEnumValue(EnumValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param FieldDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterFieldDefinition(FieldDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param FieldDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveFieldDefinition(FieldDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param FieldNode $node
     * @return NodeInterface|null
     */
    protected function enterField(FieldNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param FieldNode $node
     * @return NodeInterface|null
     */
    protected function leaveField(FieldNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param FloatValueNode $node
     * @return NodeInterface|null
     */
    protected function enterFloatValue(FloatValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param FloatValueNode $node
     * @return NodeInterface|null
     */
    protected function leaveFloatValue(FloatValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param FragmentDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterFragmentDefinition(FragmentDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param FragmentDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveFragmentDefinition(FragmentDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param FragmentSpreadNode $node
     * @return FragmentSpreadNode|null
     */
    protected function enterFragmentSpread(FragmentSpreadNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param FragmentSpreadNode $node
     * @return NodeInterface|null
     */
    protected function leaveFragmentSpread(FragmentSpreadNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param InlineFragmentNode $node
     * @return NodeInterface|null
     */
    protected function enterInlineFragment(InlineFragmentNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param InlineFragmentNode $node
     * @return NodeInterface|null
     */
    protected function leaveInlineFragment(InlineFragmentNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param InputObjectTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterInputObjectTypeDefinition(InputObjectTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param InputObjectTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveInputObjectTypeDefinition(InputObjectTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param InputObjectTypeExtensionNode $node
     * @return NodeInterface|null
     */
    protected function enterInputObjectTypeExtension(InputObjectTypeExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param InputObjectTypeExtensionNode $node
     * @return NodeInterface|null
     */
    protected function leaveInputObjectTypeExtension(InputObjectTypeExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param InputValueDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterInputValueDefinition(InputValueDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param InputValueDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveInputValueDefinition(InputValueDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param IntValueNode $node
     * @return NodeInterface|null
     */
    protected function enterIntValue(IntValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param IntValueNode $node
     * @return NodeInterface|null
     */
    protected function leaveIntValue(IntValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param InterfaceTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterInterfaceTypeDefinition(InterfaceTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param InterfaceTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveInterfaceTypeDefinition(InterfaceTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param InterfaceTypeExtensionNode $node
     * @return NodeInterface|null
     */
    protected function enterInterfaceTypeExtension(InterfaceTypeExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param InterfaceTypeExtensionNode $node
     * @return NodeInterface|null
     */
    protected function leaveInterfaceTypeExtension(InterfaceTypeExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ListTypeNode $node
     * @return NodeInterface|null
     */
    protected function enterListType(ListTypeNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ListTypeNode $node
     * @return NodeInterface|null
     */
    protected function leaveListType(ListTypeNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ListValueNode $node
     * @return NodeInterface|null
     */
    protected function enterListValue(ListValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ListValueNode $node
     * @return NodeInterface|null
     */
    protected function leaveListValue(ListValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param NamedTypeNode $node
     * @return NodeInterface|null
     */
    protected function enterNamedType(NamedTypeNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param NamedTypeNode $node
     * @return NodeInterface|null
     */
    protected function leaveNamedType(NamedTypeNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param NameNode $node
     * @return NodeInterface|null
     */
    protected function enterName(NameNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param NameNode $node
     * @return NodeInterface|null
     */
    protected function leaveName(NameNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param NonNullTypeNode $node
     * @return NodeInterface|null
     */
    protected function enterNonNullType(NonNullTypeNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param NonNullTypeNode $node
     * @return NodeInterface|null
     */
    protected function leaveNonNullType(NonNullTypeNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param NullValueNode $node
     * @return NodeInterface|null
     */
    protected function enterNullValue(NullValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param NullValueNode $node
     * @return NodeInterface|null
     */
    protected function leaveNullValue(NullValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ObjectFieldNode $node
     * @return NodeInterface|null
     */
    protected function enterObjectField(ObjectFieldNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ObjectFieldNode $node
     * @return NodeInterface|null
     */
    protected function leaveObjectField(ObjectFieldNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ObjectTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterObjectTypeDefinition(ObjectTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ObjectTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveObjectTypeDefinition(ObjectTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ObjectTypeExtensionNode $node
     * @return NodeInterface|null
     */
    protected function enterObjectTypeExtension(ObjectTypeExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ObjectTypeExtensionNode $node
     * @return NodeInterface|null
     */
    protected function leaveObjectTypeExtension(ObjectTypeExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ObjectValueNode $node
     * @return NodeInterface|null
     */
    protected function enterObjectValue(ObjectValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ObjectValueNode $node
     * @return NodeInterface|null
     */
    protected function leaveObjectValue(ObjectValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param OperationDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterOperationDefinition(OperationDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param OperationDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveOperationDefinition(OperationDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param OperationTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterOperationTypeDefinition(OperationTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param OperationTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveOperationTypeDefinition(OperationTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ScalarTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterScalarTypeDefinition(ScalarTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ScalarTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveScalarTypeDefinition(ScalarTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ScalarTypeExtensionNode $node
     * @return NodeInterface|null
     */
    protected function enterScalarTypeExtension(ScalarTypeExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param ScalarTypeExtensionNode $node
     * @return NodeInterface|null
     */
    protected function leaveScalarTypeExtension(ScalarTypeExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param SchemaDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterSchemaDefinition(SchemaDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param SchemaDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveSchemaDefinition(SchemaDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param SchemaExtensionNode $node
     * @return NodeInterface|null
     */
    protected function enterSchemaExtension(SchemaExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param SchemaExtensionNode $node
     * @return NodeInterface|null
     */
    protected function leaveSchemaExtension(SchemaExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param SelectionSetNode $node
     * @return NodeInterface|null
     */
    protected function enterSelectionSet(SelectionSetNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param SelectionSetNode $node
     * @return NodeInterface|null
     */
    protected function leaveSelectionSet(SelectionSetNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param StringValueNode $node
     * @return NodeInterface|null
     */
    protected function enterStringValue(StringValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param StringValueNode $node
     * @return NodeInterface|null
     */
    protected function leaveStringValue(StringValueNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param UnionTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterUnionTypeDefinition(UnionTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param UnionTypeDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveUnionTypeDefinition(UnionTypeDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param UnionTypeExtensionNode $node
     * @return NodeInterface|null
     */
    protected function enterUnionTypeExtension(UnionTypeExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param UnionTypeExtensionNode $node
     * @return NodeInterface|null
     */
    protected function leaveUnionTypeExtension(UnionTypeExtensionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param VariableDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function enterVariableDefinition(VariableDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param VariableDefinitionNode $node
     * @return NodeInterface|null
     */
    protected function leaveVariableDefinition(VariableDefinitionNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param VariableNode $node
     * @return NodeInterface|null
     */
    protected function enterVariable(VariableNode $node): ?NodeInterface
    {
        return $node;
    }

    /**
     * @param VariableNode $node
     * @return NodeInterface|null
     */
    protected function leaveVariable(VariableNode $node): ?NodeInterface
    {
        return $node;
    }
}


1			<?php
2
3			namespace Digia\GraphQL\Language\Visitor;
4
5			use Digia\GraphQL\Language\Node\ArgumentNode;
6			use Digia\GraphQL\Language\Node\BooleanValueNode;
7			use Digia\GraphQL\Language\Node\DirectiveDefinitionNode;
8			use Digia\GraphQL\Language\Node\DirectiveNode;
9			use Digia\GraphQL\Language\Node\DocumentNode;
10			use Digia\GraphQL\Language\Node\EnumTypeDefinitionNode;
11			use Digia\GraphQL\Language\Node\EnumTypeExtensionNode;
12			use Digia\GraphQL\Language\Node\EnumValueDefinitionNode;
13			use Digia\GraphQL\Language\Node\EnumValueNode;
14			use Digia\GraphQL\Language\Node\FieldDefinitionNode;
15			use Digia\GraphQL\Language\Node\FieldNode;
16			use Digia\GraphQL\Language\Node\FloatValueNode;
17			use Digia\GraphQL\Language\Node\FragmentDefinitionNode;
18			use Digia\GraphQL\Language\Node\FragmentSpreadNode;
19			use Digia\GraphQL\Language\Node\InlineFragmentNode;
20			use Digia\GraphQL\Language\Node\InputObjectTypeDefinitionNode;
21			use Digia\GraphQL\Language\Node\InputObjectTypeExtensionNode;
22			use Digia\GraphQL\Language\Node\InputValueDefinitionNode;
23			use Digia\GraphQL\Language\Node\InterfaceTypeDefinitionNode;
24			use Digia\GraphQL\Language\Node\InterfaceTypeExtensionNode;
25			use Digia\GraphQL\Language\Node\IntValueNode;
26			use Digia\GraphQL\Language\Node\ListTypeNode;
27			use Digia\GraphQL\Language\Node\ListValueNode;
28			use Digia\GraphQL\Language\Node\NamedTypeNode;
29			use Digia\GraphQL\Language\Node\NameNode;
30			use Digia\GraphQL\Language\Node\NodeInterface;
31			use Digia\GraphQL\Language\Node\NonNullTypeNode;
32			use Digia\GraphQL\Language\Node\NullValueNode;
33			use Digia\GraphQL\Language\Node\ObjectFieldNode;
34			use Digia\GraphQL\Language\Node\ObjectTypeDefinitionNode;
35			use Digia\GraphQL\Language\Node\ObjectTypeExtensionNode;
36			use Digia\GraphQL\Language\Node\ObjectValueNode;
37			use Digia\GraphQL\Language\Node\OperationDefinitionNode;
38			use Digia\GraphQL\Language\Node\OperationTypeDefinitionNode;
39			use Digia\GraphQL\Language\Node\ScalarTypeDefinitionNode;
40			use Digia\GraphQL\Language\Node\ScalarTypeExtensionNode;
41			use Digia\GraphQL\Language\Node\SchemaDefinitionNode;
42			use Digia\GraphQL\Language\Node\SchemaExtensionNode;
43			use Digia\GraphQL\Language\Node\SelectionSetNode;
44			use Digia\GraphQL\Language\Node\StringValueNode;
45			use Digia\GraphQL\Language\Node\UnionTypeDefinitionNode;
46			use Digia\GraphQL\Language\Node\UnionTypeExtensionNode;
47			use Digia\GraphQL\Language\Node\VariableDefinitionNode;
48			use Digia\GraphQL\Language\Node\VariableNode;
49
50			class SpecificKindVisitor implements VisitorInterface
51			{
52			/**
53			* @inheritdoc
54			*/
55			public function enterNode(NodeInterface $node): ?NodeInterface
56			{
57			$enterMethod = 'enter' . $node->getKind();
58			return $this->{$enterMethod}($node);
59			}
60
61			/**
62			* @inheritdoc
63			*/
64			public function leaveNode(NodeInterface $node): ?NodeInterface
65			{
66			$leaveMethod = 'leave' . $node->getKind();
67			return $this->{$leaveMethod}($node);
68			}
69
70			/**
71			* @param ArgumentNode $node
72			* @return NodeInterface\|null
73			*/
74			protected function enterArgument(ArgumentNode $node): ?NodeInterface
75			{
76			return $node;
77			}
78
79			/**
80			* @param ArgumentNode $node
81			* @return NodeInterface\|null
82			*/
83			protected function leaveArgument(ArgumentNode $node): ?NodeInterface
84			{
85			return $node;
86			}
87
88			/**
89			* @param BooleanValueNode $node
90			* @return NodeInterface\|null
91			*/
92			protected function enterBooleanValue(BooleanValueNode $node): ?NodeInterface
93			{
94			return $node;
95			}
96
97			/**
98			* @param BooleanValueNode $node
99			* @return NodeInterface\|null
100			*/
101			protected function leaveBooleanValue(BooleanValueNode $node): ?NodeInterface
102			{
103			return $node;
104			}
105
106			/**
107			* @param DirectiveDefinitionNode $node
108			* @return NodeInterface\|null
109			*/
110			protected function enterDirectiveDefinition(DirectiveDefinitionNode $node): ?NodeInterface
111			{
112			return $node;
113			}
114
115			/**
116			* @param DirectiveDefinitionNode $node
117			* @return NodeInterface\|null
118			*/
119			protected function leaveDirectiveDefinition(DirectiveDefinitionNode $node): ?NodeInterface
120			{
121			return $node;
122			}
123
124			/**
125			* @param DirectiveNode $node
126			* @return NodeInterface\|null
127			*/
128			protected function enterDirective(DirectiveNode $node): ?NodeInterface
129			{
130			return $node;
131			}
132
133			/**
134			* @param DirectiveNode $node
135			* @return NodeInterface\|null
136			*/
137			protected function leaveDirective(DirectiveNode $node): ?NodeInterface
138			{
139			return $node;
140			}
141
142			/**
143			* @param DocumentNode $node
144			* @return NodeInterface\|null
145			*/
146			protected function enterDocument(DocumentNode $node): ?NodeInterface
147			{
148			return $node;
149			}
150
151			/**
152			* @param DocumentNode $node
153			* @return NodeInterface\|null
154			*/
155			protected function leaveDocument(DocumentNode $node): ?NodeInterface
156			{
157			return $node;
158			}
159
160			/**
161			* @param EnumTypeDefinitionNode $node
162			* @return NodeInterface\|null
163			*/
164			protected function enterEnumTypeDefinition(EnumTypeDefinitionNode $node): ?NodeInterface
165			{
166			return $node;
167			}
168
169			/**
170			* @param EnumTypeDefinitionNode $node
171			* @return NodeInterface\|null
172			*/
173			protected function leaveEnumTypeDefinition(EnumTypeDefinitionNode $node): ?NodeInterface
174			{
175			return $node;
176			}
177
178			/**
179			* @param EnumTypeExtensionNode $node
180			* @return NodeInterface\|null
181			*/
182			protected function enterEnumTypeExtension(EnumTypeExtensionNode $node): ?NodeInterface
183			{
184			return $node;
185			}
186
187			/**
188			* @param EnumTypeExtensionNode $node
189			* @return NodeInterface\|null
190			*/
191			protected function leaveEnumTypeExtension(EnumTypeExtensionNode $node): ?NodeInterface
192			{
193			return $node;
194			}
195
196			/**
197			* @param EnumValueDefinitionNode $node
198			* @return NodeInterface\|null
199			*/
200			protected function enterEnumValueDefinition(EnumValueDefinitionNode $node): ?NodeInterface
201			{
202			return $node;
203			}
204
205			/**
206			* @param EnumValueDefinitionNode $node
207			* @return NodeInterface\|null
208			*/
209			protected function leaveEnumValueDefinition(EnumValueDefinitionNode $node): ?NodeInterface
210			{
211			return $node;
212			}
213
214			/**
215			* @param EnumValueNode $node
216			* @return NodeInterface\|null
217			*/
218			protected function enterEnumValue(EnumValueNode $node): ?NodeInterface
219			{
220			return $node;
221			}
222
223			/**
224			* @param EnumValueNode $node
225			* @return NodeInterface\|null
226			*/
227			protected function leaveEnumValue(EnumValueNode $node): ?NodeInterface
228			{
229			return $node;
230			}
231
232			/**
233			* @param FieldDefinitionNode $node
234			* @return NodeInterface\|null
235			*/
236			protected function enterFieldDefinition(FieldDefinitionNode $node): ?NodeInterface
237			{
238			return $node;
239			}
240
241			/**
242			* @param FieldDefinitionNode $node
243			* @return NodeInterface\|null
244			*/
245			protected function leaveFieldDefinition(FieldDefinitionNode $node): ?NodeInterface
246			{
247			return $node;
248			}
249
250			/**
251			* @param FieldNode $node
252			* @return NodeInterface\|null
253			*/
254			protected function enterField(FieldNode $node): ?NodeInterface
255			{
256			return $node;
257			}
258
259			/**
260			* @param FieldNode $node
261			* @return NodeInterface\|null
262			*/
263			protected function leaveField(FieldNode $node): ?NodeInterface
264			{
265			return $node;
266			}
267
268			/**
269			* @param FloatValueNode $node
270			* @return NodeInterface\|null
271			*/
272			protected function enterFloatValue(FloatValueNode $node): ?NodeInterface
273			{
274			return $node;
275			}
276
277			/**
278			* @param FloatValueNode $node
279			* @return NodeInterface\|null
280			*/
281			protected function leaveFloatValue(FloatValueNode $node): ?NodeInterface
282			{
283			return $node;
284			}
285
286			/**
287			* @param FragmentDefinitionNode $node
288			* @return NodeInterface\|null
289			*/
290			protected function enterFragmentDefinition(FragmentDefinitionNode $node): ?NodeInterface
291			{
292			return $node;
293			}
294
295			/**
296			* @param FragmentDefinitionNode $node
297			* @return NodeInterface\|null
298			*/
299			protected function leaveFragmentDefinition(FragmentDefinitionNode $node): ?NodeInterface
300			{
301			return $node;
302			}
303
304			/**
305			* @param FragmentSpreadNode $node
306			* @return FragmentSpreadNode\|null
307			*/
308			protected function enterFragmentSpread(FragmentSpreadNode $node): ?NodeInterface
309			{
310			return $node;
311			}
312
313			/**
314			* @param FragmentSpreadNode $node
315			* @return NodeInterface\|null
316			*/
317			protected function leaveFragmentSpread(FragmentSpreadNode $node): ?NodeInterface
318			{
319			return $node;
320			}
321
322			/**
323			* @param InlineFragmentNode $node
324			* @return NodeInterface\|null
325			*/
326			protected function enterInlineFragment(InlineFragmentNode $node): ?NodeInterface
327			{
328			return $node;
329			}
330
331			/**
332			* @param InlineFragmentNode $node
333			* @return NodeInterface\|null
334			*/
335			protected function leaveInlineFragment(InlineFragmentNode $node): ?NodeInterface
336			{
337			return $node;
338			}
339
340			/**
341			* @param InputObjectTypeDefinitionNode $node
342			* @return NodeInterface\|null
343			*/
344			protected function enterInputObjectTypeDefinition(InputObjectTypeDefinitionNode $node): ?NodeInterface
345			{
346			return $node;
347			}
348
349			/**
350			* @param InputObjectTypeDefinitionNode $node
351			* @return NodeInterface\|null
352			*/
353			protected function leaveInputObjectTypeDefinition(InputObjectTypeDefinitionNode $node): ?NodeInterface
354			{
355			return $node;
356			}
357
358			/**
359			* @param InputObjectTypeExtensionNode $node
360			* @return NodeInterface\|null
361			*/
362			protected function enterInputObjectTypeExtension(InputObjectTypeExtensionNode $node): ?NodeInterface
363			{
364			return $node;
365			}
366
367			/**
368			* @param InputObjectTypeExtensionNode $node
369			* @return NodeInterface\|null
370			*/
371			protected function leaveInputObjectTypeExtension(InputObjectTypeExtensionNode $node): ?NodeInterface
372			{
373			return $node;
374			}
375
376			/**
377			* @param InputValueDefinitionNode $node
378			* @return NodeInterface\|null
379			*/
380			protected function enterInputValueDefinition(InputValueDefinitionNode $node): ?NodeInterface
381			{
382			return $node;
383			}
384
385			/**
386			* @param InputValueDefinitionNode $node
387			* @return NodeInterface\|null
388			*/
389			protected function leaveInputValueDefinition(InputValueDefinitionNode $node): ?NodeInterface
390			{
391			return $node;
392			}
393
394			/**
395			* @param IntValueNode $node
396			* @return NodeInterface\|null
397			*/
398			protected function enterIntValue(IntValueNode $node): ?NodeInterface
399			{
400			return $node;
401			}
402
403			/**
404			* @param IntValueNode $node
405			* @return NodeInterface\|null
406			*/
407			protected function leaveIntValue(IntValueNode $node): ?NodeInterface
408			{
409			return $node;
410			}
411
412			/**
413			* @param InterfaceTypeDefinitionNode $node
414			* @return NodeInterface\|null
415			*/
416			protected function enterInterfaceTypeDefinition(InterfaceTypeDefinitionNode $node): ?NodeInterface
417			{
418			return $node;
419			}
420
421			/**
422			* @param InterfaceTypeDefinitionNode $node
423			* @return NodeInterface\|null
424			*/
425			protected function leaveInterfaceTypeDefinition(InterfaceTypeDefinitionNode $node): ?NodeInterface
426			{
427			return $node;
428			}
429
430			/**
431			* @param InterfaceTypeExtensionNode $node
432			* @return NodeInterface\|null
433			*/
434			protected function enterInterfaceTypeExtension(InterfaceTypeExtensionNode $node): ?NodeInterface
435			{
436			return $node;
437			}
438
439			/**
440			* @param InterfaceTypeExtensionNode $node
441			* @return NodeInterface\|null
442			*/
443			protected function leaveInterfaceTypeExtension(InterfaceTypeExtensionNode $node): ?NodeInterface
444			{
445			return $node;
446			}
447
448			/**
449			* @param ListTypeNode $node
450			* @return NodeInterface\|null
451			*/
452			protected function enterListType(ListTypeNode $node): ?NodeInterface
453			{
454			return $node;
455			}
456
457			/**
458			* @param ListTypeNode $node
459			* @return NodeInterface\|null
460			*/
461			protected function leaveListType(ListTypeNode $node): ?NodeInterface
462			{
463			return $node;
464			}
465
466			/**
467			* @param ListValueNode $node
468			* @return NodeInterface\|null
469			*/
470			protected function enterListValue(ListValueNode $node): ?NodeInterface
471			{
472			return $node;
473			}
474
475			/**
476			* @param ListValueNode $node
477			* @return NodeInterface\|null
478			*/
479			protected function leaveListValue(ListValueNode $node): ?NodeInterface
480			{
481			return $node;
482			}
483
484			/**
485			* @param NamedTypeNode $node
486			* @return NodeInterface\|null
487			*/
488			protected function enterNamedType(NamedTypeNode $node): ?NodeInterface
489			{
490			return $node;
491			}
492
493			/**
494			* @param NamedTypeNode $node
495			* @return NodeInterface\|null
496			*/
497			protected function leaveNamedType(NamedTypeNode $node): ?NodeInterface
498			{
499			return $node;
500			}
501
502			/**
503			* @param NameNode $node
504			* @return NodeInterface\|null
505			*/
506			protected function enterName(NameNode $node): ?NodeInterface
507			{
508			return $node;
509			}
510
511			/**
512			* @param NameNode $node
513			* @return NodeInterface\|null
514			*/
515			protected function leaveName(NameNode $node): ?NodeInterface
516			{
517			return $node;
518			}
519
520			/**
521			* @param NonNullTypeNode $node
522			* @return NodeInterface\|null
523			*/
524			protected function enterNonNullType(NonNullTypeNode $node): ?NodeInterface
525			{
526			return $node;
527			}
528
529			/**
530			* @param NonNullTypeNode $node
531			* @return NodeInterface\|null
532			*/
533			protected function leaveNonNullType(NonNullTypeNode $node): ?NodeInterface
534			{
535			return $node;
536			}
537
538			/**
539			* @param NullValueNode $node
540			* @return NodeInterface\|null
541			*/
542			protected function enterNullValue(NullValueNode $node): ?NodeInterface
543			{
544			return $node;
545			}
546
547			/**
548			* @param NullValueNode $node
549			* @return NodeInterface\|null
550			*/
551			protected function leaveNullValue(NullValueNode $node): ?NodeInterface
552			{
553			return $node;
554			}
555
556			/**
557			* @param ObjectFieldNode $node
558			* @return NodeInterface\|null
559			*/
560			protected function enterObjectField(ObjectFieldNode $node): ?NodeInterface
561			{
562			return $node;
563			}
564
565			/**
566			* @param ObjectFieldNode $node
567			* @return NodeInterface\|null
568			*/
569			protected function leaveObjectField(ObjectFieldNode $node): ?NodeInterface
570			{
571			return $node;
572			}
573
574			/**
575			* @param ObjectTypeDefinitionNode $node
576			* @return NodeInterface\|null
577			*/
578			protected function enterObjectTypeDefinition(ObjectTypeDefinitionNode $node): ?NodeInterface
579			{
580			return $node;
581			}
582
583			/**
584			* @param ObjectTypeDefinitionNode $node
585			* @return NodeInterface\|null
586			*/
587			protected function leaveObjectTypeDefinition(ObjectTypeDefinitionNode $node): ?NodeInterface
588			{
589			return $node;
590			}
591
592			/**
593			* @param ObjectTypeExtensionNode $node
594			* @return NodeInterface\|null
595			*/
596			protected function enterObjectTypeExtension(ObjectTypeExtensionNode $node): ?NodeInterface
597			{
598			return $node;
599			}
600
601			/**
602			* @param ObjectTypeExtensionNode $node
603			* @return NodeInterface\|null
604			*/
605			protected function leaveObjectTypeExtension(ObjectTypeExtensionNode $node): ?NodeInterface
606			{
607			return $node;
608			}
609
610			/**
611			* @param ObjectValueNode $node
612			* @return NodeInterface\|null
613			*/
614			protected function enterObjectValue(ObjectValueNode $node): ?NodeInterface
615			{
616			return $node;
617			}
618
619			/**
620			* @param ObjectValueNode $node
621			* @return NodeInterface\|null
622			*/
623			protected function leaveObjectValue(ObjectValueNode $node): ?NodeInterface
624			{
625			return $node;
626			}
627
628			/**
629			* @param OperationDefinitionNode $node
630			* @return NodeInterface\|null
631			*/
632			protected function enterOperationDefinition(OperationDefinitionNode $node): ?NodeInterface
633			{
634			return $node;
635			}
636
637			/**
638			* @param OperationDefinitionNode $node
639			* @return NodeInterface\|null
640			*/
641			protected function leaveOperationDefinition(OperationDefinitionNode $node): ?NodeInterface
642			{
643			return $node;
644			}
645
646			/**
647			* @param OperationTypeDefinitionNode $node
648			* @return NodeInterface\|null
649			*/
650			protected function enterOperationTypeDefinition(OperationTypeDefinitionNode $node): ?NodeInterface
651			{
652			return $node;
653			}
654
655			/**
656			* @param OperationTypeDefinitionNode $node
657			* @return NodeInterface\|null
658			*/
659			protected function leaveOperationTypeDefinition(OperationTypeDefinitionNode $node): ?NodeInterface
660			{
661			return $node;
662			}
663
664			/**
665			* @param ScalarTypeDefinitionNode $node
666			* @return NodeInterface\|null
667			*/
668			protected function enterScalarTypeDefinition(ScalarTypeDefinitionNode $node): ?NodeInterface
669			{
670			return $node;
671			}
672
673			/**
674			* @param ScalarTypeDefinitionNode $node
675			* @return NodeInterface\|null
676			*/
677			protected function leaveScalarTypeDefinition(ScalarTypeDefinitionNode $node): ?NodeInterface
678			{
679			return $node;
680			}
681
682			/**
683			* @param ScalarTypeExtensionNode $node
684			* @return NodeInterface\|null
685			*/
686			protected function enterScalarTypeExtension(ScalarTypeExtensionNode $node): ?NodeInterface
687			{
688			return $node;
689			}
690
691			/**
692			* @param ScalarTypeExtensionNode $node
693			* @return NodeInterface\|null
694			*/
695			protected function leaveScalarTypeExtension(ScalarTypeExtensionNode $node): ?NodeInterface
696			{
697			return $node;
698			}
699
700			/**
701			* @param SchemaDefinitionNode $node
702			* @return NodeInterface\|null
703			*/
704			protected function enterSchemaDefinition(SchemaDefinitionNode $node): ?NodeInterface
705			{
706			return $node;
707			}
708
709			/**
710			* @param SchemaDefinitionNode $node
711			* @return NodeInterface\|null
712			*/
713			protected function leaveSchemaDefinition(SchemaDefinitionNode $node): ?NodeInterface
714			{
715			return $node;
716			}
717
718			/**
719			* @param SchemaExtensionNode $node
720			* @return NodeInterface\|null
721			*/
722			protected function enterSchemaExtension(SchemaExtensionNode $node): ?NodeInterface
723			{
724			return $node;
725			}
726
727			/**
728			* @param SchemaExtensionNode $node
729			* @return NodeInterface\|null
730			*/
731			protected function leaveSchemaExtension(SchemaExtensionNode $node): ?NodeInterface
732			{
733			return $node;
734			}
735
736			/**
737			* @param SelectionSetNode $node
738			* @return NodeInterface\|null
739			*/
740			protected function enterSelectionSet(SelectionSetNode $node): ?NodeInterface
741			{
742			return $node;
743			}
744
745			/**
746			* @param SelectionSetNode $node
747			* @return NodeInterface\|null
748			*/
749			protected function leaveSelectionSet(SelectionSetNode $node): ?NodeInterface
750			{
751			return $node;
752			}
753
754			/**
755			* @param StringValueNode $node
756			* @return NodeInterface\|null
757			*/
758			protected function enterStringValue(StringValueNode $node): ?NodeInterface
759			{
760			return $node;
761			}
762
763			/**
764			* @param StringValueNode $node
765			* @return NodeInterface\|null
766			*/
767			protected function leaveStringValue(StringValueNode $node): ?NodeInterface
768			{
769			return $node;
770			}
771
772			/**
773			* @param UnionTypeDefinitionNode $node
774			* @return NodeInterface\|null
775			*/
776			protected function enterUnionTypeDefinition(UnionTypeDefinitionNode $node): ?NodeInterface
777			{
778			return $node;
779			}
780
781			/**
782			* @param UnionTypeDefinitionNode $node
783			* @return NodeInterface\|null
784			*/
785			protected function leaveUnionTypeDefinition(UnionTypeDefinitionNode $node): ?NodeInterface
786			{
787			return $node;
788			}
789
790			/**
791			* @param UnionTypeExtensionNode $node
792			* @return NodeInterface\|null
793			*/
794			protected function enterUnionTypeExtension(UnionTypeExtensionNode $node): ?NodeInterface
795			{
796			return $node;
797			}
798
799			/**
800			* @param UnionTypeExtensionNode $node
801			* @return NodeInterface\|null
802			*/
803			protected function leaveUnionTypeExtension(UnionTypeExtensionNode $node): ?NodeInterface
804			{
805			return $node;
806			}
807
808			/**
809			* @param VariableDefinitionNode $node
810			* @return NodeInterface\|null
811			*/
812			protected function enterVariableDefinition(VariableDefinitionNode $node): ?NodeInterface
813			{
814			return $node;
815			}
816
817			/**
818			* @param VariableDefinitionNode $node
819			* @return NodeInterface\|null
820			*/
821			protected function leaveVariableDefinition(VariableDefinitionNode $node): ?NodeInterface
822			{
823			return $node;
824			}
825
826			/**
827			* @param VariableNode $node
828			* @return NodeInterface\|null
829			*/
830			protected function enterVariable(VariableNode $node): ?NodeInterface
831			{
832			return $node;
833			}
834
835			/**
836			* @param VariableNode $node
837			* @return NodeInterface\|null
838			*/
839			protected function leaveVariable(VariableNode $node): ?NodeInterface
840			{
841			return $node;
842			}
843			}
844

digiaonline / graphql-php

Pull Request — master (#272)

SpecificKindVisitor F

Complexity

Size/Duplication

Importance

88 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like