digiaonline / graphql-php

src/Validation/Rule/ProvidedNonNullArgumentsRule.php

Indentation +16 added lines, -16 removed lines

@@ -36,9 +36,9 @@ 
 
         $argumentNodes = $node->getArguments();
         $argumentNodeMap = keyMap($argumentNodes,
-          function (ArgumentNode $argument) {
-              return $argument->getNameValue();
-          });
+            function (ArgumentNode $argument) {
+                return $argument->getNameValue();
+            });
 
         foreach ($fieldDefinition->getArguments() as $argumentDefinition) {
             $argumentNode = $argumentNodeMap[$argumentDefinition->getName()] ?? null;
@@ -46,14 +46,14 @@ 
 
             if (null === $argumentNode && $argumentType instanceof NonNullType) {
                 $this->context->reportError(
-                  new ValidationException(
+                    new ValidationException(
                     missingFieldArgumentMessage(
-                      (string)$node,
-                      (string)$argumentDefinition,
-                      (string)$argumentType
+                        (string)$node,
+                        (string)$argumentDefinition,
+                        (string)$argumentType
                     ),
                     [$node]
-                  )
+                    )
                 );
             }
         }
@@ -74,9 +74,9 @@ 
 
         $argumentNodes = $node->getArguments();
         $argumentNodeMap = keyMap($argumentNodes,
-          function (ArgumentNode $argument) {
-              return $argument->getNameValue();
-          });
+            function (ArgumentNode $argument) {
+                return $argument->getNameValue();
+            });
 
         foreach ($directiveDefinition->getArguments() as $argumentDefinition) {
             $argumentNode = $argumentNodeMap[$argumentDefinition->getName()] ?? null;
@@ -84,14 +84,14 @@ 
 
             if (null === $argumentNode && $argumentType instanceof NonNullType) {
                 $this->context->reportError(
-                  new ValidationException(
+                    new ValidationException(
                     missingDirectiveArgumentMessage(
-                      (string)$node,
-                      (string)$argumentDefinition,
-                      (string)$argumentType
+                        (string)$node,
+                        (string)$argumentDefinition,
+                        (string)$argumentType
                     ),
                     [$node]
-                  )
+                    )
                 );
             }
         }

Spacing +2 added lines, -2 removed lines

@@ -36,7 +36,7 @@ 
 
         $argumentNodes = $node->getArguments();
         $argumentNodeMap = keyMap($argumentNodes,
-          function (ArgumentNode $argument) {
+          function(ArgumentNode $argument) {
               return $argument->getNameValue();
           });
 
@@ -74,7 +74,7 @@ 
 
         $argumentNodes = $node->getArguments();
         $argumentNodeMap = keyMap($argumentNodes,
-          function (ArgumentNode $argument) {
+          function(ArgumentNode $argument) {
               return $argument->getNameValue();
           });
 

src/Validation/Rule/PossibleFragmentSpreadsRule.php

Indentation +7 added lines, -7 removed lines

@@ -38,11 +38,11 @@ 
           !doTypesOverlap($this->context->getSchema(),
             $fragmentType, $parentType)) {
             $this->context->reportError(
-              new ValidationException(
+                new ValidationException(
                 typeIncompatibleAnonymousSpreadMessage($parentType,
-                  $fragmentType),
+                    $fragmentType),
                 [$node]
-              )
+                )
             );
         }
 
@@ -64,11 +64,11 @@ 
           !doTypesOverlap($this->context->getSchema(),
             $fragmentType, $parentType)) {
             $this->context->reportError(
-              new ValidationException(
+                new ValidationException(
                 typeIncompatibleSpreadMessage($fragmentName, $parentType,
-                  $fragmentType),
+                    $fragmentType),
                 [$node]
-              )
+                )
             );
         }
 
@@ -90,7 +90,7 @@ 
         }
 
         $type = typeFromAST($this->context->getSchema(),
-          $fragment->getTypeCondition());
+            $fragment->getTypeCondition());
 
         return $type instanceof CompositeTypeInterface ? $type : null;
     }

src/Validation/Rule/KnownDirectivesRule.php

Indentation +6 added lines, -6 removed lines

@@ -49,15 +49,15 @@ 
     {
         /** @var Directive $directiveDefinition */
         $directiveDefinition = find(
-          $this->context->getSchema()->getDirectives(),
-          function (Directive $definition) use ($node) {
-              return $definition->getName() === $node->getNameValue();
-          }
+            $this->context->getSchema()->getDirectives(),
+            function (Directive $definition) use ($node) {
+                return $definition->getName() === $node->getNameValue();
+            }
         );
 
         if (null == $directiveDefinition) {
             $this->context->reportError(
-              new ValidationException(unknownDirectiveMessage((string)$node),
+                new ValidationException(unknownDirectiveMessage((string)$node),
                 [$node])
             );
 
@@ -69,7 +69,7 @@ 
         if (null !== $location && !\in_array($location,
             $directiveDefinition->getLocations())) {
             $this->context->reportError(
-              new ValidationException(misplacedDirectiveMessage((string)$node,
+                new ValidationException(misplacedDirectiveMessage((string)$node,
                 $location), [$node])
             );
         }

Spacing +1 added lines, -1 removed lines

@@ -50,7 +50,7 @@
         /** @var Directive $directiveDefinition */
         $directiveDefinition = find(
           $this->context->getSchema()->getDirectives(),
-          function (Directive $definition) use ($node) {
+          function(Directive $definition) use ($node) {
               return $definition->getName() === $node->getNameValue();
           }
         );

src/Validation/Rule/SupportedRules.php

Indentation +25 added lines, -25 removed lines

@@ -11,31 +11,31 @@
      * @var array
      */
     private static $supportedRules = [
-      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,
     ];
 
     /**

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));