digiaonline / graphql-php

src/Error/GraphQLException.php

Spacing +5 added lines, -5 removed lines

@@ -152,7 +152,7 @@ 
      */
     public function getLocationsAsArray(): ?array
     {
-        return !empty($this->locations) ? \array_map(function (SourceLocation $location) {
+        return !empty($this->locations) ? \array_map(function(SourceLocation $location) {
             return $location->toArray();
         }, $this->locations) : null;
     }
@@ -193,7 +193,7 @@ 
             $nodes = [$nodes];
         }
 
-        $this->nodes = \array_filter($nodes, function ($node) {
+        $this->nodes = \array_filter($nodes, function($node) {
             return null !== $node;
         });
 
@@ -224,7 +224,7 @@ 
     protected function resolvePositions(?array $positions)
     {
         if (null === $positions && !empty($this->nodes)) {
-            $positions = \array_reduce($this->nodes, function (array $list, ?NodeInterface $node) {
+            $positions = \array_reduce($this->nodes, function(array $list, ?NodeInterface $node) {
                 if (null !== $node) {
                     $location = $node->getLocation();
                     if (null !== $location) {
@@ -252,11 +252,11 @@ 
     protected function resolveLocations(?array $positions, ?Source $source)
     {
         if (null !== $positions && null !== $source) {
-            $locations = \array_map(function ($position) use ($source) {
+            $locations = \array_map(function($position) use ($source) {
                 return SourceLocation::fromSource($source, $position);
             }, $positions);
         } elseif (!empty($this->nodes)) {
-            $locations = \array_reduce($this->nodes, function (array $list, NodeInterface $node) {
+            $locations = \array_reduce($this->nodes, function(array $list, NodeInterface $node) {
                 $location = $node->getLocation();
                 if (null !== $location) {
                     $list[] = SourceLocation::fromSource($location->getSource(), $location->getStart());

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 (NodeInterface $node) {
+        return \array_map(function(NodeInterface $node) {
             return $this->buildType($node);
         }, $nodes);
     }
@@ -158,7 +158,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()) : [],
@@ -226,7 +226,7 @@ 
     {
         $typesMap = keyMap(
             \array_merge($customTypes, specifiedScalarTypes(), introspectionTypes()),
-            function (NamedTypeInterface $type) {
+            function(NamedTypeInterface $type) {
                 return $type->getName();
             }
         );
@@ -243,7 +243,7 @@ 
     {
         $directivesMap = keyMap(
             \array_merge($customDirectives, specifiedDirectives()),
-            function (Directive $directive) {
+            function(Directive $directive) {
                 return $directive->getName();
             }
         );
@@ -262,10 +262,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 [
@@ -319,14 +319,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 (NodeInterface $interface) {
+            'interfaces'  => function() use ($node) {
+                return $node->hasInterfaces() ? \array_map(function(NodeInterface $interface) {
                     return $this->buildType($interface);
                 }, $node->getInterfaces()) : [];
             },
@@ -342,11 +342,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()));
@@ -376,7 +376,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()),
@@ -396,10 +396,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),
@@ -421,7 +421,7 @@ 
         return newUnionType([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'types'       => $node->hasTypes() ? \array_map(function (NodeInterface $type) {
+            'types'       => $node->hasTypes() ? \array_map(function(NodeInterface $type) {
                 return $this->buildType($type);
             }, $node->getTypes()) : [],
             'resolveType' => $this->getTypeResolver($node->getNameValue()),
@@ -450,7 +450,7 @@ 
         return newScalarType([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'serialize'   => function ($value) {
+            'serialize'   => function($value) {
                 return $value;
             },
             'astNode'     => $node,
@@ -467,13 +467,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/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();
                 },
             ]);