digiaonline / graphql-php

src/Language/Node/ListTypeNode.php

Indentation +3 added lines, -3 removed lines

@@ -18,9 +18,9 @@
     public function toArray(): array
     {
         return [
-          'kind' => $this->kind,
-          'type' => $this->getTypeAsArray(),
-          'loc' => $this->getLocationAsArray(),
+            'kind' => $this->kind,
+            'type' => $this->getTypeAsArray(),
+            'loc' => $this->getLocationAsArray(),
         ];
     }
 }

src/Language/Node/EnumValueDefinitionNode.php

Indentation +5 added lines, -5 removed lines

@@ -20,11 +20,11 @@
     public function toArray(): array
     {
         return [
-          'kind' => $this->kind,
-          'description' => $this->getDescriptionAsArray(),
-          'name' => $this->getNameAsArray(),
-          'directives' => $this->getDirectivesAsArray(),
-          'loc' => $this->getLocationAsArray(),
+            'kind' => $this->kind,
+            'description' => $this->getDescriptionAsArray(),
+            'name' => $this->getNameAsArray(),
+            'directives' => $this->getDirectivesAsArray(),
+            'loc' => $this->getLocationAsArray(),
         ];
     }
 }

src/Language/Node/UnionTypeExtensionNode.php

Indentation +5 added lines, -5 removed lines

@@ -20,11 +20,11 @@
     public function toArray(): array
     {
         return [
-          'kind' => $this->kind,
-          'name' => $this->getNameAsArray(),
-          'directives' => $this->getDirectivesAsArray(),
-          'types' => $this->getTypesAsArray(),
-          'loc' => $this->getLocationAsArray(),
+            'kind' => $this->kind,
+            'name' => $this->getNameAsArray(),
+            'directives' => $this->getDirectivesAsArray(),
+            'types' => $this->getTypesAsArray(),
+            'loc' => $this->getLocationAsArray(),
         ];
     }
 }

src/Language/Node/InputObjectTypeDefinitionNode.php

Indentation +7 added lines, -7 removed lines

@@ -3,7 +3,7 @@ 
 namespace Digia\GraphQL\Language\Node;
 
 class InputObjectTypeDefinitionNode extends AbstractNode implements TypeDefinitionNodeInterface,
-  DirectivesAwareInterface, NameAwareInterface
+    DirectivesAwareInterface, NameAwareInterface
 {
 
     use DescriptionTrait;
@@ -22,12 +22,12 @@ 
     public function toArray(): array
     {
         return [
-          'kind' => $this->kind,
-          'description' => $this->getDescriptionAsArray(),
-          'name' => $this->getNameAsArray(),
-          'directives' => $this->getDirectivesAsArray(),
-          'fields' => $this->getFieldsAsArray(),
-          'loc' => $this->getLocationAsArray(),
+            'kind' => $this->kind,
+            'description' => $this->getDescriptionAsArray(),
+            'name' => $this->getNameAsArray(),
+            'directives' => $this->getDirectivesAsArray(),
+            'fields' => $this->getFieldsAsArray(),
+            'loc' => $this->getLocationAsArray(),
         ];
     }
 }

src/Language/Node/FloatValueNode.php

Indentation +3 added lines, -3 removed lines

@@ -18,9 +18,9 @@
     public function toArray(): array
     {
         return [
-          'kind' => $this->kind,
-          'loc' => $this->getLocationAsArray(),
-          'value' => $this->value,
+            'kind' => $this->kind,
+            'loc' => $this->getLocationAsArray(),
+            'value' => $this->value,
         ];
     }
 }

src/Language/ASTBuilder.php

Indentation +224 added lines, -224 removed lines

@@ -30,9 +30,9 @@ 
         } while (!$this->skip($lexer, TokenKindEnum::EOF));
 
         return [
-          'kind' => NodeKindEnum::DOCUMENT,
-          'definitions' => $definitions,
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::DOCUMENT,
+            'definitions' => $definitions,
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -112,13 +112,13 @@ 
 
         if ($this->peek($lexer, TokenKindEnum::BRACE_L)) {
             return [
-              'kind' => NodeKindEnum::OPERATION_DEFINITION,
-              'operation' => 'query',
-              'name' => null,
-              'variableDefinitions' => [],
-              'directives' => [],
-              'selectionSet' => $this->buildSelectionSet($lexer),
-              'loc' => $this->buildLocation($lexer, $start),
+                'kind' => NodeKindEnum::OPERATION_DEFINITION,
+                'operation' => 'query',
+                'name' => null,
+                'variableDefinitions' => [],
+                'directives' => [],
+                'selectionSet' => $this->buildSelectionSet($lexer),
+                'loc' => $this->buildLocation($lexer, $start),
             ];
         }
 
@@ -129,13 +129,13 @@ 
         }
 
         return [
-          'kind' => NodeKindEnum::OPERATION_DEFINITION,
-          'operation' => $operation,
-          'name' => $name ?? null,
-          'variableDefinitions' => $this->buildVariableDefinitions($lexer),
-          'directives' => $this->buildDirectives($lexer),
-          'selectionSet' => $this->buildSelectionSet($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::OPERATION_DEFINITION,
+            'operation' => $operation,
+            'name' => $name ?? null,
+            'variableDefinitions' => $this->buildVariableDefinitions($lexer),
+            'directives' => $this->buildDirectives($lexer),
+            'selectionSet' => $this->buildSelectionSet($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -150,14 +150,14 @@ 
         $start = $lexer->getToken();
 
         return [
-          'kind' => NodeKindEnum::SELECTION_SET,
-          'selections' => $this->many(
+            'kind' => NodeKindEnum::SELECTION_SET,
+            'selections' => $this->many(
             $lexer,
             TokenKindEnum::BRACE_L,
             [$this, 'buildSelection'],
             TokenKindEnum::BRACE_R
-          ),
-          'loc' => $this->buildLocation($lexer, $start),
+            ),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -200,9 +200,9 @@ 
         $token = $this->expect($lexer, TokenKindEnum::NAME);
 
         return [
-          'kind' => NodeKindEnum::NAME,
-          'value' => $token->getValue(),
-          'loc' => $this->buildLocation($lexer, $token),
+            'kind' => NodeKindEnum::NAME,
+            'value' => $token->getValue(),
+            'loc' => $this->buildLocation($lexer, $token),
         ];
     }
 
@@ -228,8 +228,8 @@ 
      * @throws SyntaxErrorException
      */
     protected function buildDirectives(
-      LexerInterface $lexer,
-      bool $isConst = false
+        LexerInterface $lexer,
+        bool $isConst = false
     ): ?array
     {
         $directives = [];
@@ -249,18 +249,18 @@ 
      * @throws SyntaxErrorException
      */
     protected function buildDirective(
-      LexerInterface $lexer,
-      bool $isConst
+        LexerInterface $lexer,
+        bool $isConst
     ): array {
         $start = $lexer->getToken();
 
         $this->expect($lexer, TokenKindEnum::AT);
 
         return [
-          'kind' => NodeKindEnum::DIRECTIVE,
-          'name' => $this->buildName($lexer),
-          'arguments' => $this->buildArguments($lexer, $isConst),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::DIRECTIVE,
+            'name' => $this->buildName($lexer),
+            'arguments' => $this->buildArguments($lexer, $isConst),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -272,8 +272,8 @@ 
      * @throws SyntaxErrorException
      */
     protected function buildArguments(
-      LexerInterface $lexer,
-      bool $isConst = false
+        LexerInterface $lexer,
+        bool $isConst = false
     ): ?array
     {
         return $this->peek($lexer, TokenKindEnum::PAREN_L)
@@ -282,7 +282,7 @@ 
             TokenKindEnum::PAREN_L,
             [$this, $isConst ? 'buildConstArgument' : 'buildArgument'],
             TokenKindEnum::PAREN_R
-          )
+            )
           : [];
     }
 
@@ -304,13 +304,13 @@ 
         };
 
         return [
-          'kind' => NodeKindEnum::FRAGMENT_DEFINITION,
-          'name' => $this->buildFragmentName($lexer),
-          'variableDefinitions' => $this->buildVariableDefinitions($lexer),
-          'typeCondition' => $buildTypeCondition($lexer),
-          'directives' => $this->buildDirectives($lexer),
-          'selectionSet' => $this->buildSelectionSet($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::FRAGMENT_DEFINITION,
+            'name' => $this->buildFragmentName($lexer),
+            'variableDefinitions' => $this->buildVariableDefinitions($lexer),
+            'typeCondition' => $buildTypeCondition($lexer),
+            'directives' => $this->buildDirectives($lexer),
+            'selectionSet' => $this->buildSelectionSet($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -325,9 +325,9 @@ 
         $start = $lexer->getToken();
 
         return [
-          'kind' => NodeKindEnum::NAMED_TYPE,
-          'name' => $this->buildName($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::NAMED_TYPE,
+            'name' => $this->buildName($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -397,15 +397,15 @@ 
         $this->expectKeyword($lexer, KeywordEnum::SCHEMA);
 
         return [
-          'kind' => NodeKindEnum::SCHEMA_DEFINITION,
-          'directives' => $this->buildDirectives($lexer),
-          'operationTypes' => $this->many(
+            'kind' => NodeKindEnum::SCHEMA_DEFINITION,
+            'directives' => $this->buildDirectives($lexer),
+            'operationTypes' => $this->many(
             $lexer,
             TokenKindEnum::BRACE_L,
             [$this, 'buildOperationTypeDefinition'],
             TokenKindEnum::BRACE_R
-          ),
-          'loc' => $this->buildLocation($lexer, $start),
+            ),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -424,11 +424,11 @@ 
         $this->expectKeyword($lexer, KeywordEnum::SCALAR);
 
         return [
-          'kind' => NodeKindEnum::SCALAR_TYPE_DEFINITION,
-          'description' => $description,
-          'name' => $this->buildName($lexer),
-          'directives' => $this->buildDirectives($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::SCALAR_TYPE_DEFINITION,
+            'description' => $description,
+            'name' => $this->buildName($lexer),
+            'directives' => $this->buildDirectives($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -449,10 +449,10 @@ 
         $lexer->advance();
 
         return [
-          'kind' => NodeKindEnum::STRING,
-          'value' => $token->getValue(),
-          'block' => $token->getKind() === TokenKindEnum::BLOCK_STRING,
-          'loc' => $this->buildLocation($lexer, $token),
+            'kind' => NodeKindEnum::STRING,
+            'value' => $token->getValue(),
+            'block' => $token->getKind() === TokenKindEnum::BLOCK_STRING,
+            'loc' => $this->buildLocation($lexer, $token),
         ];
     }
 
@@ -471,13 +471,13 @@ 
         $this->expectKeyword($lexer, KeywordEnum::TYPE);
 
         return [
-          'kind' => NodeKindEnum::OBJECT_TYPE_DEFINITION,
-          'description' => $description,
-          'name' => $this->buildName($lexer),
-          'interfaces' => $this->buildImplementsInterfaces($lexer),
-          'directives' => $this->buildDirectives($lexer),
-          'fields' => $this->buildFieldsDefinition($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::OBJECT_TYPE_DEFINITION,
+            'description' => $description,
+            'name' => $this->buildName($lexer),
+            'interfaces' => $this->buildImplementsInterfaces($lexer),
+            'directives' => $this->buildDirectives($lexer),
+            'fields' => $this->buildFieldsDefinition($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -519,7 +519,7 @@ 
             TokenKindEnum::BRACE_L,
             [$this, 'buildFieldDefinition'],
             TokenKindEnum::BRACE_R
-          )
+            )
           : [];
     }
 
@@ -539,12 +539,12 @@ 
         $this->expectKeyword($lexer, KeywordEnum::INTERFACE);
 
         return [
-          'kind' => NodeKindEnum::INTERFACE_TYPE_DEFINITION,
-          'description' => $description,
-          'name' => $this->buildName($lexer),
-          'directives' => $this->buildDirectives($lexer),
-          'fields' => $this->buildFieldsDefinition($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::INTERFACE_TYPE_DEFINITION,
+            'description' => $description,
+            'name' => $this->buildName($lexer),
+            'directives' => $this->buildDirectives($lexer),
+            'fields' => $this->buildFieldsDefinition($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -563,12 +563,12 @@ 
         $this->expectKeyword($lexer, KeywordEnum::UNION);
 
         return [
-          'kind' => NodeKindEnum::UNION_TYPE_DEFINITION,
-          'description' => $description,
-          'name' => $this->buildName($lexer),
-          'directives' => $this->buildDirectives($lexer),
-          'types' => $this->buildUnionMemberTypes($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::UNION_TYPE_DEFINITION,
+            'description' => $description,
+            'name' => $this->buildName($lexer),
+            'directives' => $this->buildDirectives($lexer),
+            'types' => $this->buildUnionMemberTypes($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -609,12 +609,12 @@ 
         $this->expectKeyword($lexer, KeywordEnum::ENUM);
 
         return [
-          'kind' => NodeKindEnum::ENUM_TYPE_DEFINITION,
-          'description' => $description,
-          'name' => $this->buildName($lexer),
-          'directives' => $this->buildDirectives($lexer),
-          'values' => $this->buildEnumValuesDefinition($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::ENUM_TYPE_DEFINITION,
+            'description' => $description,
+            'name' => $this->buildName($lexer),
+            'directives' => $this->buildDirectives($lexer),
+            'values' => $this->buildEnumValuesDefinition($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -632,7 +632,7 @@ 
             TokenKindEnum::BRACE_L,
             [$this, 'buildEnumValueDefinition'],
             TokenKindEnum::BRACE_R
-          )
+            )
           : [];
     }
 
@@ -652,12 +652,12 @@ 
         $this->expectKeyword($lexer, KeywordEnum::INPUT);
 
         return [
-          'kind' => NodeKindEnum::INPUT_OBJECT_TYPE_DEFINITION,
-          'description' => $description,
-          'name' => $this->buildName($lexer),
-          'directives' => $this->buildDirectives($lexer, true),
-          'fields' => $this->buildInputFieldsDefinition($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::INPUT_OBJECT_TYPE_DEFINITION,
+            'description' => $description,
+            'name' => $this->buildName($lexer),
+            'directives' => $this->buildDirectives($lexer, true),
+            'fields' => $this->buildInputFieldsDefinition($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -679,7 +679,7 @@ 
             TokenKindEnum::BRACE_L,
             $buildFunction,
             TokenKindEnum::BRACE_R
-          )
+            )
           : [];
     }
 
@@ -699,15 +699,15 @@ 
         $this->expect($lexer, TokenKindEnum::COLON);
 
         return [
-          'kind' => NodeKindEnum::INPUT_VALUE_DEFINITION,
-          'description' => $description,
-          'name' => $name,
-          'type' => $this->buildTypeReference($lexer),
-          'defaultValue' => $this->skip($lexer, TokenKindEnum::EQUALS)
+            'kind' => NodeKindEnum::INPUT_VALUE_DEFINITION,
+            'description' => $description,
+            'name' => $name,
+            'type' => $this->buildTypeReference($lexer),
+            'defaultValue' => $this->skip($lexer, TokenKindEnum::EQUALS)
             ? $this->buildValueLiteral($lexer, true)
             : null,
-          'directives' => $this->buildDirectives($lexer, true),
-          'loc' => $this->buildLocation($lexer, $start),
+            'directives' => $this->buildDirectives($lexer, true),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -738,9 +738,9 @@ 
             $this->expect($lexer, TokenKindEnum::BRACKET_R);
 
             $type = [
-              'kind' => NodeKindEnum::LIST_TYPE,
-              'type' => $type,
-              'loc' => $this->buildLocation($lexer, $start),
+                'kind' => NodeKindEnum::LIST_TYPE,
+                'type' => $type,
+                'loc' => $this->buildLocation($lexer, $start),
             ];
         } else {
             $type = $this->buildNamedType($lexer);
@@ -748,9 +748,9 @@ 
 
         if ($this->skip($lexer, TokenKindEnum::BANG)) {
             return [
-              'kind' => NodeKindEnum::NON_NULL_TYPE,
-              'type' => $type,
-              'loc' => $this->buildLocation($lexer, $start),
+                'kind' => NodeKindEnum::NON_NULL_TYPE,
+                'type' => $type,
+                'loc' => $this->buildLocation($lexer, $start),
             ];
         }
 
@@ -765,8 +765,8 @@ 
      * @throws SyntaxErrorException
      */
     public function buildValueLiteral(
-      LexerInterface $lexer,
-      bool $isConst = false
+        LexerInterface $lexer,
+        bool $isConst = false
     ): ?array
     {
         return $this->parseValueLiteral($lexer, $isConst);
@@ -780,8 +780,8 @@ 
      * @throws SyntaxErrorException
      */
     protected function parseValueLiteral(
-      LexerInterface $lexer,
-      bool $isConst
+        LexerInterface $lexer,
+        bool $isConst
     ): array {
         $token = $lexer->getToken();
 
@@ -794,17 +794,17 @@ 
                 $lexer->advance();
 
                 return [
-                  'kind' => NodeKindEnum::INT,
-                  'value' => $token->getValue(),
-                  'loc' => $this->buildLocation($lexer, $token),
+                    'kind' => NodeKindEnum::INT,
+                    'value' => $token->getValue(),
+                    'loc' => $this->buildLocation($lexer, $token),
                 ];
             case TokenKindEnum::FLOAT:
                 $lexer->advance();
 
                 return [
-                  'kind' => NodeKindEnum::FLOAT,
-                  'value' => $token->getValue(),
-                  'loc' => $this->buildLocation($lexer, $token),
+                    'kind' => NodeKindEnum::FLOAT,
+                    'value' => $token->getValue(),
+                    'loc' => $this->buildLocation($lexer, $token),
                 ];
             case TokenKindEnum::STRING:
             case TokenKindEnum::BLOCK_STRING:
@@ -816,9 +816,9 @@ 
                     $lexer->advance();
 
                     return [
-                      'kind' => NodeKindEnum::BOOLEAN,
-                      'value' => $value === 'true',
-                      'loc' => $this->buildLocation($lexer, $token),
+                        'kind' => NodeKindEnum::BOOLEAN,
+                        'value' => $value === 'true',
+                        'loc' => $this->buildLocation($lexer, $token),
                     ];
                 }
 
@@ -826,17 +826,17 @@ 
                     $lexer->advance();
 
                     return [
-                      'kind' => NodeKindEnum::NULL,
-                      'loc' => $this->buildLocation($lexer, $token),
+                        'kind' => NodeKindEnum::NULL,
+                        'loc' => $this->buildLocation($lexer, $token),
                     ];
                 }
 
                 $lexer->advance();
 
                 return [
-                  'kind' => NodeKindEnum::ENUM,
-                  'value' => $token->getValue(),
-                  'loc' => $this->buildLocation($lexer, $token),
+                    'kind' => NodeKindEnum::ENUM,
+                    'value' => $token->getValue(),
+                    'loc' => $this->buildLocation($lexer, $token),
                 ];
             case TokenKindEnum::DOLLAR:
                 if (!$isConst) {
@@ -860,14 +860,14 @@ 
         $start = $lexer->getToken();
 
         return [
-          'kind' => NodeKindEnum::LIST,
-          'values' => $this->any(
+            'kind' => NodeKindEnum::LIST,
+            'values' => $this->any(
             $lexer,
             TokenKindEnum::BRACKET_L,
             [$this, $isConst ? 'buildConstValue' : 'buildValue'],
             TokenKindEnum::BRACKET_R
-          ),
-          'loc' => $this->buildLocation($lexer, $start),
+            ),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -891,9 +891,9 @@ 
         }
 
         return [
-          'kind' => NodeKindEnum::OBJECT,
-          'fields' => $fields,
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::OBJECT,
+            'fields' => $fields,
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -905,8 +905,8 @@ 
      * @throws SyntaxErrorException
      */
     protected function buildObjectField(
-      LexerInterface $lexer,
-      bool $isConst
+        LexerInterface $lexer,
+        bool $isConst
     ): array {
         $start = $lexer->getToken();
 
@@ -917,10 +917,10 @@ 
         };
 
         return [
-          'kind' => NodeKindEnum::OBJECT_FIELD,
-          'name' => $this->buildName($lexer),
-          'value' => $buildValue($lexer, $isConst),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::OBJECT_FIELD,
+            'name' => $this->buildName($lexer),
+            'value' => $buildValue($lexer, $isConst),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -937,9 +937,9 @@ 
         $this->expect($lexer, TokenKindEnum::DOLLAR);
 
         return [
-          'kind' => NodeKindEnum::VARIABLE,
-          'name' => $this->buildName($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::VARIABLE,
+            'name' => $this->buildName($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -967,12 +967,12 @@ 
         $locations = $this->buildDirectiveLocations($lexer);
 
         return [
-          'kind' => NodeKindEnum::DIRECTIVE_DEFINITION,
-          'description' => $description,
-          'name' => $name,
-          'arguments' => $arguments,
-          'locations' => $locations,
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::DIRECTIVE_DEFINITION,
+            'description' => $description,
+            'name' => $name,
+            'arguments' => $arguments,
+            'locations' => $locations,
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -994,7 +994,7 @@ 
             TokenKindEnum::PAREN_L,
             $buildFunction,
             TokenKindEnum::PAREN_R
-          )
+            )
           : [];
     }
 
@@ -1076,8 +1076,8 @@ 
      * @throws SyntaxErrorException
      */
     protected function buildScalarTypeExtension(
-      LexerInterface $lexer,
-      bool $isConst = false
+        LexerInterface $lexer,
+        bool $isConst = false
     ): ?array
     {
         $start = $lexer->getToken();
@@ -1093,10 +1093,10 @@ 
         }
 
         return [
-          'kind' => NodeKindEnum::SCALAR_TYPE_EXTENSION,
-          'name' => $name,
-          'directives' => $directives,
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::SCALAR_TYPE_EXTENSION,
+            'name' => $name,
+            'directives' => $directives,
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -1123,12 +1123,12 @@ 
         }
 
         return [
-          'kind' => NodeKindEnum::OBJECT_TYPE_EXTENSION,
-          'name' => $name,
-          'interfaces' => $interfaces,
-          'directives' => $directives,
-          'fields' => $fields,
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::OBJECT_TYPE_EXTENSION,
+            'name' => $name,
+            'interfaces' => $interfaces,
+            'directives' => $directives,
+            'fields' => $fields,
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -1155,11 +1155,11 @@ 
         }
 
         return [
-          'kind' => NodeKindEnum::INTERFACE_TYPE_EXTENSION,
-          'name' => $name,
-          'directives' => $directives,
-          'fields' => $fields,
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::INTERFACE_TYPE_EXTENSION,
+            'name' => $name,
+            'directives' => $directives,
+            'fields' => $fields,
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -1185,11 +1185,11 @@ 
         }
 
         return [
-          'kind' => NodeKindEnum::UNION_TYPE_EXTENSION,
-          'name' => $name,
-          'directives' => $directives,
-          'types' => $types,
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::UNION_TYPE_EXTENSION,
+            'name' => $name,
+            'directives' => $directives,
+            'types' => $types,
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -1215,11 +1215,11 @@ 
         }
 
         return [
-          'kind' => NodeKindEnum::ENUM_TYPE_EXTENSION,
-          'name' => $name,
-          'directives' => $directives,
-          'values' => $values,
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::ENUM_TYPE_EXTENSION,
+            'name' => $name,
+            'directives' => $directives,
+            'values' => $values,
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -1246,11 +1246,11 @@ 
         }
 
         return [
-          'kind' => NodeKindEnum::INPUT_OBJECT_TYPE_EXTENSION,
-          'name' => $name,
-          'directives' => $directives,
-          'fields' => $fields,
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::INPUT_OBJECT_TYPE_EXTENSION,
+            'name' => $name,
+            'directives' => $directives,
+            'fields' => $fields,
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -1276,10 +1276,10 @@ 
         };
 
         return [
-          'kind' => NodeKindEnum::ARGUMENT,
-          'name' => $this->buildName($lexer),
-          'value' => $buildValue($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::ARGUMENT,
+            'name' => $this->buildName($lexer),
+            'value' => $buildValue($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -1305,10 +1305,10 @@ 
         };
 
         return [
-          'kind' => NodeKindEnum::ARGUMENT,
-          'name' => $this->buildName($lexer),
-          'value' => $buildValue($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::ARGUMENT,
+            'name' => $this->buildName($lexer),
+            'value' => $buildValue($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -1323,11 +1323,11 @@ 
         $start = $lexer->getToken();
 
         return [
-          'kind' => NodeKindEnum::ENUM_VALUE_DEFINITION,
-          'description' => $this->buildDescription($lexer),
-          'name' => $this->buildName($lexer),
-          'directives' => $this->buildDirectives($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::ENUM_VALUE_DEFINITION,
+            'description' => $this->buildDescription($lexer),
+            'name' => $this->buildName($lexer),
+            'directives' => $this->buildDirectives($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -1348,13 +1348,13 @@ 
         $this->expect($lexer, TokenKindEnum::COLON);
 
         return [
-          'kind' => NodeKindEnum::FIELD_DEFINITION,
-          'description' => $description,
-          'name' => $name,
-          'arguments' => $arguments,
-          'type' => $this->buildTypeReference($lexer),
-          'directives' => $this->buildDirectives($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::FIELD_DEFINITION,
+            'description' => $description,
+            'name' => $name,
+            'arguments' => $arguments,
+            'type' => $this->buildTypeReference($lexer),
+            'directives' => $this->buildDirectives($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -1373,10 +1373,10 @@ 
         $this->expect($lexer, TokenKindEnum::COLON);
 
         return [
-          'kind' => NodeKindEnum::OPERATION_TYPE_DEFINITION,
-          'operation' => $operation,
-          'type' => $this->buildNamedType($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::OPERATION_TYPE_DEFINITION,
+            'operation' => $operation,
+            'type' => $this->buildNamedType($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -1409,10 +1409,10 @@ 
 
         if ($tokenValue !== 'on' && $this->peek($lexer, TokenKindEnum::NAME)) {
             return [
-              'kind' => NodeKindEnum::FRAGMENT_SPREAD,
-              'name' => $this->buildFragmentName($lexer),
-              'directives' => $this->buildDirectives($lexer),
-              'loc' => $this->buildLocation($lexer, $start),
+                'kind' => NodeKindEnum::FRAGMENT_SPREAD,
+                'name' => $this->buildFragmentName($lexer),
+                'directives' => $this->buildDirectives($lexer),
+                'loc' => $this->buildLocation($lexer, $start),
             ];
         }
 
@@ -1423,11 +1423,11 @@ 
         }
 
         return [
-          'kind' => NodeKindEnum::INLINE_FRAGMENT,
-          'typeCondition' => $typeCondition ?? null,
-          'directives' => $this->buildDirectives($lexer),
-          'selectionSet' => $this->buildSelectionSet($lexer),
-          'loc' => $this->buildLocation($lexer, $start),
+            'kind' => NodeKindEnum::INLINE_FRAGMENT,
+            'typeCondition' => $typeCondition ?? null,
+            'directives' => $this->buildDirectives($lexer),
+            'selectionSet' => $this->buildSelectionSet($lexer),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -1451,15 +1451,15 @@ 
         }
 
         return [
-          'kind' => NodeKindEnum::FIELD,
-          'alias' => $alias ?? null,
-          'name' => $name,
-          'arguments' => $this->buildArguments($lexer, false),
-          'directives' => $this->buildDirectives($lexer),
-          'selectionSet' => $this->peek($lexer, TokenKindEnum::BRACE_L)
+            'kind' => NodeKindEnum::FIELD,
+            'alias' => $alias ?? null,
+            'name' => $name,
+            'arguments' => $this->buildArguments($lexer, false),
+            'directives' => $this->buildDirectives($lexer),
+            'selectionSet' => $this->peek($lexer, TokenKindEnum::BRACE_L)
             ? $this->buildSelectionSet($lexer)
             : null,
-          'loc' => $this->buildLocation($lexer, $start),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 
@@ -1508,13 +1508,13 @@ 
         };
 
         return [
-          'kind' => NodeKindEnum::VARIABLE_DEFINITION,
-          'variable' => $this->buildVariable($lexer),
-          'type' => $buildType($lexer),
-          'defaultValue' => $this->skip($lexer, TokenKindEnum::EQUALS)
+            'kind' => NodeKindEnum::VARIABLE_DEFINITION,
+            'variable' => $this->buildVariable($lexer),
+            'type' => $buildType($lexer),
+            'defaultValue' => $this->skip($lexer, TokenKindEnum::EQUALS)
             ? $this->buildValueLiteral($lexer, true)
             : null,
-          'loc' => $this->buildLocation($lexer, $start),
+            'loc' => $this->buildLocation($lexer, $start),
         ];
     }
 }

Spacing +7 added lines, -7 removed lines

@@ -298,7 +298,7 @@ 
 
         $this->expectKeyword($lexer, KeywordEnum::FRAGMENT);
 
-        $buildTypeCondition = function (LexerInterface $lexer) {
+        $buildTypeCondition = function(LexerInterface $lexer) {
             $this->expectKeyword($lexer, 'on');
             return $this->buildNamedType($lexer);
         };
@@ -669,7 +669,7 @@ 
      */
     protected function buildInputFieldsDefinition(LexerInterface $lexer): ?array
     {
-        $buildFunction = function (LexerInterface $lexer): array {
+        $buildFunction = function(LexerInterface $lexer): array {
             return $this->buildInputValueDefinition($lexer);
         };
 
@@ -910,7 +910,7 @@ 
     ): array {
         $start = $lexer->getToken();
 
-        $buildValue = function (LexerInterface $lexer, bool $isConst) {
+        $buildValue = function(LexerInterface $lexer, bool $isConst) {
             $this->expect($lexer, TokenKindEnum::COLON);
 
             return $this->buildValueLiteral($lexer, $isConst);
@@ -984,7 +984,7 @@ 
      */
     protected function buildArgumentsDefinition(LexerInterface $lexer): ?array
     {
-        $buildFunction = function (LexerInterface $lexer): array {
+        $buildFunction = function(LexerInterface $lexer): array {
             return $this->buildInputValueDefinition($lexer);
         };
 
@@ -1270,7 +1270,7 @@ 
          * @return mixed
          * @throws SyntaxErrorException
          */
-        $buildValue = function (LexerInterface $lexer) {
+        $buildValue = function(LexerInterface $lexer) {
             $this->expect($lexer, TokenKindEnum::COLON);
             return $this->buildValueLiteral($lexer);
         };
@@ -1299,7 +1299,7 @@ 
          * @return mixed
          * @throws SyntaxErrorException
          */
-        $buildValue = function (LexerInterface $lexer) {
+        $buildValue = function(LexerInterface $lexer) {
             $this->expect($lexer, TokenKindEnum::COLON);
             return $this->buildValueLiteral($lexer);
         };
@@ -1501,7 +1501,7 @@ 
          * @return mixed
          * @throws SyntaxErrorException
          */
-        $buildType = function (LexerInterface $lexer) {
+        $buildType = function(LexerInterface $lexer) {
             $this->expect($lexer, TokenKindEnum::COLON);
 
             return $this->buildTypeReference($lexer);

src/Validation/ValidationProvider.php

Indentation +3 added lines, -3 removed lines

@@ -12,7 +12,7 @@ 
      * @var array
      */
     protected $provides = [
-      ValidatorInterface::class,
+        ValidatorInterface::class,
     ];
 
     /**
@@ -21,7 +21,7 @@ 
     public function register()
     {
         $this->container->add(ValidatorInterface::class, Validator::class,
-          true/* $shared */)
-          ->withArgument(SchemaValidatorInterface::class);
+            true/* $shared */)
+            ->withArgument(SchemaValidatorInterface::class);
     }
 }

src/Validation/RulesProvider.php

Indentation +51 added lines, -51 removed lines

@@ -38,31 +38,31 @@ 
      * @var array
      */
     protected $provides = [
-      ExecutableDefinitionsRule::class,
-      FieldOnCorrectTypeRule::class,
-      FragmentsOnCompositeTypesRule::class,
-      KnownArgumentNamesRule::class,
-      KnownDirectivesRule::class,
-      KnownFragmentNamesRule::class,
-      KnownTypeNamesRule::class,
-      LoneAnonymousOperationRule::class,
-      NoFragmentCyclesRule::class,
-      NoUndefinedVariablesRule::class,
-      NoUnusedFragmentsRule::class,
-      NoUnusedVariablesRule::class,
-      OverlappingFieldsCanBeMergedRule::class,
-      PossibleFragmentSpreadsRule::class,
-      ProvidedNonNullArgumentsRule::class,
-      ScalarLeafsRule::class,
-      SingleFieldSubscriptionsRule::class,
-      UniqueArgumentNamesRule::class,
-      UniqueDirectivesPerLocationRule::class,
-      UniqueFragmentNamesRule::class,
-      UniqueVariableNamesRule::class,
-      ValuesOfCorrectTypeRule::class,
-      VariablesAreInputTypesRule::class,
-      VariablesDefaultValueAllowedRule::class,
-      VariablesInAllowedPositionRule::class,
+        ExecutableDefinitionsRule::class,
+        FieldOnCorrectTypeRule::class,
+        FragmentsOnCompositeTypesRule::class,
+        KnownArgumentNamesRule::class,
+        KnownDirectivesRule::class,
+        KnownFragmentNamesRule::class,
+        KnownTypeNamesRule::class,
+        LoneAnonymousOperationRule::class,
+        NoFragmentCyclesRule::class,
+        NoUndefinedVariablesRule::class,
+        NoUnusedFragmentsRule::class,
+        NoUnusedVariablesRule::class,
+        OverlappingFieldsCanBeMergedRule::class,
+        PossibleFragmentSpreadsRule::class,
+        ProvidedNonNullArgumentsRule::class,
+        ScalarLeafsRule::class,
+        SingleFieldSubscriptionsRule::class,
+        UniqueArgumentNamesRule::class,
+        UniqueDirectivesPerLocationRule::class,
+        UniqueFragmentNamesRule::class,
+        UniqueVariableNamesRule::class,
+        ValuesOfCorrectTypeRule::class,
+        VariablesAreInputTypesRule::class,
+        VariablesDefaultValueAllowedRule::class,
+        VariablesInAllowedPositionRule::class,
     ];
 
     /**
@@ -71,57 +71,57 @@ 
     public function register()
     {
         $this->container->add(ExecutableDefinitionsRule::class,
-          ExecutableDefinitionsRule::class);
+            ExecutableDefinitionsRule::class);
         $this->container->add(FieldOnCorrectTypeRule::class,
-          FieldOnCorrectTypeRule::class);
+            FieldOnCorrectTypeRule::class);
         $this->container->add(FragmentsOnCompositeTypesRule::class,
-          FragmentsOnCompositeTypesRule::class);
+            FragmentsOnCompositeTypesRule::class);
         $this->container->add(KnownArgumentNamesRule::class,
-          KnownArgumentNamesRule::class);
+            KnownArgumentNamesRule::class);
         $this->container->add(KnownDirectivesRule::class,
-          KnownDirectivesRule::class);
+            KnownDirectivesRule::class);
         $this->container->add(KnownFragmentNamesRule::class,
-          KnownFragmentNamesRule::class);
+            KnownFragmentNamesRule::class);
         $this->container->add(KnownTypeNamesRule::class,
-          KnownTypeNamesRule::class);
+            KnownTypeNamesRule::class);
         $this->container->add(LoneAnonymousOperationRule::class,
-          LoneAnonymousOperationRule::class);
+            LoneAnonymousOperationRule::class);
         $this->container->add(NoFragmentCyclesRule::class,
-          NoFragmentCyclesRule::class);
+            NoFragmentCyclesRule::class);
         $this->container->add(NoUndefinedVariablesRule::class,
-          NoUndefinedVariablesRule::class);
+            NoUndefinedVariablesRule::class);
         $this->container->add(NoUnusedFragmentsRule::class,
-          NoUnusedFragmentsRule::class);
+            NoUnusedFragmentsRule::class);
         $this->container->add(NoUnusedVariablesRule::class,
-          NoUnusedVariablesRule::class);
+            NoUnusedVariablesRule::class);
         $this->container->add(OverlappingFieldsCanBeMergedRule::class,
-          OverlappingFieldsCanBeMergedRule::class);
+            OverlappingFieldsCanBeMergedRule::class);
         $this->container->add(PossibleFragmentSpreadsRule::class,
-          PossibleFragmentSpreadsRule::class);
+            PossibleFragmentSpreadsRule::class);
         $this->container->add(ProvidedNonNullArgumentsRule::class,
-          ProvidedNonNullArgumentsRule::class);
+            ProvidedNonNullArgumentsRule::class);
         $this->container->add(ScalarLeafsRule::class, ScalarLeafsRule::class);
         $this->container->add(SingleFieldSubscriptionsRule::class,
-          SingleFieldSubscriptionsRule::class);
+            SingleFieldSubscriptionsRule::class);
         $this->container->add(UniqueArgumentNamesRule::class,
-          UniqueArgumentNamesRule::class);
+            UniqueArgumentNamesRule::class);
         $this->container->add(UniqueDirectivesPerLocationRule::class,
-          UniqueDirectivesPerLocationRule::class);
+            UniqueDirectivesPerLocationRule::class);
         $this->container->add(UniqueFragmentNamesRule::class,
-          UniqueFragmentNamesRule::class);
+            UniqueFragmentNamesRule::class);
         $this->container->add(UniqueInputFieldNamesRule::class,
-          UniqueInputFieldNamesRule::class);
+            UniqueInputFieldNamesRule::class);
         $this->container->add(UniqueOperationNamesRule::class,
-          UniqueOperationNamesRule::class);
+            UniqueOperationNamesRule::class);
         $this->container->add(UniqueVariableNamesRule::class,
-          UniqueVariableNamesRule::class);
+            UniqueVariableNamesRule::class);
         $this->container->add(ValuesOfCorrectTypeRule::class,
-          ValuesOfCorrectTypeRule::class);
+            ValuesOfCorrectTypeRule::class);
         $this->container->add(VariablesAreInputTypesRule::class,
-          VariablesAreInputTypesRule::class);
+            VariablesAreInputTypesRule::class);
         $this->container->add(VariablesDefaultValueAllowedRule::class,
-          VariablesDefaultValueAllowedRule::class);
+            VariablesDefaultValueAllowedRule::class);
         $this->container->add(VariablesInAllowedPositionRule::class,
-          VariablesInAllowedPositionRule::class);
+            VariablesInAllowedPositionRule::class);
     }
 }

src/Validation/ValidationContextInterface.php

Indentation +2 added lines, -2 removed lines

@@ -87,7 +87,7 @@ 
      * @return array
      */
     public function getRecursiveVariableUsages(
-      OperationDefinitionNode $operation
+        OperationDefinitionNode $operation
     ): array;
 
     /**
@@ -103,6 +103,6 @@ 
      * @return array|FragmentDefinitionNode[]
      */
     public function getRecursivelyReferencedFragments(
-      OperationDefinitionNode $operation
+        OperationDefinitionNode $operation
     ): array;
 }