digiaonline / graphql-php

src/Validation/Validator.php

Indentation +6 added lines, -6 removed lines

@@ -34,8 +34,8 @@ 
      * @inheritdoc
      */
     public function validate(
-      SchemaInterface $schema,
-      DocumentNode $document,
+        SchemaInterface $schema,
+        DocumentNode $document,
       ?array $rules = null,
       ?TypeInfo $typeInfo = null
     ): array {
@@ -53,7 +53,7 @@ 
         }, $rules);
 
         $visitor = new TypeInfoVisitor($typeInfo,
-          new ParallelVisitor($visitors));
+            new ParallelVisitor($visitors));
 
         // Visit the whole document with each instance of all provided rules.
         $document->acceptVisitor($visitor);
@@ -69,9 +69,9 @@ 
      * @return ValidationContextInterface
      */
     public function createContext(
-      SchemaInterface $schema,
-      DocumentNode $document,
-      TypeInfo $typeInfo
+        SchemaInterface $schema,
+        DocumentNode $document,
+        TypeInfo $typeInfo
     ): ValidationContextInterface {
         return new ValidationContext($schema, $document, $typeInfo);
     }

src/Validation/Conflict/FindsConflictsTrait.php

Indentation +126 added lines, -126 removed lines

@@ -109,9 +109,9 @@ 
      * @throws InvariantException
      */
     protected function findConflictsWithinSelectionSet(
-      Map $cachedFieldsAndFragmentNames,
-      PairSet $comparedFragmentPairs,
-      SelectionSetNode $selectionSet,
+        Map $cachedFieldsAndFragmentNames,
+        PairSet $comparedFragmentPairs,
+        SelectionSetNode $selectionSet,
       ?NamedTypeInterface $parentType = null
     ): array {
         $this->cachedFieldsAndFragmentNames = $cachedFieldsAndFragmentNames;
@@ -135,11 +135,11 @@ 
             /** @noinspection ForeachInvariantsInspection */
             for ($i = 0; $i < $fragmentNamesCount; $i++) {
                 $this->collectConflictsBetweenFieldsAndFragment(
-                  $context,
-                  $comparedFragments,
-                  $fieldMap,
-                  $fragmentNames[$i],
-                  false/* $areMutuallyExclusive */
+                    $context,
+                    $comparedFragments,
+                    $fieldMap,
+                    $fragmentNames[$i],
+                    false/* $areMutuallyExclusive */
                 );
 
                 // (C) Then compare this fragment with all other fragments found in this
@@ -148,10 +148,10 @@ 
                 // item in that same list (except for itself).
                 for ($j = $i + 1; $j < $fragmentNamesCount; $j++) {
                     $this->collectConflictsBetweenFragments(
-                      $context,
-                      $fragmentNames[$i],
-                      $fragmentNames[$j],
-                      false/* $areMutuallyExclusive */
+                        $context,
+                        $fragmentNames[$i],
+                        $fragmentNames[$j],
+                        false/* $areMutuallyExclusive */
                     );
                 }
             }
@@ -173,11 +173,11 @@ 
      * @throws InvalidTypeException
      */
     protected function collectConflictsBetweenFieldsAndFragment(
-      ComparisonContext $context,
-      array &$comparedFragments,
-      array $fieldMap,
-      string $fragmentName,
-      bool $areMutuallyExclusive
+        ComparisonContext $context,
+        array &$comparedFragments,
+        array $fieldMap,
+        string $fragmentName,
+        bool $areMutuallyExclusive
     ): void {
         // Memoize so a fragment is not compared for conflicts more than once.
         if (isset($comparedFragments[$fragmentName])) {
@@ -204,10 +204,10 @@ 
         // (D) First collect any conflicts between the provided collection of fields
         // and the collection of fields represented by the given fragment.
         $this->collectConflictsBetween(
-          $context,
-          $fieldMap,
-          $fieldMapB,
-          $areMutuallyExclusive
+            $context,
+            $fieldMap,
+            $fieldMapB,
+            $areMutuallyExclusive
         );
 
         $fragmentNamesB = $contextB->getFragmentNames();
@@ -220,11 +220,11 @@ 
             /** @noinspection ForeachInvariantsInspection */
             for ($i = 0; $i < $fragmentNamesBCount; $i++) {
                 $this->collectConflictsBetweenFieldsAndFragment(
-                  $context,
-                  $comparedFragments,
-                  $fieldMap,
-                  $fragmentNamesB[$i],
-                  $areMutuallyExclusive
+                    $context,
+                    $comparedFragments,
+                    $fieldMap,
+                    $fragmentNamesB[$i],
+                    $areMutuallyExclusive
                 );
             }
         }
@@ -242,10 +242,10 @@ 
      * @throws InvalidTypeException
      */
     protected function collectConflictsBetweenFragments(
-      ComparisonContext $context,
-      string $fragmentNameA,
-      string $fragmentNameB,
-      bool $areMutuallyExclusive
+        ComparisonContext $context,
+        string $fragmentNameA,
+        string $fragmentNameB,
+        bool $areMutuallyExclusive
     ): void {
         // No need to compare a fragment to itself.
         if ($fragmentNameA === $fragmentNameB) {
@@ -254,12 +254,12 @@ 
 
         // Memoize so two fragments are not compared for conflicts more than once.
         if ($this->comparedFragmentPairs->has($fragmentNameA, $fragmentNameB,
-          $areMutuallyExclusive)) {
+            $areMutuallyExclusive)) {
             return;
         }
 
         $this->comparedFragmentPairs->add($fragmentNameA, $fragmentNameB,
-          $areMutuallyExclusive);
+            $areMutuallyExclusive);
 
         $fragmentA = $this->getValidationContext()->getFragment($fragmentNameA);
         $fragmentB = $this->getValidationContext()->getFragment($fragmentNameB);
@@ -274,10 +274,10 @@ 
         // (F) First, collect all conflicts between these two collections of fields
         // (not including any nested fragments).
         $this->collectConflictsBetween(
-          $context,
-          $contextA->getFieldMap(),
-          $contextB->getFieldMap(),
-          $areMutuallyExclusive
+            $context,
+            $contextA->getFieldMap(),
+            $contextB->getFieldMap(),
+            $areMutuallyExclusive
         );
 
         $fragmentNamesB = $contextB->getFragmentNames();
@@ -290,10 +290,10 @@ 
             /** @noinspection ForeachInvariantsInspection */
             for ($j = 0; $j < $fragmentNamesBCount; $j++) {
                 $this->collectConflictsBetweenFragments(
-                  $context,
-                  $fragmentNameA,
-                  $fragmentNamesB[$j],
-                  $areMutuallyExclusive
+                    $context,
+                    $fragmentNameA,
+                    $fragmentNamesB[$j],
+                    $areMutuallyExclusive
                 );
             }
         }
@@ -308,10 +308,10 @@ 
             /** @noinspection ForeachInvariantsInspection */
             for ($i = 0; $i < $fragmentNamesACount; $i++) {
                 $this->collectConflictsBetweenFragments(
-                  $context,
-                  $fragmentNamesA[$i],
-                  $fragmentNameB,
-                  $areMutuallyExclusive
+                    $context,
+                    $fragmentNamesA[$i],
+                    $fragmentNameB,
+                    $areMutuallyExclusive
                 );
             }
         }
@@ -333,17 +333,17 @@ 
      */
     protected function findConflictsBetweenSubSelectionSets(
       ?NamedTypeInterface $parentTypeA,
-      SelectionSetNode $selectionSetA,
+        SelectionSetNode $selectionSetA,
       ?NamedTypeInterface $parentTypeB,
-      SelectionSetNode $selectionSetB,
-      bool $areMutuallyExclusive
+        SelectionSetNode $selectionSetB,
+        bool $areMutuallyExclusive
     ): array {
         $context = new ComparisonContext();
 
         $contextA = $this->getFieldsAndFragmentNames($selectionSetA,
-          $parentTypeA);
+            $parentTypeA);
         $contextB = $this->getFieldsAndFragmentNames($selectionSetB,
-          $parentTypeB);
+            $parentTypeB);
 
         $fieldMapA = $contextA->getFieldMap();
         $fieldMapB = $contextB->getFieldMap();
@@ -356,10 +356,10 @@ 
 
         // (H) First, collect all conflicts between these two collections of field.
         $this->collectConflictsBetween(
-          $context,
-          $fieldMapA,
-          $fieldMapB,
-          $areMutuallyExclusive
+            $context,
+            $fieldMapA,
+            $fieldMapB,
+            $areMutuallyExclusive
         );
 
         // (I) Then collect conflicts between the first collection of fields and
@@ -370,11 +370,11 @@ 
             /** @noinspection ForeachInvariantsInspection */
             for ($j = 0; $j < $fragmentNamesBCount; $j++) {
                 $this->collectConflictsBetweenFieldsAndFragment(
-                  $context,
-                  $comparedFragments,
-                  $fieldMapA,
-                  $fragmentNamesB[$j],
-                  $areMutuallyExclusive
+                    $context,
+                    $comparedFragments,
+                    $fieldMapA,
+                    $fragmentNamesB[$j],
+                    $areMutuallyExclusive
                 );
             }
         }
@@ -387,11 +387,11 @@ 
             /** @noinspection ForeachInvariantsInspection */
             for ($i = 0; $i < $fragmentNamesACount; $i++) {
                 $this->collectConflictsBetweenFieldsAndFragment(
-                  $context,
-                  $comparedFragments,
-                  $fieldMapB,
-                  $fragmentNamesA[$i],
-                  $areMutuallyExclusive
+                    $context,
+                    $comparedFragments,
+                    $fieldMapB,
+                    $fragmentNamesA[$i],
+                    $areMutuallyExclusive
                 );
             }
         }
@@ -401,10 +401,10 @@ 
             /** @noinspection ForeachInvariantsInspection */
             for ($j = 0; $j < $fragmentNamesBCount; $j++) {
                 $this->collectConflictsBetweenFragments(
-                  $context,
-                  $fragmentNamesA[$i],
-                  $fragmentNamesB[$j],
-                  $areMutuallyExclusive
+                    $context,
+                    $fragmentNamesA[$i],
+                    $fragmentNamesB[$j],
+                    $areMutuallyExclusive
                 );
             }
         }
@@ -436,11 +436,11 @@ 
                 for ($i = 0; $i < $fieldsCount; $i++) {
                     for ($j = $i + 1; $j < $fieldsCount; $j++) {
                         $conflict = $this->findConflict(
-                          $responseName,
-                          $fields[$i],
-                          $fields[$j],
-                          // within one collection is never mutually exclusive
-                          false/* $areMutuallyExclusive */
+                            $responseName,
+                            $fields[$i],
+                            $fields[$j],
+                            // within one collection is never mutually exclusive
+                            false/* $areMutuallyExclusive */
                         );
 
                         if (null !== $conflict) {
@@ -467,10 +467,10 @@ 
      * @throws InvalidTypeException
      */
     protected function collectConflictsBetween(
-      ComparisonContext $context,
-      array $fieldMapA,
-      array $fieldMapB,
-      bool $parentFieldsAreMutuallyExclusive
+        ComparisonContext $context,
+        array $fieldMapA,
+        array $fieldMapB,
+        bool $parentFieldsAreMutuallyExclusive
     ): void {
         // A field map is a keyed collection, where each key represents a response
         // name and the value at that key is a list of all fields which provide that
@@ -488,10 +488,10 @@ 
                     /** @noinspection ForeachInvariantsInspection */
                     for ($j = 0; $j < $fieldsBCount; $j++) {
                         $conflict = $this->findConflict(
-                          $responseName,
-                          $fieldsA[$i],
-                          $fieldsB[$j],
-                          $parentFieldsAreMutuallyExclusive
+                            $responseName,
+                            $fieldsA[$i],
+                            $fieldsB[$j],
+                            $parentFieldsAreMutuallyExclusive
                         );
 
                         if (null !== $conflict) {
@@ -516,10 +516,10 @@ 
      * @throws InvalidTypeException
      */
     protected function findConflict(
-      string $responseName,
-      FieldContext $fieldA,
-      FieldContext $fieldB,
-      bool $parentFieldsAreMutuallyExclusive
+        string $responseName,
+        FieldContext $fieldA,
+        FieldContext $fieldB,
+        bool $parentFieldsAreMutuallyExclusive
     ): ?Conflict
     {
         $parentTypeA = $fieldA->getParentType();
@@ -551,21 +551,21 @@ 
 
             if ($nameA !== $nameB) {
                 return new Conflict(
-                  $responseName,
-                  sprintf('%s and %s are different fields', $nameA, $nameB),
-                  [$nodeA],
-                  [$nodeB]
+                    $responseName,
+                    sprintf('%s and %s are different fields', $nameA, $nameB),
+                    [$nodeA],
+                    [$nodeB]
                 );
             }
 
             // Two field calls must have the same arguments.
             if (!compareArguments($nodeA->getArguments(),
-              $nodeB->getArguments())) {
+                $nodeB->getArguments())) {
                 return new Conflict(
-                  $responseName,
-                  'they have differing arguments',
-                  [$nodeA],
-                  [$nodeB]
+                    $responseName,
+                    'they have differing arguments',
+                    [$nodeA],
+                    [$nodeB]
                 );
             }
         }
@@ -577,11 +577,11 @@ 
         if (null !== $typeA && null !== $typeB && compareTypes($typeA,
             $typeB)) {
             return new Conflict(
-              $responseName,
-              sprintf('they return conflicting types %s and %s', (string)$typeA,
+                $responseName,
+                sprintf('they return conflicting types %s and %s', (string)$typeA,
                 (string)$typeB),
-              [$nodeA],
-              [$nodeB]
+                [$nodeA],
+                [$nodeB]
             );
         }
 
@@ -593,15 +593,15 @@ 
 
         if (null !== $selectionSetA && null !== $selectionSetB) {
             $conflicts = $this->findConflictsBetweenSubSelectionSets(
-              getNamedType($typeA),
-              $selectionSetA,
-              getNamedType($typeB),
-              $selectionSetB,
-              $areMutuallyExclusive
+                getNamedType($typeA),
+                $selectionSetA,
+                getNamedType($typeB),
+                $selectionSetB,
+                $areMutuallyExclusive
             );
 
             return $this->subfieldConflicts($conflicts, $responseName, $nodeA,
-              $nodeB);
+                $nodeB);
         }
 
         return null;
@@ -620,7 +620,7 @@ 
      * @throws InvariantException
      */
     protected function getFieldsAndFragmentNames(
-      SelectionSetNode $selectionSet,
+        SelectionSetNode $selectionSet,
       ?NamedTypeInterface $parentType
     ): ComparisonContext {
         $cached = $this->cachedFieldsAndFragmentNames->get($selectionSet);
@@ -629,7 +629,7 @@ 
             $cached = new ComparisonContext();
 
             $this->collectFieldsAndFragmentNames($cached, $selectionSet,
-              $parentType);
+                $parentType);
 
             $this->cachedFieldsAndFragmentNames->set($selectionSet, $cached);
         }
@@ -648,7 +648,7 @@ 
      * @throws InvalidTypeException
      */
     protected function getReferencedFieldsAndFragmentNames(
-      FragmentDefinitionNode $fragment
+        FragmentDefinitionNode $fragment
     ): ComparisonContext {
         $cached = $this->cachedFieldsAndFragmentNames->get($fragment);
 
@@ -658,10 +658,10 @@ 
 
         /** @var NamedTypeInterface $fragmentType */
         $fragmentType = typeFromAST($this->getValidationContext()->getSchema(),
-          $fragment->getTypeCondition());
+            $fragment->getTypeCondition());
 
         return $this->getFieldsAndFragmentNames($fragment->getSelectionSet(),
-          $fragmentType);
+            $fragmentType);
     }
 
     /**
@@ -673,8 +673,8 @@ 
      * @throws InvariantException
      */
     protected function collectFieldsAndFragmentNames(
-      ComparisonContext $context,
-      SelectionSetNode $selectionSet,
+        ComparisonContext $context,
+        SelectionSetNode $selectionSet,
       ?NamedTypeInterface $parentType
     ): void {
         foreach ($selectionSet->getSelections() as $selection) {
@@ -684,7 +684,7 @@ 
                   : null;
 
                 $context->registerField(new FieldContext($parentType,
-                  $selection, $definition));
+                    $selection, $definition));
             } elseif ($selection instanceof FragmentSpreadNode) {
                 $context->registerFragment($selection);
             } elseif ($selection instanceof InlineFragmentNode) {
@@ -696,7 +696,7 @@ 
                   : $parentType;
 
                 $this->collectFieldsAndFragmentNames($context,
-                  $selection->getSelectionSet(), $inlineFragmentType);
+                    $selection->getSelectionSet(), $inlineFragmentType);
             }
         }
     }
@@ -713,10 +713,10 @@ 
      * @return Conflict|null
      */
     protected function subfieldConflicts(
-      array $conflicts,
-      string $responseName,
-      FieldNode $nodeA,
-      FieldNode $nodeB
+        array $conflicts,
+        string $responseName,
+        FieldNode $nodeA,
+        FieldNode $nodeB
     ): ?Conflict
     {
         if (empty($conflicts)) {
@@ -724,16 +724,16 @@ 
         }
 
         return new Conflict(
-          $responseName,
-          array_map(function (Conflict $conflict) {
-              return [$conflict->getResponseName(), $conflict->getReason()];
-          }, $conflicts),
-          array_reduce($conflicts, function ($allFields, Conflict $conflict) {
-              return array_merge($allFields, $conflict->getFieldsA());
-          }, [$nodeA]),
-          array_reduce($conflicts, function ($allFields, Conflict $conflict) {
-              return array_merge($allFields, $conflict->getFieldsB());
-          }, [$nodeB])
+            $responseName,
+            array_map(function (Conflict $conflict) {
+                return [$conflict->getResponseName(), $conflict->getReason()];
+            }, $conflicts),
+            array_reduce($conflicts, function ($allFields, Conflict $conflict) {
+                return array_merge($allFields, $conflict->getFieldsA());
+            }, [$nodeA]),
+            array_reduce($conflicts, function ($allFields, Conflict $conflict) {
+                return array_merge($allFields, $conflict->getFieldsB());
+            }, [$nodeB])
         );
     }
 }

Spacing +3 added lines, -3 removed lines

@@ -725,13 +725,13 @@
 
         return new Conflict(
           $responseName,
-          array_map(function (Conflict $conflict) {
+          array_map(function(Conflict $conflict) {
               return [$conflict->getResponseName(), $conflict->getReason()];
           }, $conflicts),
-          array_reduce($conflicts, function ($allFields, Conflict $conflict) {
+          array_reduce($conflicts, function($allFields, Conflict $conflict) {
               return array_merge($allFields, $conflict->getFieldsA());
           }, [$nodeA]),
-          array_reduce($conflicts, function ($allFields, Conflict $conflict) {
+          array_reduce($conflicts, function($allFields, Conflict $conflict) {
               return array_merge($allFields, $conflict->getFieldsB());
           }, [$nodeB])
         );

src/Validation/Conflict/PairSet.php

Indentation +3 added lines, -3 removed lines

@@ -57,9 +57,9 @@
      * @param bool $areMutuallyExclusive
      */
     protected function addToData(
-      string $a,
-      string $b,
-      bool $areMutuallyExclusive
+        string $a,
+        string $b,
+        bool $areMutuallyExclusive
     ): void {
         $map = $this->data[$a] ?? [];
 

src/Validation/Conflict/Conflict.php

Indentation +4 added lines, -4 removed lines

@@ -34,10 +34,10 @@
      * @param array|null $fieldsB
      */
     public function __construct(
-      string $responseName,
-      $reason,
-      array $fieldsA,
-      array $fieldsB
+        string $responseName,
+        $reason,
+        array $fieldsA,
+        array $fieldsB
     ) {
         $this->responseName = $responseName;
         $this->reason = $reason;

src/Validation/Conflict/FieldContext.php

Indentation +1 added lines, -1 removed lines

@@ -33,7 +33,7 @@
      */
     public function __construct(
       ?CompositeTypeInterface $parentType,
-      FieldNode $node,
+        FieldNode $node,
       ?Field $definition = null
     ) {
         $this->parentType = $parentType;

src/Validation/messages.php

Indentation +96 added lines, -96 removed lines

@@ -23,18 +23,18 @@ 
  * @return string
  */
 function undefinedFieldMessage(
-  string $fieldName,
-  string $type,
-  array $suggestedTypeNames,
-  array $suggestedFieldNames
+    string $fieldName,
+    string $type,
+    array $suggestedTypeNames,
+    array $suggestedFieldNames
 ): string {
     $message = sprintf('Cannot query field "%s" on type "%s".', $fieldName,
-      $type);
+        $type);
     if (!empty($suggestedTypeNames)) {
         return $message . ' ' . sprintf(
             'Did you mean to use an inline fragment on %s?',
             quotedOrList($suggestedTypeNames)
-          );
+            );
     }
     if (!empty($suggestedFieldNames)) {
         return $message . ' ' . sprintf('Did you mean %s?',
@@ -51,7 +51,7 @@ 
 function inlineFragmentOnNonCompositeMessage(string $typeName): string
 {
     return sprintf('Fragment cannot condition on non composite type "%s".',
-      $typeName);
+        $typeName);
 }
 
 /**
@@ -61,11 +61,11 @@ 
  * @return string
  */
 function fragmentOnNonCompositeMessage(
-  string $fragmentName,
-  string $typeName
+    string $fragmentName,
+    string $typeName
 ): string {
     return sprintf('Fragment "%s" cannot condition on non composite type "%s".',
-      $fragmentName, $typeName);
+        $fragmentName, $typeName);
 }
 
 /**
@@ -77,13 +77,13 @@ 
  * @return string
  */
 function unknownArgumentMessage(
-  string $argumentName,
-  string $fieldName,
-  string $typeName,
-  array $suggestedArguments
+    string $argumentName,
+    string $fieldName,
+    string $typeName,
+    array $suggestedArguments
 ): string {
     $message = sprintf('Unknown argument "%s" on field "%s" of type "%s".',
-      $argumentName, $fieldName, $typeName);
+        $argumentName, $fieldName, $typeName);
     if (!empty($suggestedArguments)) {
         return $message . ' ' . sprintf('Did you mean %s',
             quotedOrList($suggestedArguments));
@@ -99,12 +99,12 @@ 
  * @return string
  */
 function unknownDirectiveArgumentMessage(
-  string $argumentName,
-  string $directiveName,
-  array $suggestedArguments
+    string $argumentName,
+    string $directiveName,
+    array $suggestedArguments
 ): string {
     $message = sprintf('Unknown argument "%s" on directive "@%s".',
-      $argumentName, $directiveName);
+        $argumentName, $directiveName);
     if (!empty($suggestedArguments)) {
         return $message . ' ' . sprintf('Did you mean %s',
             quotedOrList($suggestedArguments));
@@ -129,11 +129,11 @@ 
  * @return string
  */
 function misplacedDirectiveMessage(
-  string $directiveName,
-  string $location
+    string $directiveName,
+    string $location
 ): string {
     return sprintf('Directive "%s" may not be used on %s.', $directiveName,
-      $location);
+        $location);
 }
 
 /**
@@ -180,7 +180,7 @@ 
 {
     $via = !empty($spreadNames) ? ' via ' . implode(', ', $spreadNames) : '';
     return sprintf('Cannot spread fragment "%s" within itself%s.',
-      $fragmentName, $via);
+        $fragmentName, $via);
 }
 
 /**
@@ -190,7 +190,7 @@ 
  * @return string
  */
 function undefinedVariableMessage(
-  string $variableName,
+    string $variableName,
   ?string $operationName = null
 ): string {
     /** @noinspection IsEmptyFunctionUsageInspection */
@@ -217,7 +217,7 @@ 
  * @return string
  */
 function unusedVariableMessage(
-  string $variableName,
+    string $variableName,
   ?string $operationName = null
 ): string {
     /** @noinspection IsEmptyFunctionUsageInspection */
@@ -236,9 +236,9 @@ 
 function fieldsConflictMessage(string $responseName, $reason): string
 {
     return sprintf(
-      'Fields "%s" conflict because %s. Use different aliases on the fields to fetch both if this was intentional.',
-      $responseName,
-      conflictReasonMessage($reason)
+        'Fields "%s" conflict because %s. Use different aliases on the fields to fetch both if this was intentional.',
+        $responseName,
+        conflictReasonMessage($reason)
     );
 }
 
@@ -260,7 +260,7 @@ 
     return implode(' and ', array_map(function ($reason) {
         [$responseName, $subreason] = $reason;
         return sprintf('subfields "%s" conflict because %s', $responseName,
-          conflictReasonMessage($subreason));
+            conflictReasonMessage($subreason));
     }, $reason));
 }
 
@@ -272,15 +272,15 @@ 
  * @return string
  */
 function typeIncompatibleSpreadMessage(
-  string $fragmentName,
-  string $parentType,
-  string $fragmentType
+    string $fragmentName,
+    string $parentType,
+    string $fragmentType
 ): string {
     return sprintf(
-      'Fragment "%s" cannot be spread here as objects of type "%s" can never be of type "%s".',
-      $fragmentName,
-      $parentType,
-      $fragmentType
+        'Fragment "%s" cannot be spread here as objects of type "%s" can never be of type "%s".',
+        $fragmentName,
+        $parentType,
+        $fragmentType
     );
 }
 
@@ -291,13 +291,13 @@ 
  * @return string
  */
 function typeIncompatibleAnonymousSpreadMessage(
-  string $parentType,
-  string $fragmentType
+    string $parentType,
+    string $fragmentType
 ): string {
     return sprintf(
-      'Fragment cannot be spread here as objects of type "%s" can never be of type "%s".',
-      $parentType,
-      $fragmentType
+        'Fragment cannot be spread here as objects of type "%s" can never be of type "%s".',
+        $parentType,
+        $fragmentType
     );
 }
 
@@ -309,15 +309,15 @@ 
  * @return string
  */
 function missingFieldArgumentMessage(
-  string $fieldName,
-  string $argumentName,
-  string $typeName
+    string $fieldName,
+    string $argumentName,
+    string $typeName
 ): string {
     return sprintf(
-      'Field "%s" argument "%s" of type "%s" is required but not provided.',
-      $fieldName,
-      $argumentName,
-      $typeName
+        'Field "%s" argument "%s" of type "%s" is required but not provided.',
+        $fieldName,
+        $argumentName,
+        $typeName
     );
 }
 
@@ -329,15 +329,15 @@ 
  * @return string
  */
 function missingDirectiveArgumentMessage(
-  string $directiveName,
-  string $argumentName,
-  string $typeName
+    string $directiveName,
+    string $argumentName,
+    string $typeName
 ): string {
     return sprintf(
-      'Directive "%s" argument "%s" of type "%s" is required but not provided.',
-      $directiveName,
-      $argumentName,
-      $typeName
+        'Directive "%s" argument "%s" of type "%s" is required but not provided.',
+        $directiveName,
+        $argumentName,
+        $typeName
     );
 }
 
@@ -348,11 +348,11 @@ 
  * @return string
  */
 function noSubselectionAllowedMessage(
-  string $fieldName,
-  string $typeName
+    string $fieldName,
+    string $typeName
 ): string {
     return sprintf('Field "%s" must not have a selection since type "%s" has no subfields.',
-      $fieldName, $typeName);
+        $fieldName, $typeName);
 }
 
 /**
@@ -362,14 +362,14 @@ 
  * @return string
  */
 function requiresSubselectionMessage(
-  string $fieldName,
-  string $typeName
+    string $fieldName,
+    string $typeName
 ): string {
     return sprintf(
-      'Field "%s" of type "%s" must have a selection of subfields. Did you mean "%s { ... }"?',
-      $fieldName,
-      $typeName,
-      $fieldName
+        'Field "%s" of type "%s" must have a selection of subfields. Did you mean "%s { ... }"?',
+        $fieldName,
+        $typeName,
+        $fieldName
     );
 }
 
@@ -402,7 +402,7 @@ 
 function duplicateDirectiveMessage(string $directiveName): string
 {
     return sprintf('The directive "%s" can only be used once at this location.',
-      $directiveName);
+        $directiveName);
 }
 
 /**
@@ -433,7 +433,7 @@ 
 function duplicateOperationMessage(string $operationName): string
 {
     return sprintf('There can be only one operation named "%s".',
-      $operationName);
+        $operationName);
 }
 
 /**
@@ -453,11 +453,11 @@ 
  * @return string
  */
 function nonInputTypeOnVariableMessage(
-  string $variableName,
-  string $typeName
+    string $variableName,
+    string $typeName
 ): string {
     return sprintf('Variable "$%s" cannot be non-input type "%s".',
-      $variableName, $typeName);
+        $variableName, $typeName);
 }
 
 /**
@@ -468,15 +468,15 @@ 
  * @return string
  */
 function variableDefaultValueNotAllowedMessage(
-  string $variableName,
-  string $typeName,
-  string $guessedTypeName
+    string $variableName,
+    string $typeName,
+    string $guessedTypeName
 ): string {
     return sprintf(
-      'Variable "$%s" of type "%s" is required and will not use the default value. Perhaps you meant to use type "%s".',
-      $variableName,
-      $typeName,
-      $guessedTypeName
+        'Variable "$%s" of type "%s" is required and will not use the default value. Perhaps you meant to use type "%s".',
+        $variableName,
+        $typeName,
+        $guessedTypeName
     );
 }
 
@@ -488,15 +488,15 @@ 
  * @return string
  */
 function badVariablePositionMessage(
-  string $variableName,
-  string $typeName,
-  string $expectedTypeName
+    string $variableName,
+    string $typeName,
+    string $expectedTypeName
 ): string {
     return sprintf(
-      'Variable "$%s" of type "%s" used in position expecting type "%s".',
-      $variableName,
-      $typeName,
-      $expectedTypeName
+        'Variable "$%s" of type "%s" used in position expecting type "%s".',
+        $variableName,
+        $typeName,
+        $expectedTypeName
     );
 }
 
@@ -508,12 +508,12 @@ 
  * @return string
  */
 function badValueMessage(
-  string $typeName,
-  string $valueName,
+    string $typeName,
+    string $valueName,
   ?string $message = null
 ): string {
     return sprintf('Expected type %s, found %s%s', $typeName, $valueName,
-      null !== $message ? "; $message" : '.');
+        null !== $message ? "; $message" : '.');
 }
 
 /**
@@ -524,12 +524,12 @@ 
  * @return string
  */
 function requiredFieldMessage(
-  string $typeName,
-  string $fieldName,
-  string $fieldTypeName
+    string $typeName,
+    string $fieldName,
+    string $fieldTypeName
 ): string {
     return sprintf('Field %s.%s of required type %s was not provided.',
-      $typeName, $fieldName, $fieldTypeName);
+        $typeName, $fieldName, $fieldTypeName);
 }
 
 /**
@@ -540,14 +540,14 @@ 
  * @return string
  */
 function unknownFieldMessage(
-  string $typeName,
-  string $fieldName,
+    string $typeName,
+    string $fieldName,
   ?string $message = null
 ): string {
     return sprintf(
-      'Field %s is not defined by type %s%s',
-      $fieldName,
-      $typeName,
-      null !== $message ? "; $message" : '.'
+        'Field %s is not defined by type %s%s',
+        $fieldName,
+        $typeName,
+        null !== $message ? "; $message" : '.'
     );
 }

Spacing +1 added lines, -1 removed lines

@@ -257,7 +257,7 @@
         return conflictReasonMessage([$reason]);
     }
 
-    return implode(' and ', array_map(function ($reason) {
+    return implode(' and ', array_map(function($reason) {
         [$responseName, $subreason] = $reason;
         return sprintf('subfields "%s" conflict because %s', $responseName,
           conflictReasonMessage($subreason));

src/Util/TypeInfo.php

Indentation +11 added lines, -11 removed lines

@@ -74,7 +74,7 @@ 
      * @param callable|null $getFieldDefinitionFunction
      */
     public function __construct(
-      SchemaInterface $schema,
+        SchemaInterface $schema,
       ?callable $getFieldDefinitionFunction = null,
       ?TypeInterface $initialType = null
     ) {
@@ -85,9 +85,9 @@ 
             SchemaInterface $schema,
             TypeInterface $parentType,
             FieldNode $fieldNode
-          ) {
-              return getFieldDefinition($schema, $parentType, $fieldNode);
-          };
+            ) {
+                return getFieldDefinition($schema, $parentType, $fieldNode);
+            };
 
         if ($initialType instanceof InputTypeInterface) {
             $this->inputTypeStack[] = $initialType;
@@ -106,13 +106,13 @@ 
      * @return Field|null
      */
     public function resolveFieldDefinition(
-      SchemaInterface $schema,
-      TypeInterface $parentType,
-      FieldNode $fieldNode
+        SchemaInterface $schema,
+        TypeInterface $parentType,
+        FieldNode $fieldNode
     ): ?Field
     {
         return \call_user_func($this->getFieldDefinitionFunction, $schema,
-          $parentType, $fieldNode);
+            $parentType, $fieldNode);
     }
 
     /**
@@ -297,9 +297,9 @@ 
  * @throws InvalidTypeException
  */
 function getFieldDefinition(
-  SchemaInterface $schema,
-  TypeInterface $parentType,
-  FieldNode $fieldNode
+    SchemaInterface $schema,
+    TypeInterface $parentType,
+    FieldNode $fieldNode
 ): ?Field
 {
     $name = $fieldNode->getNameValue();

Spacing +1 added lines, -1 removed lines

@@ -81,7 +81,7 @@
         $this->schema = $schema;
         $this->getFieldDefinitionFunction = null !== $getFieldDefinitionFunction
           ? $getFieldDefinitionFunction
-          : function (
+          : function(
             SchemaInterface $schema,
             TypeInterface $parentType,
             FieldNode $fieldNode

src/Util/TypeHelper.php

Indentation +19 added lines, -19 removed lines

@@ -29,8 +29,8 @@ 
      * @return bool
      */
     public function isEqualType(
-      TypeInterface $typeA,
-      TypeInterface $typeB
+        TypeInterface $typeA,
+        TypeInterface $typeB
     ): bool {
         // Equivalent types are equal.
         if ($typeA === $typeB) {
@@ -62,9 +62,9 @@ 
      * @return bool
      */
     public function isTypeSubtypeOf(
-      SchemaInterface $schema,
-      TypeInterface $maybeSubtype,
-      TypeInterface $superType
+        SchemaInterface $schema,
+        TypeInterface $maybeSubtype,
+        TypeInterface $superType
     ): bool {
         // Equivalent type is a valid subtype.
         if ($maybeSubtype === $superType) {
@@ -75,7 +75,7 @@ 
         if ($superType instanceof NonNullType) {
             if ($maybeSubtype instanceof NonNullType) {
                 return $this->isTypeSubtypeOf($schema,
-                  $maybeSubtype->getOfType(), $superType->getOfType());
+                    $maybeSubtype->getOfType(), $superType->getOfType());
             }
             return false;
         }
@@ -83,14 +83,14 @@ 
         if ($maybeSubtype instanceof NonNullType) {
             // If superType is nullable, maybeSubType may be non-null or nullable.
             return $this->isTypeSubtypeOf($schema, $maybeSubtype->getOfType(),
-              $superType);
+                $superType);
         }
 
         // If superType type is a list, maybeSubType type must also be a list.
         if ($superType instanceof ListType) {
             if ($maybeSubtype instanceof ListType) {
                 return $this->isTypeSubtypeOf($schema,
-                  $maybeSubtype->getOfType(), $superType->getOfType());
+                    $maybeSubtype->getOfType(), $superType->getOfType());
             }
             return false;
         }
@@ -127,9 +127,9 @@ 
      * @return bool
      */
     public function doTypesOverlap(
-      SchemaInterface $schema,
-      TypeInterface $typeA,
-      TypeInterface $typeB
+        SchemaInterface $schema,
+        TypeInterface $typeA,
+        TypeInterface $typeB
     ): bool {
         // Equivalent types overlap
         if ($typeA === $typeB) {
@@ -141,9 +141,9 @@ 
                 // If both types are abstract, then determine if there is any intersection
                 // between possible concrete types of each.
                 return arraySome($schema->getPossibleTypes($typeA),
-                  function (TypeInterface $type) use ($schema, $typeB) {
-                      return $schema->isPossibleType($typeB, $type);
-                  });
+                    function (TypeInterface $type) use ($schema, $typeB) {
+                        return $schema->isPossibleType($typeB, $type);
+                    });
             }
 
             // Determine if the latter type is a possible concrete type of the former.
@@ -173,8 +173,8 @@ 
      * @return bool
      */
     public function compareTypes(
-      TypeInterface $typeA,
-      TypeInterface $typeB
+        TypeInterface $typeA,
+        TypeInterface $typeB
     ): bool {
         if ($typeA instanceof ListType) {
             return $typeB instanceof ListType
@@ -212,8 +212,8 @@ 
      * @throws InvalidTypeException
      */
     public function fromAST(
-      SchemaInterface $schema,
-      TypeNodeInterface $typeNode
+        SchemaInterface $schema,
+        TypeNodeInterface $typeNode
     ): ?TypeInterface
     {
         $innerType = null;
@@ -233,6 +233,6 @@ 
         }
 
         throw new InvalidTypeException(sprintf('Unexpected type kind: %s',
-          $typeNode->getKind()));
+            $typeNode->getKind()));
     }
 }

Spacing +1 added lines, -1 removed lines

@@ -141,7 +141,7 @@
                 // If both types are abstract, then determine if there is any intersection
                 // between possible concrete types of each.
                 return arraySome($schema->getPossibleTypes($typeA),
-                  function (TypeInterface $type) use ($schema, $typeB) {
+                  function(TypeInterface $type) use ($schema, $typeB) {
                       return $schema->isPossibleType($typeB, $type);
                   });
             }

src/Util/ValueHelper.php

Indentation +31 added lines, -31 removed lines

@@ -39,19 +39,19 @@ 
         }
 
         return arrayEvery($argumentsA,
-          function (ArgumentNode $argumentA) use ($argumentsB) {
-              $argumentB = find($argumentsB,
+            function (ArgumentNode $argumentA) use ($argumentsB) {
+                $argumentB = find($argumentsB,
                 function (ArgumentNode $argument) use ($argumentA) {
                     return $argument->getNameValue() === $argumentA->getNameValue();
                 });
 
-              if (null === $argumentB) {
-                  return false;
-              }
+                if (null === $argumentB) {
+                    return false;
+                }
 
-              return $this->compareValues($argumentA->getValue(),
+                return $this->compareValues($argumentA->getValue(),
                 $argumentB->getValue());
-          });
+            });
     }
 
     /**
@@ -95,8 +95,8 @@ 
      */
     public function fromAST(
       ?NodeInterface $node,
-      TypeInterface $type,
-      array $variables = []
+        TypeInterface $type,
+        array $variables = []
     ) {
         if (null === $node) {
             throw new ResolutionException('Node is not defined.');
@@ -116,7 +116,7 @@ 
 
             if (!isset($variables[$variableName])) {
                 throw new ResolutionException(
-                  \sprintf('Cannot resolve value for missing variable "%s".',
+                    \sprintf('Cannot resolve value for missing variable "%s".',
                     $variableName)
                 );
             }
@@ -157,9 +157,9 @@ 
      * @throws ResolutionException
      */
     protected function resolveNonNullType(
-      NodeInterface $node,
-      NonNullType $type,
-      array $variables = []
+        NodeInterface $node,
+        NonNullType $type,
+        array $variables = []
     ) {
         if ($node instanceof NullValueNode) {
             throw new ResolutionException('Cannot resolve non-null values from null value node.');
@@ -178,9 +178,9 @@ 
      * @throws ResolutionException
      */
     protected function resolveListType(
-      NodeInterface $node,
-      ListType $type,
-      array $variables = []
+        NodeInterface $node,
+        ListType $type,
+        array $variables = []
     ) {
         $itemType = $type->getOfType();
 
@@ -198,7 +198,7 @@ 
                     $resolvedValues[] = null;
                 } else {
                     $resolvedValues[] = $this->fromAST($value, $itemType,
-                      $variables);
+                        $variables);
                 }
             }
 
@@ -215,8 +215,8 @@ 
      * @return bool
      */
     protected function isMissingVariable(
-      ValueNodeInterface $node,
-      array $variables
+        ValueNodeInterface $node,
+        array $variables
     ): bool {
         return $node instanceof VariableNode && !isset($variables[$node->getNameValue()]);
     }
@@ -232,9 +232,9 @@ 
      * @throws ResolutionException
      */
     protected function resolveInputObjectType(
-      NodeInterface $node,
-      InputObjectType $type,
-      array $variables = []
+        NodeInterface $node,
+        InputObjectType $type,
+        array $variables = []
     ) {
         if (!$node instanceof ObjectValueNode) {
             throw new ResolutionException('Input object values can only be resolved form object value nodes.');
@@ -244,9 +244,9 @@ 
 
         /** @var ObjectFieldNode[] $fieldNodes */
         $fieldNodes = keyMap($node->getFields(),
-          function (ObjectFieldNode $value) {
-              return $value->getNameValue();
-          });
+            function (ObjectFieldNode $value) {
+                return $value->getNameValue();
+            });
 
         foreach ($type->getFields() as $field) {
             $name = $field->getName();
@@ -263,7 +263,7 @@ 
             }
 
             $fieldValue = $this->fromAST($fieldNode->getValue(),
-              $field->getType(), $variables);
+                $field->getType(), $variables);
 
             $resolvedValues[$name] = $fieldValue;
         }
@@ -291,7 +291,7 @@ 
 
         if (null === $enumValue) {
             throw new ResolutionException(\sprintf('Cannot resolve enum value for missing value "%s".',
-              $name));
+                $name));
         }
 
         return $enumValue->getValue();
@@ -306,9 +306,9 @@ 
      * @throws ResolutionException
      */
     protected function resolveScalarType(
-      NodeInterface $node,
-      ScalarType $type,
-      array $variables = []
+        NodeInterface $node,
+        ScalarType $type,
+        array $variables = []
     ) {
         // Scalars fulfill parsing a literal value via parseLiteral().
         // Invalid values represent a failure to parse correctly, in which case
@@ -323,7 +323,7 @@ 
 
         if (null === $result) {
             throw new ResolutionException(\sprintf('Failed to parse literal for scalar type "%s".',
-              (string)$type));
+                (string)$type));
         }
 
         return $result;

Spacing +3 added lines, -3 removed lines

@@ -39,9 +39,9 @@ 
         }
 
         return arrayEvery($argumentsA,
-          function (ArgumentNode $argumentA) use ($argumentsB) {
+          function(ArgumentNode $argumentA) use ($argumentsB) {
               $argumentB = find($argumentsB,
-                function (ArgumentNode $argument) use ($argumentA) {
+                function(ArgumentNode $argument) use ($argumentA) {
                     return $argument->getNameValue() === $argumentA->getNameValue();
                 });
 
@@ -244,7 +244,7 @@ 
 
         /** @var ObjectFieldNode[] $fieldNodes */
         $fieldNodes = keyMap($node->getFields(),
-          function (ObjectFieldNode $value) {
+          function(ObjectFieldNode $value) {
               return $value->getNameValue();
           });