digiaonline / graphql-php

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 (NamedTypeInterface $type): bool {
+            function(NamedTypeInterface $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 (NamedTypeInterface $type): bool {
+            function(NamedTypeInterface $type): bool {
                 return isIntrospectionType($type);
             }
         );
@@ -140,7 +140,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());
         });
 
@@ -283,11 +283,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,
@@ -359,7 +359,7 @@ 
         // This is important for getting the linebreaks correct between the items.
         $firstInBlock = true;
 
-        return printLines(\array_map(function (EnumValue $value) use (&$firstInBlock): string {
+        return printLines(\array_map(function(EnumValue $value) use (&$firstInBlock): string {
             $description  = $this->printDescription($value, '  ', $firstInBlock);
             $name         = $value->getName();
             $deprecated   = $this->printDeprecated($value);
@@ -381,7 +381,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([
@@ -429,7 +429,7 @@ 
         // This is important for getting the linebreaks correct between the items.
         $firstInBlock = true;
 
-        return printLines(\array_map(function (Field $field) use (&$firstInBlock): string {
+        return printLines(\array_map(function(Field $field) use (&$firstInBlock): string {
             $description  = $this->printDescription($field, '  ', $firstInBlock);
             $name         = $field->getName();
             $arguments    = $this->printArguments($field->getArguments());
@@ -456,15 +456,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([
@@ -571,7 +571,7 @@ 
      */
     protected function printMany(array $definitions): array
     {
-        return \array_map(function ($definition) {
+        return \array_map(function($definition) {
             return $this->print($definition);
         }, $definitions);
     }

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,
@@ -213,7 +213,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::TYPE_INTROSPECTION, function () {
+            ->share(GraphQL::TYPE_INTROSPECTION, function() {
                 return newObjectType([
                     'name'            => GraphQL::TYPE_INTROSPECTION,
                     'isIntrospection' => true,
@@ -225,11 +225,11 @@ 
                         'Enum types provide their values. 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;
                                     }
@@ -265,7 +265,7 @@ 
                                 'args'    => [
                                     'includeDeprecated' => ['type' => booleanType(), 'defaultValue' => false],
                                 ],
-                                'resolve' => function (TypeInterface $type, array $args):
+                                'resolve' => function(TypeInterface $type, array $args):
                                 ?array {
                                     ['includeDeprecated' => $includeDeprecated] = $args;
 
@@ -273,7 +273,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();
                                             });
                                         }
@@ -286,13 +286,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,
@@ -310,14 +310,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();
                                             });
                                         }
@@ -330,7 +330,7 @@ 
                             ],
                             'inputFields'   => [
                                 'type'    => newList(newNonNull(__InputValue())),
-                                'resolve' => function (TypeInterface $type): ?array {
+                                'resolve' => function(TypeInterface $type): ?array {
                                     return $type instanceof InputObjectType ? $type->getFields() : null;
                                 },
                             ],
@@ -341,20 +341,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() ?? [];
                                 },
                             ],
@@ -367,7 +367,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::INPUT_VALUE_INTROSPECTION, function () {
+            ->share(GraphQL::INPUT_VALUE_INTROSPECTION, function() {
                 return newObjectType([
                     'name'            => GraphQL::INPUT_VALUE_INTROSPECTION,
                     'isIntrospection' => true,
@@ -375,7 +375,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()],
@@ -385,7 +385,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;
                                 }
@@ -396,7 +396,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::ENUM_VALUE_INTROSPECTION, function () {
+            ->share(GraphQL::ENUM_VALUE_INTROSPECTION, function() {
                 return newObjectType([
                     'name'            => GraphQL::ENUM_VALUE_INTROSPECTION,
                     'isIntrospection' => true,
@@ -404,7 +404,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()],
@@ -416,7 +416,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::TYPE_KIND_INTROSPECTION, function () {
+            ->share(GraphQL::TYPE_KIND_INTROSPECTION, function() {
                 return newEnumType([
                     'name'            => GraphQL::TYPE_KIND_INTROSPECTION,
                     'isIntrospection' => true,
@@ -457,12 +457,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();
                     },
                 ]);
@@ -470,13 +470,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);
                     },
@@ -485,12 +485,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/Schema/utils.php

Spacing +2 added lines, -2 removed lines

@@ -10,7 +10,7 @@ 
 function descriptionLines(string $description, int $maxLength): array
 {
     // Map over the description lines and merge them into a flat array.
-    return \array_merge(...\array_map(function (string $line) use ($maxLength) {
+    return \array_merge(...\array_map(function(string $line) use ($maxLength) {
         if (\strlen($line) < ($maxLength + 5)) {
             return [$line];
         }
@@ -57,7 +57,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 !== '';
     });