digiaonline / graphql-php

src/Language/Node/ArgumentsTrait.php

Spacing +1 added lines, -1 removed lines

@@ -30,7 +30,7 @@
      */
     public function getArgumentsAST(): array
     {
-        return \array_map(function (ArgumentNode $node) {
+        return \array_map(function(ArgumentNode $node) {
             return $node->toAST();
         }, $this->getArguments());
     }

src/Type/ScalarTypesProvider.php

Spacing +20 added lines, -20 removed lines

@@ -33,17 +33,17 @@ 
      */
     public function register()
     {
-        $this->container->add(GraphQL::BOOLEAN, function (BooleanCoercer $coercer) {
+        $this->container->add(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();
                     }
@@ -53,20 +53,20 @@ 
         }, true/* $shared */)
             ->withArgument(BooleanCoercer::class);
 
-        $this->container->add(GraphQL::FLOAT, function (FloatCoercer $coercer) {
+        $this->container->add(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();
                     }
@@ -76,19 +76,19 @@ 
         }, true/* $shared */)
             ->withArgument(FloatCoercer::class);
 
-        $this->container->add(GraphQL::INT, function (IntCoercer $coercer) {
+        $this->container->add(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 &&
@@ -102,7 +102,7 @@ 
         }, true/* $shared */)
             ->withArgument(IntCoercer::class);
 
-        $this->container->add(GraphQL::ID, function (StringCoercer $coercer) {
+        $this->container->add(GraphQL::ID, function(StringCoercer $coercer) {
             return newScalarType([
                 'name'         => TypeNameEnum::ID,
                 'description'  =>
@@ -111,13 +111,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();
                     }
@@ -127,20 +127,20 @@ 
         }, true/* $shared */)
             ->withArgument(StringCoercer::class);
 
-        $this->container->add(GraphQL::STRING, function (StringCoercer $coercer) {
+        $this->container->add(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/Language/Parser.php

Spacing +9 added lines, -9 removed lines

@@ -314,7 +314,7 @@ 
         /**
          * @return TypeNodeInterface
          */
-        $parseType = function (): TypeNodeInterface {
+        $parseType = function(): TypeNodeInterface {
             $this->expect(TokenKindEnum::COLON);
             return $this->lexType();
         };
@@ -425,7 +425,7 @@ 
         /**
          * @return ArgumentNode
          */
-        $parseFunction = function () use ($isConst): ArgumentNode {
+        $parseFunction = function() use ($isConst) : ArgumentNode {
             return $this->lexArgument($isConst);
         };
 
@@ -452,7 +452,7 @@ 
         /**
          * @return NodeInterface|TypeNodeInterface|ValueNodeInterface
          */
-        $parseValue = function () use ($isConst): NodeInterface {
+        $parseValue = function() use ($isConst): NodeInterface {
             $this->expect(TokenKindEnum::COLON);
             return $this->lexValue($isConst);
         };
@@ -521,7 +521,7 @@ 
 
         $this->expectKeyword(KeywordEnum::FRAGMENT);
 
-        $parseTypeCondition = function () {
+        $parseTypeCondition = function() {
             $this->expectKeyword(KeywordEnum::ON);
             return $this->lexNamedType();
         };
@@ -651,7 +651,7 @@ 
     {
         $start = $this->lexer->getToken();
 
-        $parseFunction = function () use ($isConst) {
+        $parseFunction = function() use ($isConst) {
             return $this->lexValue($isConst);
         };
 
@@ -704,7 +704,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);
         };
@@ -1047,7 +1047,7 @@ 
      */
     protected function lexArgumentsDefinition(): array
     {
-        $parseFunction = function (): InputValueDefinitionNode {
+        $parseFunction = function(): InputValueDefinitionNode {
             return $this->lexInputValueDefinition();
         };
 
@@ -1253,7 +1253,7 @@ 
      */
     protected function lexInputFieldsDefinition(): array
     {
-        $parseFunction = function (): InputValueDefinitionNode {
+        $parseFunction = function(): InputValueDefinitionNode {
             return $this->lexInputValueDefinition();
         };
 
@@ -1557,7 +1557,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/Execution/ExecutionResult.php

Spacing +1 added lines, -1 removed lines

@@ -66,7 +66,7 @@
         $array = [];
 
         if (!empty($this->errors)) {
-            $array['errors'] = \array_map(function (GraphQLException $error) {
+            $array['errors'] = \array_map(function(GraphQLException $error) {
                 return $error->toArray();
             }, $this->errors);
         }

src/Util/TypeInfo.php

Spacing +1 added lines, -1 removed lines

@@ -77,7 +77,7 @@
         ?TypeInterface $initialType = null
     ) {
         $this->schema                     = $schema;
-        $this->getFieldDefinitionFunction = $getFieldDefinitionFunction ?? function (
+        $this->getFieldDefinitionFunction = $getFieldDefinitionFunction ?? function(
                 Schema $schema,
                 TypeInterface $parentType,
                 FieldNode $fieldNode

src/Type/IntrospectionProvider.php

Spacing +36 added lines, -36 removed lines

@@ -57,7 +57,7 @@ 
      */
     protected function registerIntrospectionTypes()
     {
-        $this->container->add(GraphQL::SCHEMA_INTROSPECTION, function () {
+        $this->container->add(GraphQL::SCHEMA_INTROSPECTION, function() {
             return newObjectType([
                 'name'            => GraphQL::SCHEMA_INTROSPECTION,
                 'isIntrospection' => true,
@@ -65,19 +65,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();
                             },
                         ],
@@ -86,7 +86,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();
                             },
                         ],
@@ -95,14 +95,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();
                             },
                         ],
@@ -111,7 +111,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::DIRECTIVE_INTROSPECTION, function () {
+        $this->container->add(GraphQL::DIRECTIVE_INTROSPECTION, function() {
             return newObjectType([
                 'name'            => GraphQL::DIRECTIVE_INTROSPECTION,
                 'isIntrospection' => true,
@@ -122,7 +122,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(String())],
                         'description' => ['type' => String()],
@@ -131,7 +131,7 @@ 
                         ],
                         'args'        => [
                             'type'    => newNonNull(newList(newNonNull(__InputValue()))),
-                            'resolve' => function (Directive $directive): array {
+                            'resolve' => function(Directive $directive): array {
                                 return $directive->getArguments() ?: [];
                             },
                         ],
@@ -140,7 +140,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::DIRECTIVE_LOCATION_INTROSPECTION, function () {
+        $this->container->add(GraphQL::DIRECTIVE_LOCATION_INTROSPECTION, function() {
             return newEnumType([
                 'name'            => GraphQL::DIRECTIVE_LOCATION_INTROSPECTION,
                 'isIntrospection' => true,
@@ -206,7 +206,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::TYPE_INTROSPECTION, function () {
+        $this->container->add(GraphQL::TYPE_INTROSPECTION, function() {
             return newObjectType([
                 'name'            => GraphQL::TYPE_INTROSPECTION,
                 'isIntrospection' => true,
@@ -219,11 +219,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;
                                 }
@@ -259,7 +259,7 @@ 
                             'args'    => [
                                 'includeDeprecated' => ['type' => Boolean(), 'defaultValue' => false],
                             ],
-                            'resolve' => function (TypeInterface $type, array $args):
+                            'resolve' => function(TypeInterface $type, array $args):
                             ?array {
                                 ['includeDeprecated' => $includeDeprecated] = $args;
 
@@ -267,7 +267,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();
                                         });
                                     }
@@ -280,13 +280,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,
@@ -304,14 +304,14 @@ 
                             'args'    => [
                                 'includeDeprecated' => ['type' => Boolean(), '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();
                                         });
                                     }
@@ -324,7 +324,7 @@ 
                         ],
                         'inputFields'   => [
                             'type'    => newList(newNonNull(__InputValue())),
-                            'resolve' => function (TypeInterface $type): ?array {
+                            'resolve' => function(TypeInterface $type): ?array {
                                 return $type instanceof InputObjectType ? $type->getFields() : null;
                             },
                         ],
@@ -334,20 +334,20 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::FIELD_INTROSPECTION, function () {
+        $this->container->add(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(String())],
                         'description'       => ['type' => String()],
                         'args'              => [
                             'type'    => newNonNull(newList(newNonNull(__InputValue()))),
-                            'resolve' => function (ArgumentsAwareInterface $directive): array {
+                            'resolve' => function(ArgumentsAwareInterface $directive): array {
                                 return $directive->getArguments() ?? [];
                             },
                         ],
@@ -359,7 +359,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::INPUT_VALUE_INTROSPECTION, function () {
+        $this->container->add(GraphQL::INPUT_VALUE_INTROSPECTION, function() {
             return newObjectType([
                 'name'            => GraphQL::INPUT_VALUE_INTROSPECTION,
                 'isIntrospection' => true,
@@ -367,7 +367,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(String())],
                         'description'  => ['type' => String()],
@@ -377,7 +377,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;
                             }
@@ -387,7 +387,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::ENUM_VALUE_INTROSPECTION, function () {
+        $this->container->add(GraphQL::ENUM_VALUE_INTROSPECTION, function() {
             return newObjectType([
                 'name'            => GraphQL::ENUM_VALUE_INTROSPECTION,
                 'isIntrospection' => true,
@@ -395,7 +395,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(String())],
                         'description'       => ['type' => String()],
@@ -406,7 +406,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::TYPE_KIND_INTROSPECTION, function () {
+        $this->container->add(GraphQL::TYPE_KIND_INTROSPECTION, function() {
             return newEnumType([
                 'name'            => GraphQL::TYPE_KIND_INTROSPECTION,
                 'isIntrospection' => true,
@@ -446,25 +446,25 @@ 
      */
     protected function registerMetaFields()
     {
-        $this->container->add(GraphQL::SCHEMA_META_FIELD_DEFINITION, function ($__Schema) {
+        $this->container->add(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();
                 },
             ]);
         })
             ->withArgument(GraphQL::SCHEMA_INTROSPECTION);
 
-        $this->container->add(GraphQL::TYPE_META_FIELD_DEFINITION, function ($__Type) {
+        $this->container->add(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(String())]],
-                'resolve'     => function ($source, $args, $context, ResolveInfo $info): TypeInterface {
+                'resolve'     => function($source, $args, $context, ResolveInfo $info): TypeInterface {
                     ['name' => $name] = $args;
                     return $info->getSchema()->getType($name);
                 },
@@ -472,12 +472,12 @@ 
         })
             ->withArgument(GraphQL::TYPE_INTROSPECTION);
 
-        $this->container->add(GraphQL::TYPE_NAME_META_FIELD_DEFINITION, function () {
+        $this->container->add(GraphQL::TYPE_NAME_META_FIELD_DEFINITION, function() {
             return newField([
                 'name'        => '__typename',
                 'description' => 'The name of the current Object type at runtime.',
                 'type'        => newNonNull(String()),
-                'resolve'     => function ($source, $args, $context, ResolveInfo $info): string {
+                'resolve'     => function($source, $args, $context, ResolveInfo $info): string {
                     return $info->getParentType()->getName();
                 },
             ]);

src/Schema/utils.php

Spacing +1 added lines, -1 removed lines

@@ -74,7 +74,7 @@
 function printLines(array $lines): string
 {
     // Don't print empty lines
-    $lines = \array_filter($lines, function (string $line) {
+    $lines = \array_filter($lines, function(string $line) {
         return $line !== '';
     });
     

src/Schema/DefinitionPrinter.php

Spacing +14 added lines, -14 removed lines

@@ -46,10 +46,10 @@ 
 
         return $this->printFilteredSchema(
             $schema,
-            function (Directive $directive): bool {
+            function(Directive $directive): bool {
                 return !isSpecifiedDirective($directive);
             },
-            function (TypeInterface $type): bool {
+            function(TypeInterface $type): bool {
                 return !isSpecifiedScalarType($type) && !isIntrospectionType($type);
             }
         );
@@ -66,10 +66,10 @@ 
 
         return $this->printFilteredSchema(
             $schema,
-            function (Directive $directive): bool {
+            function(Directive $directive): bool {
                 return isSpecifiedDirective($directive);
             },
-            function (TypeInterface $type): bool {
+            function(TypeInterface $type): bool {
                 return isIntrospectionType($type);
             }
         );
@@ -135,7 +135,7 @@ 
     {
         $types = \array_filter(\array_values($schema->getTypeMap()), $filter);
 
-        \usort($types, function (NamedTypeInterface $typeA, NamedTypeInterface $typeB) {
+        \usort($types, function(NamedTypeInterface $typeA, NamedTypeInterface $typeB) {
             return \strcasecmp($typeA->getName(), $typeB->getName());
         });
 
@@ -261,11 +261,11 @@ 
         $description = $this->printDescription($type);
         $name        = $type->getName();
         $implements  = $type->hasInterfaces()
-            ? ' implements ' . printArray(' & ', \array_map(function (InterfaceType $interface) {
+            ? ' implements ' . printArray(' & ', \array_map(function(InterfaceType $interface) {
                 return $interface->getName();
             }, $type->getInterfaces()))
             : '';
-        $fields      = $this->printFields($type->getFields());
+        $fields = $this->printFields($type->getFields());
 
         return printLines([
             $description,
@@ -329,7 +329,7 @@ 
 
     protected function printEnumValues(array $values): string
     {
-        return printLines(\array_map(function (EnumValue $value): string {
+        return printLines(\array_map(function(EnumValue $value): string {
             $description = $this->printDescription($value, '  ');
             $name        = $value->getName();
             $deprecated  = $this->printDeprecated($value);
@@ -350,7 +350,7 @@ 
     protected function printInputObjectType(InputObjectType $type): string
     {
         $description = $this->printDescription($type);
-        $fields      = \array_map(function (InputField $field): string {
+        $fields      = \array_map(function(InputField $field): string {
             $description = $this->printDescription($field, '  ');
             $inputValue  = $this->printInputValue($field);
             return printLines([
@@ -388,7 +388,7 @@ 
      */
     protected function printFields(array $fields): string
     {
-        return printLines(\array_map(function (Field $field): string {
+        return printLines(\array_map(function(Field $field): string {
             $description = $this->printDescription($field);
             $name        = $field->getName();
             $arguments   = $this->printArguments($field->getArguments());
@@ -408,15 +408,15 @@ 
         }
 
         // If every arg does not have a description, print them on one line.
-        if (arrayEvery($arguments, function (Argument $argument): bool {
+        if (arrayEvery($arguments, function(Argument $argument): bool {
             return !$argument->hasDescription();
         })) {
-            return printInputFields(\array_map(function (Argument $argument) {
+            return printInputFields(\array_map(function(Argument $argument) {
                 return $this->printInputValue($argument);
             }, $arguments));
         }
 
-        $args = \array_map(function (Argument $argument) use ($indentation) {
+        $args = \array_map(function(Argument $argument) use ($indentation) {
             $description = $this->printDescription($argument);
             $inputValue  = $this->printInputValue($argument);
             return printLines([
@@ -541,7 +541,7 @@ 
      */
     protected function printMany(array $definitions): array
     {
-        return \array_map(function ($definition) {
+        return \array_map(function($definition) {
             return $this->print($definition);
         }, $definitions);
     }