View GitHub Repository graphql-php

Schedule Inspection
Subscribe
Completed
Pull Request — master (#33)
by Sam
02:19
created
Status
Category
Toggle Patches
src/Provider/ScalarTypesProvider.php 1 patch
Spacing   +20 added lines, -20 removed lines patch added patch discarded remove patch 
@@ -36,38 +36,38 @@  discard block
 
 block discarded – undo
36 36 
      */
37 37 
     public function register()
38 38 
     {
39 
-        $this->container->add(GraphQL::BOOLEAN, function () {
39 
+        $this->container->add(GraphQL::BOOLEAN, function() {
40 40 
             return GraphQLScalarType([
41 41 
                 'name'        => TypeNameEnum::BOOLEAN,
42 42 
                 'description' => 'The `Boolean` scalar type represents `true` or `false`.',
43 
-                'serialize'   => function ($value) {
43 
+                'serialize'   => function($value) {
44 44 
                     return coerceBoolean($value);
45 45 
                 },
46 
-                'parseValue'  => function ($value) {
46 
+                'parseValue'  => function($value) {
47 47 
                     return coerceBoolean($value);
48 48 
                 },
49 49
50 
-                'parseLiteral' => function (NodeInterface $astNode) {
50 
+                'parseLiteral' => function(NodeInterface $astNode) {
51 51 
                     /** @var BooleanValueNode $astNode */
52 52 
                     return $astNode->getKind() === NodeKindEnum::BOOLEAN ? $astNode->getValue() : null;
53 53 
                 },
54 54 
             ]);
55 55 
         }, true/* $shared */);
56 56
57 
-        $this->container->add(GraphQL::FLOAT, function () {
57 
+        $this->container->add(GraphQL::FLOAT, function() {
58 58 
             return GraphQLScalarType([
59 59 
                 'name'         => TypeNameEnum::FLOAT,
60 60 
                 'description'  =>
61 61 
                     'The `Float` scalar type represents signed double-precision fractional ' .
62 62 
                     'values as specified by ' .
63 63 
                     '[IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point).',
64 
-                'serialize'    => function ($value) {
64 
+                'serialize'    => function($value) {
65 65 
                     return coerceFloat($value);
66 66 
                 },
67 
-                'parseValue'   => function ($value) {
67 
+                'parseValue'   => function($value) {
68 68 
                     return coerceFloat($value);
69 69 
                 },
70 
-                'parseLiteral' => function (NodeInterface $astNode) {
70 
+                'parseLiteral' => function(NodeInterface $astNode) {
71 71 
                     /** @var FloatValueNode $astNode */
72 72 
                     return $astNode->getKind() === NodeKindEnum::FLOAT || $astNode->getKind() === NodeKindEnum::INT
73 73 
                         ? $astNode->getValue()
 
@@ -76,26 +76,26 @@  discard block
 
 block discarded – undo
76 76 
             ]);
77 77 
         }, true/* $shared */);
78 78
79 
-        $this->container->add(GraphQL::INT, function () {
79 
+        $this->container->add(GraphQL::INT, function() {
80 80 
             return GraphQLScalarType([
81 81 
                 'name'         => TypeNameEnum::INT,
82 82 
                 'description'  =>
83 83 
                     'The `Int` scalar type represents non-fractional signed whole numeric ' .
84 84 
                     'values. Int can represent values between -(2^31) and 2^31 - 1.',
85 
-                'serialize'    => function ($value) {
85 
+                'serialize'    => function($value) {
86 86 
                     return coerceInt($value);
87 87 
                 },
88 
-                'parseValue'   => function ($value) {
88 
+                'parseValue'   => function($value) {
89 89 
                     return coerceInt($value);
90 90 
                 },
91 
-                'parseLiteral' => function (NodeInterface $astNode) {
91 
+                'parseLiteral' => function(NodeInterface $astNode) {
92 92 
                     /** @var IntValueNode $astNode */
93 93 
                     return $astNode->getKind() === NodeKindEnum::INT ? $astNode->getValue() : null;
94 94 
                 },
95 95 
             ]);
96 96 
         }, true/* $shared */);
97 97
98 
-        $this->container->add(GraphQL::ID, function () {
98 
+        $this->container->add(GraphQL::ID, function() {
99 99 
             return GraphQLScalarType([
100 100 
                 'name'         => TypeNameEnum::ID,
101 101 
                 'description'  =>
 
@@ -104,13 +104,13 @@  discard block
 
 block discarded – undo
104 104 
                     'response as a String; however, it is not intended to be human-readable. ' .
105 105 
                     'When expected as an input type, any string (such as `"4"`) or integer ' .
106 106 
                     '(such as `4`) input value will be accepted as an ID.',
107 
-                'serialize'    => function ($value) {
107 
+                'serialize'    => function($value) {
108 108 
                     return coerceString($value);
109 109 
                 },
110 
-                'parseValue'   => function ($value) {
110 
+                'parseValue'   => function($value) {
111 111 
                     return coerceString($value);
112 112 
                 },
113 
-                'parseLiteral' => function (NodeInterface $astNode) {
113 
+                'parseLiteral' => function(NodeInterface $astNode) {
114 114 
                     /** @var StringValueNode $astNode */
115 115 
                     return $astNode->getKind() === NodeKindEnum::STRING || $astNode->getKind() === NodeKindEnum::INT
116 116 
                         ? $astNode->getValue()
 
@@ -119,20 +119,20 @@  discard block
 
 block discarded – undo
119 119 
             ]);
120 120 
         }, true/* $shared */);
121 121
122 
-        $this->container->add(GraphQL::STRING, function () {
122 
+        $this->container->add(GraphQL::STRING, function() {
123 123 
             return GraphQLScalarType([
124 124 
                 'name'         => TypeNameEnum::STRING,
125 125 
                 'description'  =>
126 126 
                     'The `String` scalar type represents textual data, represented as UTF-8 ' .
127 127 
                     'character sequences. The String type is most often used by GraphQL to ' .
128 128 
                     'represent free-form human-readable text.',
129 
-                'serialize'    => function ($value) {
129 
+                'serialize'    => function($value) {
130 130 
                     return coerceString($value);
131 131 
                 },
132 
-                'parseValue'   => function ($value) {
132 
+                'parseValue'   => function($value) {
133 133 
                     return coerceString($value);
134 134 
                 },
135 
-                'parseLiteral' => function (NodeInterface $astNode) {
135 
+                'parseLiteral' => function(NodeInterface $astNode) {
136 136 
                     /** @var StringValueNode $astNode */
137 137 
                     return $astNode->getKind() === NodeKindEnum::STRING ? $astNode->getValue() : null;
138 138 
                 },
Please login to merge, or discard this patch.