@@ -80,7 +80,7 @@ discard block  | 
                                                    ||
| 80 | 80 | */  | 
                                                        
| 81 | 81 | private function validateBatchOption($shouldBatch)  | 
                                                        
| 82 | 82 |      { | 
                                                        
| 83 | -        if (!\is_bool($shouldBatch)) { | 
                                                        |
| 83 | +        if ( ! \is_bool($shouldBatch)) { | 
                                                        |
| 84 | 84 |              throw new \InvalidArgumentException('Expected argument $shouldBatch to be a boolean'); | 
                                                        
| 85 | 85 | }  | 
                                                        
| 86 | 86 | }  | 
                                                        
@@ -90,7 +90,7 @@ discard block  | 
                                                    ||
| 90 | 90 | */  | 
                                                        
| 91 | 91 | private function validateCacheOption($shouldCache)  | 
                                                        
| 92 | 92 |      { | 
                                                        
| 93 | -        if (!\is_bool($shouldCache)) { | 
                                                        |
| 93 | +        if ( ! \is_bool($shouldCache)) { | 
                                                        |
| 94 | 94 |              throw new \InvalidArgumentException('Expected argument $shouldCache to be a boolean'); | 
                                                        
| 95 | 95 | }  | 
                                                        
| 96 | 96 | }  | 
                                                        
@@ -100,7 +100,7 @@ discard block  | 
                                                    ||
| 100 | 100 | */  | 
                                                        
| 101 | 101 | private function validateMaxBatchSizeOption($maxBatchSize)  | 
                                                        
| 102 | 102 |      { | 
                                                        
| 103 | -        if ($maxBatchSize !== null && !\is_int($maxBatchSize)) { | 
                                                        |
| 103 | +        if ($maxBatchSize !== null && ! \is_int($maxBatchSize)) { | 
                                                        |
| 104 | 104 |              throw new \InvalidArgumentException('Expected argument $maxBatchSize to be null or an integer'); | 
                                                        
| 105 | 105 | }  | 
                                                        
| 106 | 106 | }  | 
                                                        
@@ -67,7 +67,7 @@ discard block  | 
                                                    ||
| 67 | 67 | }  | 
                                                        
| 68 | 68 | |
| 69 | 69 | $promise = new Promise(  | 
                                                        
| 70 | -            function (callable $resolve, callable $reject) use ($key) { | 
                                                        |
| 70 | +            function(callable $resolve, callable $reject) use ($key) { | 
                                                        |
| 71 | 71 | $this->promiseQueue[] = [  | 
                                                        
| 72 | 72 | 'key' => $key,  | 
                                                        
| 73 | 73 | 'resolve' => $resolve,  | 
                                                        
@@ -94,7 +94,7 @@ discard block  | 
                                                    ||
| 94 | 94 |      { | 
                                                        
| 95 | 95 | return \React\Promise\all(  | 
                                                        
| 96 | 96 | \array_map(  | 
                                                        
| 97 | -                function ($key) { | 
                                                        |
| 97 | +                function($key) { | 
                                                        |
| 98 | 98 | return $this->load($key);  | 
                                                        
| 99 | 99 | },  | 
                                                        
| 100 | 100 | $keys  | 
                                                        
@@ -127,7 +127,7 @@ discard block  | 
                                                    ||
| 127 | 127 | */  | 
                                                        
| 128 | 128 | public function prime($key, $value)  | 
                                                        
| 129 | 129 |      { | 
                                                        
| 130 | -        if (! $this->promiseCache->get($key)) { | 
                                                        |
| 130 | +        if ( ! $this->promiseCache->get($key)) { | 
                                                        |
| 131 | 131 | // Cache a rejected promise if the value is an Exception, in order to match  | 
                                                        
| 132 | 132 | // the behavior of load($key).  | 
                                                        
| 133 | 133 | $promise = $value instanceof \Exception ? \React\Promise\reject($value) : \React\Promise\resolve($value);  | 
                                                        
@@ -148,7 +148,7 @@ discard block  | 
                                                    ||
| 148 | 148 |      { | 
                                                        
| 149 | 149 |          if ($this->options->shouldBatch()) { | 
                                                        
| 150 | 150 | $this->eventLoop->nextTick(  | 
                                                        
| 151 | -                function () { | 
                                                        |
| 151 | +                function() { | 
                                                        |
| 152 | 152 | $this->dispatchQueue();  | 
                                                        
| 153 | 153 | }  | 
                                                        
| 154 | 154 | );  | 
                                                        
@@ -191,7 +191,7 @@ discard block  | 
                                                    ||
| 191 | 191 | /** @var Promise $batchPromise */  | 
                                                        
| 192 | 192 | $batchPromise = $batchLoadFunction($keys);  | 
                                                        
| 193 | 193 | |
| 194 | -        if (! $batchPromise || ! \is_callable([$batchPromise, 'then'])) { | 
                                                        |
| 194 | +        if ( ! $batchPromise || ! \is_callable([$batchPromise, 'then'])) { | 
                                                        |
| 195 | 195 | return $this->handleFailedDispatch($batch, new DataLoaderException(  | 
                                                        
| 196 | 196 | self::class . ' must be constructed with a function which accepts ' .  | 
                                                        
| 197 | 197 | 'an array of keys and returns a Promise which resolves to an array of values ' .  | 
                                                        
@@ -200,11 +200,11 @@ discard block  | 
                                                    ||
| 200 | 200 | }  | 
                                                        
| 201 | 201 | |
| 202 | 202 | $batchPromise->then(  | 
                                                        
| 203 | -            function ($values) use ($batch, $keys) { | 
                                                        |
| 203 | +            function($values) use ($batch, $keys) { | 
                                                        |
| 204 | 204 | $this->validateBatchPromiseOutput($values, $keys);  | 
                                                        
| 205 | 205 | $this->handleSuccessfulDispatch($batch, $values);  | 
                                                        
| 206 | 206 | }  | 
                                                        
| 207 | -        )->then(null, function ($error) use ($batch) { | 
                                                        |
| 207 | +        )->then(null, function($error) use ($batch) { | 
                                                        |
| 208 | 208 | $this->handleFailedDispatch($batch, $error);  | 
                                                        
| 209 | 209 | });  | 
                                                        
| 210 | 210 | }  | 
                                                        
@@ -269,7 +269,7 @@ discard block  | 
                                                    ||
| 269 | 269 | */  | 
                                                        
| 270 | 270 | private function validateBatchPromiseOutput($values, $keys)  | 
                                                        
| 271 | 271 |      { | 
                                                        
| 272 | -        if (! \is_array($values)) { | 
                                                        |
| 272 | +        if ( ! \is_array($values)) { | 
                                                        |
| 273 | 273 | throw new DataLoaderException(  | 
                                                        
| 274 | 274 | self::class . ' must be constructed with a function which accepts ' .  | 
                                                        
| 275 | 275 | 'an array of keys and returns a Promise which resolves to an array of values ' .  |