digiaonline / graphql-php

src/Language/AST/Node/SchemaDefinitionNode.php

Spacing +1 added lines, -1 removed lines

@@ -33,7 +33,7 @@
      */
     public function getOperationTypesAsArray(): array
     {
-        return array_map(function (SerializationInterface $node) {
+        return array_map(function(SerializationInterface $node) {
             return $node->toArray();
         }, $this->operationTypes);
     }

src/Language/AST/Node/ObjectValueNode.php

Spacing +1 added lines, -1 removed lines

@@ -26,7 +26,7 @@
      */
     public function getFieldsAsArray(): array
     {
-        return array_map(function (SerializationInterface $node) {
+        return array_map(function(SerializationInterface $node) {
             return $node->toArray();
         }, $this->fields);
     }

src/Language/Parser.php

Spacing +5 added lines, -5 removed lines

@@ -439,7 +439,7 @@ 
          * @return mixed
          * @throws GraphQLError
          */
-        $parseType = function (LexerInterface $lexer) {
+        $parseType = function(LexerInterface $lexer) {
             $this->expect($lexer, TokenKindEnum::COLON);
             return $this->parseTypeReference($lexer);
         };
@@ -569,7 +569,7 @@ 
          * @return mixed
          * @throws GraphQLError
          */
-        $parseValue = function (LexerInterface $lexer) {
+        $parseValue = function(LexerInterface $lexer) {
             $this->expect($lexer, TokenKindEnum::COLON);
             return $this->parseValueLiteral($lexer, false);
         };
@@ -596,7 +596,7 @@ 
          * @return mixed
          * @throws GraphQLError
          */
-        $parseValue = function (LexerInterface $lexer) {
+        $parseValue = function(LexerInterface $lexer) {
             $this->expect($lexer, TokenKindEnum::COLON);
             return $this->parseConstValue($lexer);
         };
@@ -657,7 +657,7 @@ 
 
         $this->expectKeyword($lexer, KeywordEnum::FRAGMENT);
 
-        $parseTypeCondition = function (LexerInterface $lexer) {
+        $parseTypeCondition = function(LexerInterface $lexer) {
             $this->expectKeyword($lexer, 'on');
             return $this->parseNamedType($lexer);
         };
@@ -854,7 +854,7 @@ 
     {
         $start = $lexer->getToken();
 
-        $parseValue = function (LexerInterface $lexer, bool $isConst) {
+        $parseValue = function(LexerInterface $lexer, bool $isConst) {
             $this->expect($lexer, TokenKindEnum::COLON);
             return $this->parseValueLiteral($lexer, $isConst);
         };

src/Type/scalars.php

Spacing +1 added lines, -1 removed lines

@@ -72,7 +72,7 @@
 {
     return arraySome(
         specifiedScalarTypes(),
-        function (ScalarType $specifiedScalarType) use ($type) {
+        function(ScalarType $specifiedScalarType) use ($type) {
             /** @noinspection PhpUndefinedMethodInspection */
             return $type->getName() === $specifiedScalarType->getName();
         }

src/Type/introspection.php

Spacing +26 added lines, -26 removed lines

@@ -33,19 +33,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'        => GraphQLNonNull(GraphQLList(GraphQLNonNull(__Type()))),
-                        'resolve'     => function (SchemaInterface $schema): array {
+                        'resolve'     => function(SchemaInterface $schema): array {
                             return array_values($schema->getTypeMap());
                         },
                     ],
                     'queryType'        => [
                         'description' => 'The type that query operations will be rooted at.',
                         'type'        => GraphQLNonNull(__Type()),
-                        'resolve'     => function (SchemaInterface $schema): ObjectType {
+                        'resolve'     => function(SchemaInterface $schema): ObjectType {
                             return $schema->getQuery();
                         },
                     ],
@@ -54,7 +54,7 @@ 
                             'If this server supports mutation, the type that ' .
                             'mutation operations will be rooted at.',
                         'type'        => __Type(),
-                        'resolve'     => function (SchemaInterface $schema): ObjectType {
+                        'resolve'     => function(SchemaInterface $schema): ObjectType {
                             return $schema->getMutation();
                         },
                     ],
@@ -63,14 +63,14 @@ 
                             'If this server support subscription, the type that ' .
                             'subscription operations will be rooted at.',
                         'type'        => __Type(),
-                        'resolve'     => function (SchemaInterface $schema): ObjectType {
+                        'resolve'     => function(SchemaInterface $schema): ObjectType {
                             return $schema->getSubscription();
                         },
                     ],
                     'directives'       => [
                         'description' => 'A list of all directives supported by this server.',
                         'type'        => GraphQLNonNull(GraphQLList(GraphQLNonNull(__Directive()))),
-                        'resolve'     => function (SchemaInterface $schema): array {
+                        'resolve'     => function(SchemaInterface $schema): array {
                             return $schema->getDirectives();
                         },
                     ],
@@ -100,7 +100,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' => GraphQLNonNull(GraphQLString())],
                     'description' => ['type' => GraphQLString()],
@@ -109,7 +109,7 @@ 
                     ],
                     'args'        => [
                         'type'    => GraphQLNonNull(GraphQLList(GraphQLNonNull(__InputValue()))),
-                        'resolve' => function (DirectiveInterface $directive): array {
+                        'resolve' => function(DirectiveInterface $directive): array {
                             return $directive->getArguments() ?: [];
                         },
                     ],
@@ -217,11 +217,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'    => GraphQLNonNull(__TypeKind()),
-                        'resolve' => function (TypeInterface $type) {
+                        'resolve' => function(TypeInterface $type) {
                             if ($type instanceof ScalarType) {
                                 return TypeKindEnum::SCALAR;
                             }
@@ -257,14 +257,14 @@ 
                         'args'    => [
                             'includeDeprecated' => ['type' => GraphQLBoolean(), 'defaultValue' => false],
                         ],
-                        'resolve' => function (TypeInterface $type, array $args): ?array {
+                        'resolve' => function(TypeInterface $type, array $args): ?array {
                             [$includeDeprecated] = $args;
 
                             if ($type instanceof ObjectType || $type instanceof InterfaceType) {
                                 $fields = array_values($type->getFields());
 
                                 if (!$includeDeprecated) {
-                                    $fields = array_filter($fields, function (Field $field) {
+                                    $fields = array_filter($fields, function(Field $field) {
                                         return !$field->isDeprecated();
                                     });
                                 }
@@ -277,13 +277,13 @@ 
                     ],
                     'interfaces'    => [
                         'type'    => GraphQLList(GraphQLNonNull(__Type())),
-                        'resolve' => function (TypeInterface $type): ?array {
+                        'resolve' => function(TypeInterface $type): ?array {
                             return $type instanceof ObjectType ? $type->getInterfaces() : null;
                         },
                     ],
                     'possibleTypes' => [
                         'type'    => GraphQLList(GraphQLNonNull(__Type())),
-                        'resolve' => function (TypeInterface $type, $args, $context, $info): ?array {
+                        'resolve' => function(TypeInterface $type, $args, $context, $info): ?array {
                             /** @var SchemaInterface $schema */
                             [$schema] = $info;
                             /** @noinspection PhpParamsInspection */
@@ -295,14 +295,14 @@ 
                         'args'    => [
                             'includeDeprecated' => ['type' => GraphQLBoolean(), 'defaultValue' => false],
                         ],
-                        'resolve' => function (TypeInterface $type, array $args): ?array {
+                        'resolve' => function(TypeInterface $type, array $args): ?array {
                             [$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();
                                     });
                                 }
@@ -315,7 +315,7 @@ 
                     ],
                     'inputFields'   => [
                         'type'    => GraphQLList(GraphQLNonNull(__InputValue())),
-                        'resolve' => function (TypeInterface $type): ?array {
+                        'resolve' => function(TypeInterface $type): ?array {
                             return $type instanceof InputObjectType ? $type->getFields() : null;
                         },
                     ],
@@ -342,13 +342,13 @@ 
             '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' => GraphQLNonNull(GraphQLString())],
                     'description'       => ['type' => GraphQLString()],
                     'args'              => [
                         'type'    => GraphQLNonNull(GraphQLList(GraphQLNonNull(__InputValue()))),
-                        'resolve' => function (DirectiveInterface $directive): array {
+                        'resolve' => function(DirectiveInterface $directive): array {
                             return $directive->getArguments() ?: [];
                         },
                     ],
@@ -378,7 +378,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' => GraphQLNonNull(GraphQLString())],
                     'description'  => ['type' => GraphQLString()],
@@ -388,7 +388,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;
                         }
@@ -416,7 +416,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' => GraphQLNonNull(GraphQLString())],
                     'description'       => ['type' => GraphQLString()],
@@ -481,7 +481,7 @@ 
         'name'        => '__schema',
         'type'        => GraphQLNonNull(__Schema()),
         'description' => 'Access the current type schema of this server.',
-        'resolve'     => function ($source, $args, $context, $info): SchemaInterface {
+        'resolve'     => function($source, $args, $context, $info): SchemaInterface {
             [$schema] = $info;
             return $schema;
         }
@@ -501,7 +501,7 @@ 
         'args'        => [
             'name' => ['type' => GraphQLNonNull(GraphQLString())],
         ],
-        'resolve'     => function ($source, $args, $context, $info): TypeInterface {
+        'resolve'     => function($source, $args, $context, $info): TypeInterface {
             /** @var SchemaInterface $schema */
             [$name] = $args;
             [$schema] = $info;
@@ -520,7 +520,7 @@ 
         'name'        => '__typename',
         'type'        => GraphQLNonNull(GraphQLString()),
         'description' => 'The name of the current Object type at runtime.',
-        'resolve'     => function ($source, $args, $context, $info): string {
+        'resolve'     => function($source, $args, $context, $info): string {
             /** @var NamedTypeInterface $parentType */
             [$parentType] = $info;
             return $parentType->getName();
@@ -553,7 +553,7 @@ 
 {
     return arraySome(
         introspectionTypes(),
-        function (TypeInterface $introspectionType) use ($type) {
+        function(TypeInterface $introspectionType) use ($type) {
             /** @noinspection PhpUndefinedMethodInspection */
             return $type->getName() === $introspectionType->getName();
         }

src/Provider/ParserProvider.php

Spacing +2 added lines, -2 removed lines

@@ -29,14 +29,14 @@
      */
     public function register()
     {
-        $this->container->add(NodeBuilderInterface::class, function () {
+        $this->container->add(NodeBuilderInterface::class, function() {
             return new NodeBuilder(SupportedBuilders::get());
         });
 
         $this->container->add(ParserInterface::class, Parser::class, true/* $shared */)
             ->withArgument(NodeBuilderInterface::class);
 
-        $this->container->add(LexerInterface::class, function () {
+        $this->container->add(LexerInterface::class, function() {
             return new Lexer(SupportedReaders::get());
         });
     }

src/Provider/DirectivesProvider.php

Spacing +3 added lines, -3 removed lines

@@ -27,7 +27,7 @@ 
      */
     public function register()
     {
-        $this->container->add(GraphQL::INCLUDE_DIRECTIVE, function () {
+        $this->container->add(GraphQL::INCLUDE_DIRECTIVE, function() {
             return GraphQLDirective([
                 'name'        => 'include',
                 'description' =>
@@ -47,7 +47,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::SKIP_DIRECTIVE, function () {
+        $this->container->add(GraphQL::SKIP_DIRECTIVE, function() {
             return GraphQLDirective([
                 'name'        => 'skip',
                 'description' =>
@@ -67,7 +67,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::DEPRECATED_DIRECTIVE, function () {
+        $this->container->add(GraphQL::DEPRECATED_DIRECTIVE, function() {
             return GraphQLDirective([
                 'name'        => 'deprecated',
                 'description' => 'Marks an element of a GraphQL schema as no longer supported.',

src/Provider/SchemaBuilderProvider.php

Spacing +1 added lines, -1 removed lines

@@ -28,7 +28,7 @@
     {
         $this->container->add(DefinitionBuilderInterface::class, DefinitionBuilder::class, true/* $shared */)
             ->withArguments([
-                function (NamedTypeNode $node) {
+                function(NamedTypeNode $node) {
                     throw new \Exception(sprintf('Type "%s" not found in document.', $node->getNameValue()));
                 },
                 CacheInterface::class,

src/Provider/ScalarTypesProvider.php

Spacing +20 added lines, -20 removed lines

@@ -36,38 +36,38 @@ 
      */
     public function register()
     {
-        $this->container->add(GraphQL::BOOLEAN, function () {
+        $this->container->add(GraphQL::BOOLEAN, function() {
             return GraphQLScalarType([
                 'name'        => TypeNameEnum::BOOLEAN,
                 'description' => 'The `Boolean` scalar type represents `true` or `false`.',
-                'serialize'   => function ($value) {
+                'serialize'   => function($value) {
                     return coerceBoolean($value);
                 },
-                'parseValue'  => function ($value) {
+                'parseValue'  => function($value) {
                     return coerceBoolean($value);
                 },
 
-                'parseLiteral' => function (NodeInterface $astNode) {
+                'parseLiteral' => function(NodeInterface $astNode) {
                     /** @var BooleanValueNode $astNode */
                     return $astNode->getKind() === NodeKindEnum::BOOLEAN ? $astNode->getValue() : null;
                 },
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::FLOAT, function () {
+        $this->container->add(GraphQL::FLOAT, function() {
             return GraphQLScalarType([
                 'name'         => TypeNameEnum::FLOAT,
                 'description'  =>
                     'The `Float` scalar type represents signed double-precision fractional ' .
                     'values as specified by ' .
                     '[IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point).',
-                'serialize'    => function ($value) {
+                'serialize'    => function($value) {
                     return coerceFloat($value);
                 },
-                'parseValue'   => function ($value) {
+                'parseValue'   => function($value) {
                     return coerceFloat($value);
                 },
-                'parseLiteral' => function (NodeInterface $astNode) {
+                'parseLiteral' => function(NodeInterface $astNode) {
                     /** @var FloatValueNode $astNode */
                     return $astNode->getKind() === NodeKindEnum::FLOAT || $astNode->getKind() === NodeKindEnum::INT
                         ? $astNode->getValue()
@@ -76,26 +76,26 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::INT, function () {
+        $this->container->add(GraphQL::INT, function() {
             return GraphQLScalarType([
                 '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) {
+                'serialize'    => function($value) {
                     return coerceInt($value);
                 },
-                'parseValue'   => function ($value) {
+                'parseValue'   => function($value) {
                     return coerceInt($value);
                 },
-                'parseLiteral' => function (NodeInterface $astNode) {
+                'parseLiteral' => function(NodeInterface $astNode) {
                     /** @var IntValueNode $astNode */
                     return $astNode->getKind() === NodeKindEnum::INT ? $astNode->getValue() : null;
                 },
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::ID, function () {
+        $this->container->add(GraphQL::ID, function() {
             return GraphQLScalarType([
                 'name'         => TypeNameEnum::ID,
                 'description'  =>
@@ -104,13 +104,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) {
+                'serialize'    => function($value) {
                     return coerceString($value);
                 },
-                'parseValue'   => function ($value) {
+                'parseValue'   => function($value) {
                     return coerceString($value);
                 },
-                'parseLiteral' => function (NodeInterface $astNode) {
+                'parseLiteral' => function(NodeInterface $astNode) {
                     /** @var StringValueNode $astNode */
                     return $astNode->getKind() === NodeKindEnum::STRING || $astNode->getKind() === NodeKindEnum::INT
                         ? $astNode->getValue()
@@ -119,20 +119,20 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::STRING, function () {
+        $this->container->add(GraphQL::STRING, function() {
             return GraphQLScalarType([
                 '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) {
+                'serialize'    => function($value) {
                     return coerceString($value);
                 },
-                'parseValue'   => function ($value) {
+                'parseValue'   => function($value) {
                     return coerceString($value);
                 },
-                'parseLiteral' => function (NodeInterface $astNode) {
+                'parseLiteral' => function(NodeInterface $astNode) {
                     /** @var StringValueNode $astNode */
                     return $astNode->getKind() === NodeKindEnum::STRING ? $astNode->getValue() : null;
                 },