digiaonline / graphql-php

src/Execution/ValuesHelper.php

Spacing +4 added lines, -4 removed lines

@@ -57,7 +57,7 @@ 
             return $coercedValues;
         }
 
-        $argumentNodeMap = keyMap($argumentNodes, function (ArgumentNode $value) {
+        $argumentNodeMap = keyMap($argumentNodes, function(ArgumentNode $value) {
             return $value->getNameValue();
         });
 
@@ -130,7 +130,7 @@ 
         array $variableValues = []
     ): ?array {
         $directiveNode = $node->hasDirectives()
-            ? find($node->getDirectives(), function (NameAwareInterface $value) use ($directive) {
+            ? find($node->getDirectives(), function(NameAwareInterface $value) use ($directive) {
                 return $value->getNameValue() === $directive->getName();
             }) : null;
 
@@ -330,7 +330,7 @@ 
                 ]);
             }
             return new CoercedValue($parseResult, null);
-        } catch (InvalidTypeException|CoercingException $ex) {
+        } catch (InvalidTypeException | CoercingException $ex) {
             return new CoercedValue(null, [
                 $this->buildCoerceException(
                     sprintf('Expected type %s', (string)$type),
@@ -361,7 +361,7 @@ 
             return new CoercedValue($enumValue, null);
         }
 
-        $suggestions = suggestionList((string)$value, \array_map(function (EnumValue $enumValue) {
+        $suggestions = suggestionList((string)$value, \array_map(function(EnumValue $enumValue) {
             return $enumValue->getName();
         }, $type->getValues()));
 

src/Language/Node/SchemaExtensionNode.php

Spacing +1 added lines, -1 removed lines

@@ -41,7 +41,7 @@
      */
     public function getOperationTypesAST(): array
     {
-        return \array_map(function (OperationTypeDefinitionNode $node) {
+        return \array_map(function(OperationTypeDefinitionNode $node) {
             return $node->toAST();
         }, $this->operationTypes);
     }

src/Language/Parser.php

Spacing +10 added lines, -10 removed lines

@@ -322,7 +322,7 @@ 
         /**
          * @return TypeNodeInterface
          */
-        $parseType = function (): TypeNodeInterface {
+        $parseType = function(): TypeNodeInterface {
             $this->expect(TokenKindEnum::COLON);
             return $this->lexType();
         };
@@ -433,7 +433,7 @@ 
         /**
          * @return ArgumentNode
          */
-        $parseFunction = function () use ($isConst): ArgumentNode {
+        $parseFunction = function() use ($isConst) : ArgumentNode {
             return $this->lexArgument($isConst);
         };
 
@@ -460,7 +460,7 @@ 
         /**
          * @return NodeInterface|TypeNodeInterface|ValueNodeInterface
          */
-        $parseValue = function () use ($isConst): NodeInterface {
+        $parseValue = function() use ($isConst): NodeInterface {
             $this->expect(TokenKindEnum::COLON);
             return $this->lexValue($isConst);
         };
@@ -529,7 +529,7 @@ 
 
         $this->expectKeyword(KeywordEnum::FRAGMENT);
 
-        $parseTypeCondition = function () {
+        $parseTypeCondition = function() {
             $this->expectKeyword(KeywordEnum::ON);
             return $this->lexNamedType();
         };
@@ -659,7 +659,7 @@ 
     {
         $start = $this->lexer->getToken();
 
-        $parseFunction = function () use ($isConst) {
+        $parseFunction = function() use ($isConst) {
             return $this->lexValue($isConst);
         };
 
@@ -712,7 +712,7 @@ 
          * @param bool $isConst
          * @return NodeInterface|TypeNodeInterface|ValueNodeInterface
          */
-        $parseValue = function (bool $isConst): NodeInterface {
+        $parseValue = function(bool $isConst): NodeInterface {
             $this->expect(TokenKindEnum::COLON);
             return $this->lexValue($isConst);
         };
@@ -1053,7 +1053,7 @@ 
      */
     protected function lexArgumentsDefinition(): array
     {
-        $parseFunction = function (): InputValueDefinitionNode {
+        $parseFunction = function(): InputValueDefinitionNode {
             return $this->lexInputValueDefinition();
         };
 
@@ -1259,7 +1259,7 @@ 
      */
     protected function lexInputFieldsDefinition(): array
     {
-        $parseFunction = function (): InputValueDefinitionNode {
+        $parseFunction = function(): InputValueDefinitionNode {
             return $this->lexInputValueDefinition();
         };
 
@@ -1327,7 +1327,7 @@ 
 
         $directives = $this->lexDirectives(true);
 
-        $parseFunction = function (): OperationTypeDefinitionNode {
+        $parseFunction = function(): OperationTypeDefinitionNode {
             return $this->lexOperationTypeDefinition();
         };
 
@@ -1601,7 +1601,7 @@ 
 
         $name = $this->lexName();
 
-        if (arraySome(DirectiveLocationEnum::values(), function ($value) use ($name) {
+        if (arraySome(DirectiveLocationEnum::values(), function($value) use ($name) {
             return $name->getValue() === $value;
         })) {
             return $name;

src/Schema/DefinitionBuilder.php

Spacing +19 added lines, -19 removed lines

@@ -107,7 +107,7 @@ 
      */
     public function buildTypes(array $nodes): array
     {
-        return \array_map(function (NamedTypeNodeInterface $node) {
+        return \array_map(function(NamedTypeNodeInterface $node) {
             return $this->buildType($node);
         }, $nodes);
     }
@@ -153,7 +153,7 @@ 
         $directive = newDirective([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'locations'   => \array_map(function (NameNode $node) {
+            'locations'   => \array_map(function(NameNode $node) {
                 return $node->getValue();
             }, $node->getLocations()),
             'args'        => $node->hasArguments() ? $this->buildArguments($node->getArguments()) : [],
@@ -221,7 +221,7 @@ 
     {
         $typesMap = keyMap(
             \array_merge($customTypes, specifiedScalarTypes(), introspectionTypes()),
-            function (NamedTypeInterface $type) {
+            function(NamedTypeInterface $type) {
                 return $type->getName();
             }
         );
@@ -238,7 +238,7 @@ 
     {
         $directivesMap = keyMap(
             \array_merge($customDirectives, specifiedDirectives()),
-            function (Directive $directive) {
+            function(Directive $directive) {
                 return $directive->getName();
             }
         );
@@ -257,10 +257,10 @@ 
     {
         return keyValueMap(
             $nodes,
-            function (InputValueDefinitionNode $value) {
+            function(InputValueDefinitionNode $value) {
                 return $value->getNameValue();
             },
-            function (InputValueDefinitionNode $value): array {
+            function(InputValueDefinitionNode $value): array {
                 $type         = $this->buildWrappedType($value->getType());
                 $defaultValue = $value->getDefaultValue();
                 return [
@@ -314,14 +314,14 @@ 
         return newObjectType([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'fields'      => $node->hasFields() ? function () use ($node) {
+            'fields'      => $node->hasFields() ? function() use ($node) {
                 return $this->buildFields($node);
             } : [],
             // Note: While this could make early assertions to get the correctly
             // typed values, that would throw immediately while type system
             // validation with validateSchema() will produce more actionable results.
-            'interfaces'  => function () use ($node) {
-                return $node->hasInterfaces() ? \array_map(function (NamedTypeNodeInterface $interface) {
+            'interfaces'  => function() use ($node) {
+                return $node->hasInterfaces() ? \array_map(function(NamedTypeNodeInterface $interface) {
                     return $this->buildType($interface);
                 }, $node->getInterfaces()) : [];
             },
@@ -337,11 +337,11 @@ 
     {
         return keyValueMap(
             $node->getFields(),
-            function ($value) {
+            function($value) {
                 /** @var FieldDefinitionNode|InputValueDefinitionNode $value */
                 return $value->getNameValue();
             },
-            function ($value) use ($node) {
+            function($value) use ($node) {
                 /** @var FieldDefinitionNode|InputValueDefinitionNode $value */
                 return $this->buildField($value,
                     $this->getFieldResolver($node->getNameValue(), $value->getNameValue()));
@@ -371,7 +371,7 @@ 
         return newInterfaceType([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'fields'      => $node->hasFields() ? function () use ($node): array {
+            'fields'      => $node->hasFields() ? function() use ($node) : array {
                 return $this->buildFields($node);
             } : [],
             'resolveType' => $this->getTypeResolver($node->getNameValue()),
@@ -391,10 +391,10 @@ 
             'description' => $node->getDescriptionValue(),
             'values'      => $node->hasValues() ? keyValueMap(
                 $node->getValues(),
-                function (EnumValueDefinitionNode $value): ?string {
+                function(EnumValueDefinitionNode $value): ?string {
                     return $value->getNameValue();
                 },
-                function (EnumValueDefinitionNode $value): array {
+                function(EnumValueDefinitionNode $value): array {
                     return [
                         'description'       => $value->getDescriptionValue(),
                         'deprecationReason' => $this->getDeprecationReason($value),
@@ -416,7 +416,7 @@ 
         return newUnionType([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'types'       => $node->hasTypes() ? \array_map(function (NamedTypeNodeInterface $type) {
+            'types'       => $node->hasTypes() ? \array_map(function(NamedTypeNodeInterface $type) {
                 return $this->buildType($type);
             }, $node->getTypes()) : [],
             'resolveType' => $this->getTypeResolver($node->getNameValue()),
@@ -445,7 +445,7 @@ 
         return newScalarType([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'serialize'   => function ($value) {
+            'serialize'   => function($value) {
                 return $value;
             },
             'astNode'     => $node,
@@ -462,13 +462,13 @@ 
         return newInputObjectType([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'fields'      => $node->hasFields() ? function () use ($node) {
+            'fields'      => $node->hasFields() ? function() use ($node) {
                 return keyValueMap(
                     $node->getFields(),
-                    function (InputValueDefinitionNode $value): ?string {
+                    function(InputValueDefinitionNode $value): ?string {
                         return $value->getNameValue();
                     },
-                    function (InputValueDefinitionNode $value): array {
+                    function(InputValueDefinitionNode $value): array {
                         $type         = $this->buildWrappedType($value->getType());
                         $defaultValue = $value->getDefaultValue();
                         return [

src/Schema/Building/BuildingContext.php

Spacing +3 added lines, -3 removed lines

@@ -77,7 +77,7 @@ 
      */
     public function buildTypes(): array
     {
-        return \array_map(function (NamedTypeNodeInterface $definition) {
+        return \array_map(function(NamedTypeNodeInterface $definition) {
             return $this->definitionBuilder->buildType($definition);
         }, \array_values($this->info->getTypeDefinitionMap()));
     }
@@ -87,7 +87,7 @@ 
      */
     public function buildDirectives(): array
     {
-        $directives = \array_map(function (DirectiveDefinitionNode $definition) {
+        $directives = \array_map(function(DirectiveDefinitionNode $definition) {
             return $this->definitionBuilder->buildDirective($definition);
         }, $this->info->getDirectiveDefinitions());
 
@@ -98,7 +98,7 @@ 
         ];
 
         foreach ($specifiedDirectivesMap as $name => $directive) {
-            if (!arraySome($directives, function (Directive $directive) use ($name) {
+            if (!arraySome($directives, function(Directive $directive) use ($name) {
                 return $directive->getName() === $name;
             })) {
                 $directives[] = $directive;

src/Execution/Executor.php

Spacing +10 added lines, -10 removed lines

@@ -170,7 +170,7 @@ 
 
         $promise = new FulfilledPromise([]);
 
-        $resolve = function ($results, $fieldName, $path, $objectType, $rootValue, $fieldNodes) {
+        $resolve = function($results, $fieldName, $path, $objectType, $rootValue, $fieldNodes) {
             $fieldPath   = $path;
             $fieldPath[] = $fieldName;
             try {
@@ -181,7 +181,7 @@ 
 
             if ($this->isPromise($result)) {
                 /** @var ExtendedPromiseInterface $result */
-                return $result->then(function ($resolvedResult) use ($fieldName, $results) {
+                return $result->then(function($resolvedResult) use ($fieldName, $results) {
                     $results[$fieldName] = $resolvedResult;
                     return $results;
                 });
@@ -193,7 +193,7 @@ 
         };
 
         foreach ($fields as $fieldName => $fieldNodes) {
-            $promise = $promise->then(function ($resolvedResults) use (
+            $promise = $promise->then(function($resolvedResults) use (
                 $resolve,
                 $fieldName,
                 $path,
@@ -205,9 +205,9 @@ 
             });
         }
 
-        $promise->then(function ($resolvedResults) use (&$finalResults) {
+        $promise->then(function($resolvedResults) use (&$finalResults) {
             $finalResults = $resolvedResults ?? [];
-        })->otherwise(function ($ex) {
+        })->otherwise(function($ex) {
             $this->context->addError($ex);
         });
 
@@ -284,7 +284,7 @@ 
             if ($this->isPromise($completed)) {
                 $context = $this->context;
                 /** @var ExtendedPromiseInterface $completed */
-                return $completed->then(null, function ($error) use ($context, $fieldNodes, $path) {
+                return $completed->then(null, function($error) use ($context, $fieldNodes, $path) {
                     //@TODO Handle $error better
                     if ($error instanceof \Exception) {
                         $context->addError($this->buildLocatedError($error, $fieldNodes, $path));
@@ -378,7 +378,7 @@ 
             $keys    = \array_keys($finalResults);
             $promise = promiseAll(\array_values($finalResults));
 
-            $promise->then(function ($values) use ($keys, &$finalResults) {
+            $promise->then(function($values) use ($keys, &$finalResults) {
                 /** @noinspection ForeachSourceInspection */
                 foreach ($values as $i => $value) {
                     $finalResults[$keys[$i]] = $value;
@@ -476,7 +476,7 @@ 
     ) {
         if ($this->isPromise($result)) {
             /** @var ExtendedPromiseInterface $result */
-            return $result->then(function (&$value) use ($returnType, $fieldNodes, $info, $path) {
+            return $result->then(function(&$value) use ($returnType, $fieldNodes, $info, $path) {
                 return $this->completeValue($returnType, $fieldNodes, $info, $path, $value);
             });
         }
@@ -564,7 +564,7 @@ 
 
         if ($this->isPromise($runtimeType)) {
             /** @var ExtendedPromiseInterface $runtimeType */
-            return $runtimeType->then(function ($resolvedRuntimeType) use (
+            return $runtimeType->then(function($resolvedRuntimeType) use (
                 $returnType,
                 $fieldNodes,
                 $info,
@@ -692,7 +692,7 @@ 
 
         if (!empty($promisedIsTypeOfResults)) {
             return promiseAll($promisedIsTypeOfResults)
-                ->then(function ($isTypeOfResults) use ($possibleTypes) {
+                ->then(function($isTypeOfResults) use ($possibleTypes) {
                     /** @noinspection ForeachSourceInspection */
                     foreach ($isTypeOfResults as $index => $result) {
                         if ($result) {

src/Type/ScalarTypesProvider.php

Spacing +20 added lines, -20 removed lines

@@ -34,17 +34,17 @@ 
     public function register()
     {
         $this->container
-            ->share(GraphQL::BOOLEAN, function (BooleanCoercer $coercer) {
+            ->share(GraphQL::BOOLEAN, function(BooleanCoercer $coercer) {
                 return newScalarType([
                     'name'         => TypeNameEnum::BOOLEAN,
                     'description'  => 'The `Boolean` scalar type represents `true` or `false`.',
-                    'serialize'    => function ($value) use ($coercer) {
+                    'serialize'    => function($value) use ($coercer) {
                         return $coercer->coerce($value);
                     },
-                    'parseValue'   => function ($value) use ($coercer) {
+                    'parseValue'   => function($value) use ($coercer) {
                         return $coercer->coerce($value);
                     },
-                    'parseLiteral' => function (NodeInterface $node) {
+                    'parseLiteral' => function(NodeInterface $node) {
                         if ($node instanceof BooleanValueNode) {
                             return $node->getValue();
                         }
@@ -55,20 +55,20 @@ 
             ->addArgument(BooleanCoercer::class);
 
         $this->container
-            ->share(GraphQL::FLOAT, function (FloatCoercer $coercer) {
+            ->share(GraphQL::FLOAT, function(FloatCoercer $coercer) {
                 return newScalarType([
                     'name'         => TypeNameEnum::FLOAT,
                     'description'  =>
                         'The `Float` scalar type represents signed double-precision fractional ' .
                         'values as specified by ' .
                         '[IEEE 754](https://en.wikipedia.org/wiki/IEEE_754).',
-                    'serialize'    => function ($value) use ($coercer) {
+                    'serialize'    => function($value) use ($coercer) {
                         return $coercer->coerce($value);
                     },
-                    'parseValue'   => function ($value) use ($coercer) {
+                    'parseValue'   => function($value) use ($coercer) {
                         return $coercer->coerce($value);
                     },
-                    'parseLiteral' => function (NodeInterface $node) {
+                    'parseLiteral' => function(NodeInterface $node) {
                         if ($node instanceof FloatValueNode || $node instanceof IntValueNode) {
                             return $node->getValue();
                         }
@@ -79,19 +79,19 @@ 
             ->addArgument(FloatCoercer::class);
 
         $this->container
-            ->share(GraphQL::INT, function (IntCoercer $coercer) {
+            ->share(GraphQL::INT, function(IntCoercer $coercer) {
                 return newScalarType([
                     'name'         => TypeNameEnum::INT,
                     'description'  =>
                         'The `Int` scalar type represents non-fractional signed whole numeric ' .
                         'values. Int can represent values between -(2^31) and 2^31 - 1.',
-                    'serialize'    => function ($value) use ($coercer) {
+                    'serialize'    => function($value) use ($coercer) {
                         return $coercer->coerce($value);
                     },
-                    'parseValue'   => function ($value) use ($coercer) {
+                    'parseValue'   => function($value) use ($coercer) {
                         return $coercer->coerce($value);
                     },
-                    'parseLiteral' => function (NodeInterface $node) {
+                    'parseLiteral' => function(NodeInterface $node) {
                         if ($node instanceof IntValueNode) {
                             $value = (int)$node->getValue();
                             if ((string)$node->getValue() === (string)$value &&
@@ -106,7 +106,7 @@ 
             ->addArgument(IntCoercer::class);
 
         $this->container
-            ->share(GraphQL::ID, function (StringCoercer $coercer) {
+            ->share(GraphQL::ID, function(StringCoercer $coercer) {
                 return newScalarType([
                     'name'         => TypeNameEnum::ID,
                     'description'  =>
@@ -115,13 +115,13 @@ 
                         'response as a String; however, it is not intended to be human-readable. ' .
                         'When expected as an input type, any string (such as `"4"`) or integer ' .
                         '(such as `4`) input value will be accepted as an ID.',
-                    'serialize'    => function ($value) use ($coercer) {
+                    'serialize'    => function($value) use ($coercer) {
                         return $coercer->coerce($value);
                     },
-                    'parseValue'   => function ($value) use ($coercer) {
+                    'parseValue'   => function($value) use ($coercer) {
                         return $coercer->coerce($value);
                     },
-                    'parseLiteral' => function (NodeInterface $node) {
+                    'parseLiteral' => function(NodeInterface $node) {
                         if ($node instanceof StringValueNode || $node instanceof IntValueNode) {
                             return $node->getValue();
                         }
@@ -132,20 +132,20 @@ 
             ->addArgument(StringCoercer::class);
 
         $this->container
-            ->share(GraphQL::STRING, function (StringCoercer $coercer) {
+            ->share(GraphQL::STRING, function(StringCoercer $coercer) {
                 return newScalarType([
                     'name'         => TypeNameEnum::STRING,
                     'description'  =>
                         'The `String` scalar type represents textual data, represented as UTF-8 ' .
                         'character sequences. The String type is most often used by GraphQL to ' .
                         'represent free-form human-readable text.',
-                    'serialize'    => function ($value) use ($coercer) {
+                    'serialize'    => function($value) use ($coercer) {
                         return $coercer->coerce($value);
                     },
-                    'parseValue'   => function ($value) use ($coercer) {
+                    'parseValue'   => function($value) use ($coercer) {
                         return $coercer->coerce($value);
                     },
-                    'parseLiteral' => function (NodeInterface $node) {
+                    'parseLiteral' => function(NodeInterface $node) {
                         if ($node instanceof StringValueNode) {
                             return $node->getValue();
                         }

src/Type/IntrospectionProvider.php

Spacing +36 added lines, -36 removed lines

@@ -58,7 +58,7 @@ 
     protected function registerIntrospectionTypes()
     {
         $this->container
-            ->share(GraphQL::SCHEMA_INTROSPECTION, function () {
+            ->share(GraphQL::SCHEMA_INTROSPECTION, function() {
                 return newObjectType([
                     'name'            => GraphQL::SCHEMA_INTROSPECTION,
                     'isIntrospection' => true,
@@ -66,19 +66,19 @@ 
                         'A GraphQL Schema defines the capabilities of a GraphQL server. It ' .
                         'exposes all available types and directives on the server, as well as ' .
                         'the entry points for query, mutation, and subscription operations.',
-                    'fields'          => function () {
+                    'fields'          => function() {
                         return [
                             'types'            => [
                                 'description' => 'A list of all types supported by this server.',
                                 'type'        => newNonNull(newList(newNonNull(__Type()))),
-                                'resolve'     => function (Schema $schema): array {
+                                'resolve'     => function(Schema $schema): array {
                                     return \array_values($schema->getTypeMap());
                                 },
                             ],
                             'queryType'        => [
                                 'description' => 'The type that query operations will be rooted at.',
                                 'type'        => newNonNull(__Type()),
-                                'resolve'     => function (Schema $schema): ?TypeInterface {
+                                'resolve'     => function(Schema $schema): ?TypeInterface {
                                     return $schema->getQueryType();
                                 },
                             ],
@@ -87,7 +87,7 @@ 
                                     'If this server supports mutation, the type that ' .
                                     'mutation operations will be rooted at.',
                                 'type'        => __Type(),
-                                'resolve'     => function (Schema $schema): ?TypeInterface {
+                                'resolve'     => function(Schema $schema): ?TypeInterface {
                                     return $schema->getMutationType();
                                 },
                             ],
@@ -96,14 +96,14 @@ 
                                     'If this server support subscription, the type that ' .
                                     'subscription operations will be rooted at.',
                                 'type'        => __Type(),
-                                'resolve'     => function (Schema $schema): ?TypeInterface {
+                                'resolve'     => function(Schema $schema): ?TypeInterface {
                                     return $schema->getSubscriptionType();
                                 },
                             ],
                             'directives'       => [
                                 'description' => 'A list of all directives supported by this server.',
                                 'type'        => newNonNull(newList(newNonNull(__Directive()))),
-                                'resolve'     => function (Schema $schema): array {
+                                'resolve'     => function(Schema $schema): array {
                                     return $schema->getDirectives();
                                 },
                             ],
@@ -113,7 +113,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::DIRECTIVE_INTROSPECTION, function () {
+            ->share(GraphQL::DIRECTIVE_INTROSPECTION, function() {
                 return newObjectType([
                     'name'            => GraphQL::DIRECTIVE_INTROSPECTION,
                     'isIntrospection' => true,
@@ -124,7 +124,7 @@ 
                         'execution behavior in ways field arguments will not suffice, such as ' .
                         'conditionally including or skipping a field. Directives provide this by ' .
                         'describing additional information to the executor.',
-                    'fields'          => function () {
+                    'fields'          => function() {
                         return [
                             'name'        => ['type' => newNonNull(stringType())],
                             'description' => ['type' => stringType()],
@@ -133,7 +133,7 @@ 
                             ],
                             'args'        => [
                                 'type'    => newNonNull(newList(newNonNull(__InputValue()))),
-                                'resolve' => function (Directive $directive): array {
+                                'resolve' => function(Directive $directive): array {
                                     return $directive->getArguments() ?: [];
                                 },
                             ],
@@ -143,7 +143,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::DIRECTIVE_LOCATION_INTROSPECTION, function () {
+            ->share(GraphQL::DIRECTIVE_LOCATION_INTROSPECTION, function() {
                 return newEnumType([
                     'name'            => GraphQL::DIRECTIVE_LOCATION_INTROSPECTION,
                     'isIntrospection' => true,
@@ -210,7 +210,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::TYPE_INTROSPECTION, function () {
+            ->share(GraphQL::TYPE_INTROSPECTION, function() {
                 return newObjectType([
                     'name'            => GraphQL::TYPE_INTROSPECTION,
                     'isIntrospection' => true,
@@ -223,11 +223,11 @@ 
                         'Object and Interface types provide the fields they describe. Abstract ' .
                         'types, Union and Interface, provide the Object types possible ' .
                         'at runtime. List and NonNull types compose other types.',
-                    'fields'          => function () {
+                    'fields'          => function() {
                         return [
                             'kind'          => [
                                 'type'    => newNonNull(__TypeKind()),
-                                'resolve' => function (TypeInterface $type) {
+                                'resolve' => function(TypeInterface $type) {
                                     if ($type instanceof ScalarType) {
                                         return TypeKindEnum::SCALAR;
                                     }
@@ -263,7 +263,7 @@ 
                                 'args'    => [
                                     'includeDeprecated' => ['type' => booleanType(), 'defaultValue' => false],
                                 ],
-                                'resolve' => function (TypeInterface $type, array $args):
+                                'resolve' => function(TypeInterface $type, array $args):
                                 ?array {
                                     ['includeDeprecated' => $includeDeprecated] = $args;
 
@@ -271,7 +271,7 @@ 
                                         $fields = \array_values($type->getFields());
 
                                         if (!$includeDeprecated) {
-                                            $fields = \array_filter($fields, function (Field $field) {
+                                            $fields = \array_filter($fields, function(Field $field) {
                                                 return !$field->isDeprecated();
                                             });
                                         }
@@ -284,13 +284,13 @@ 
                             ],
                             'interfaces'    => [
                                 'type'    => newList(newNonNull(__Type())),
-                                'resolve' => function (TypeInterface $type): ?array {
+                                'resolve' => function(TypeInterface $type): ?array {
                                     return $type instanceof ObjectType ? $type->getInterfaces() : null;
                                 },
                             ],
                             'possibleTypes' => [
                                 'type'    => newList(newNonNull(__Type())),
-                                'resolve' => function (
+                                'resolve' => function(
                                     TypeInterface $type,
                                     array $args,
                                     array $context,
@@ -308,14 +308,14 @@ 
                                 'args'    => [
                                     'includeDeprecated' => ['type' => booleanType(), 'defaultValue' => false],
                                 ],
-                                'resolve' => function (TypeInterface $type, array $args): ?array {
+                                'resolve' => function(TypeInterface $type, array $args): ?array {
                                     ['includeDeprecated' => $includeDeprecated] = $args;
 
                                     if ($type instanceof EnumType) {
                                         $values = \array_values($type->getValues());
 
                                         if (!$includeDeprecated) {
-                                            $values = \array_filter($values, function (Field $field) {
+                                            $values = \array_filter($values, function(Field $field) {
                                                 return !$field->isDeprecated();
                                             });
                                         }
@@ -328,7 +328,7 @@ 
                             ],
                             'inputFields'   => [
                                 'type'    => newList(newNonNull(__InputValue())),
-                                'resolve' => function (TypeInterface $type): ?array {
+                                'resolve' => function(TypeInterface $type): ?array {
                                     return $type instanceof InputObjectType ? $type->getFields() : null;
                                 },
                             ],
@@ -339,20 +339,20 @@ 
             });
 
         $this->container
-            ->share(GraphQL::FIELD_INTROSPECTION, function () {
+            ->share(GraphQL::FIELD_INTROSPECTION, function() {
                 return newObjectType([
                     'name'            => GraphQL::FIELD_INTROSPECTION,
                     'isIntrospection' => true,
                     'description'     =>
                         'Object and Interface types are described by a list of Fields, each of ' .
                         'which has a name, potentially a list of arguments, and a return type.',
-                    'fields'          => function () {
+                    'fields'          => function() {
                         return [
                             'name'              => ['type' => newNonNull(stringType())],
                             'description'       => ['type' => stringType()],
                             'args'              => [
                                 'type'    => newNonNull(newList(newNonNull(__InputValue()))),
-                                'resolve' => function (ArgumentsAwareInterface $directive): array {
+                                'resolve' => function(ArgumentsAwareInterface $directive): array {
                                     return $directive->getArguments() ?? [];
                                 },
                             ],
@@ -365,7 +365,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::INPUT_VALUE_INTROSPECTION, function () {
+            ->share(GraphQL::INPUT_VALUE_INTROSPECTION, function() {
                 return newObjectType([
                     'name'            => GraphQL::INPUT_VALUE_INTROSPECTION,
                     'isIntrospection' => true,
@@ -373,7 +373,7 @@ 
                         'Arguments provided to Fields or Directives and the input fields of an ' .
                         'InputObject are represented as Input Values which describe their type ' .
                         'and optionally a default value.',
-                    'fields'          => function () {
+                    'fields'          => function() {
                         return [
                             'name'         => ['type' => newNonNull(stringType())],
                             'description'  => ['type' => stringType()],
@@ -383,7 +383,7 @@ 
                                 'description' =>
                                     'A GraphQL-formatted string representing the default value for this ' .
                                     'input value.',
-                                'resolve'     => function (/*$inputValue*/) {
+                                'resolve'     => function(/*$inputValue*/) {
                                     // TODO: Implement this when we have support for printing AST.
                                     return null;
                                 }
@@ -394,7 +394,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::ENUM_VALUE_INTROSPECTION, function () {
+            ->share(GraphQL::ENUM_VALUE_INTROSPECTION, function() {
                 return newObjectType([
                     'name'            => GraphQL::ENUM_VALUE_INTROSPECTION,
                     'isIntrospection' => true,
@@ -402,7 +402,7 @@ 
                         'One possible value for a given Enum. Enum values are unique values, not ' .
                         'a placeholder for a string or numeric value. However an Enum value is ' .
                         'returned in a JSON response as a string.',
-                    'fields'          => function () {
+                    'fields'          => function() {
                         return [
                             'name'              => ['type' => newNonNull(stringType())],
                             'description'       => ['type' => stringType()],
@@ -414,7 +414,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::TYPE_KIND_INTROSPECTION, function () {
+            ->share(GraphQL::TYPE_KIND_INTROSPECTION, function() {
                 return newEnumType([
                     'name'            => GraphQL::TYPE_KIND_INTROSPECTION,
                     'isIntrospection' => true,
@@ -455,12 +455,12 @@ 
     protected function registerMetaFields()
     {
         $this->container
-            ->share(GraphQL::SCHEMA_META_FIELD_DEFINITION, function ($__Schema) {
+            ->share(GraphQL::SCHEMA_META_FIELD_DEFINITION, function($__Schema) {
                 return newField([
                     'name'        => '__schema',
                     'description' => 'Access the current type schema of this server.',
                     'type'        => newNonNull($__Schema),
-                    'resolve'     => function ($source, $args, $context, ResolveInfo $info): Schema {
+                    'resolve'     => function($source, $args, $context, ResolveInfo $info): Schema {
                         return $info->getSchema();
                     },
                 ]);
@@ -468,13 +468,13 @@ 
             ->addArgument(GraphQL::SCHEMA_INTROSPECTION);
 
         $this->container
-            ->share(GraphQL::TYPE_META_FIELD_DEFINITION, function ($__Type) {
+            ->share(GraphQL::TYPE_META_FIELD_DEFINITION, function($__Type) {
                 return newField([
                     'name'        => '__type',
                     'description' => 'Request the type information of a single type.',
                     'type'        => $__Type,
                     'args'        => ['name' => ['type' => newNonNull(stringType())]],
-                    'resolve'     => function ($source, $args, $context, ResolveInfo $info): ?TypeInterface {
+                    'resolve'     => function($source, $args, $context, ResolveInfo $info): ?TypeInterface {
                         ['name' => $name] = $args;
                         return $info->getSchema()->getType($name);
                     },
@@ -483,12 +483,12 @@ 
             ->addArgument(GraphQL::TYPE_INTROSPECTION);
 
         $this->container
-            ->share(GraphQL::TYPE_NAME_META_FIELD_DEFINITION, function () {
+            ->share(GraphQL::TYPE_NAME_META_FIELD_DEFINITION, function() {
                 return newField([
                     'name'        => '__typename',
                     'description' => 'The name of the current Object type at runtime.',
                     'type'        => newNonNull(stringType()),
-                    'resolve'     => function ($source, $args, $context, ResolveInfo $info): string {
+                    'resolve'     => function($source, $args, $context, ResolveInfo $info): string {
                         return $info->getParentType()->getName();
                     },
                 ]);

src/Type/DirectivesProvider.php

Spacing +3 added lines, -3 removed lines

@@ -23,7 +23,7 @@ 
     public function register()
     {
         $this->container
-            ->share(GraphQL::INCLUDE_DIRECTIVE, function () {
+            ->share(GraphQL::INCLUDE_DIRECTIVE, function() {
                 return newDirective([
                     'name'        => 'include',
                     'description' =>
@@ -44,7 +44,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::SKIP_DIRECTIVE, function () {
+            ->share(GraphQL::SKIP_DIRECTIVE, function() {
                 return newDirective([
                     'name'        => 'skip',
                     'description' =>
@@ -65,7 +65,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::DEPRECATED_DIRECTIVE, function () {
+            ->share(GraphQL::DEPRECATED_DIRECTIVE, function() {
                 return newDirective([
                     'name'        => 'deprecated',
                     'description' => 'Marks an element of a GraphQL schema as no longer supported.',