WebSVN – Moodle – Diff – /lib/guzzlehttp/promises/src/Utils.php

 <?php
+declare(strict_types=1);
 namespace GuzzleHttp\Promise;
 final class Utils
      * while ($eventLoop->isRunning()) {
      *     GuzzleHttp\Promise\Utils::queue()->run();
      * }
      * </code>
+     *
-     * @param TaskQueueInterface $assign Optionally specify a new queue instance.
+     * @param TaskQueueInterface|null $assign Optionally specify a new queue instance.
-     *
-     * @return TaskQueueInterface
      */
-    public static function queue(TaskQueueInterface $assign = null)
+    public static function queue(?TaskQueueInterface $assign = null): TaskQueueInterface
+    {
         static $queue;
         if ($assign) {
     /**
      * Adds a function to run in the task queue when it is next `run()` and
      * returns a promise that is fulfilled or rejected with the result.
+     *
      * @param callable $task Task function to run.
-     *
-     * @return PromiseInterface
      */
-    public static function task(callable $task)
+    public static function task(callable $task): PromiseInterface
+    {
         $queue = self::queue();
         $promise = new Promise([$queue, 'run']);
-        $queue->add(function () use ($task, $promise) {
+        $queue->add(function () use ($task, $promise): void {
             try {
                 if (Is::pending($promise)) {
                     $promise->resolve($task());
+                }
             } catch (\Throwable $e) {
                 $promise->reject($e);
-            } catch (\Exception $e) {
-                $promise->reject($e);
+            }
         });
         return $promise;
      * array will contain a "value" key mapping to the fulfilled value of the
      * promise. If the promise is rejected, the array will contain a "reason"
      * key mapping to the rejection reason of the promise.
+     *
      * @param PromiseInterface $promise Promise or value.
-     *
-     * @return array
      */
-    public static function inspect(PromiseInterface $promise)
+    public static function inspect(PromiseInterface $promise): array
+    {
         try {
             return [
                 'state' => PromiseInterface::FULFILLED,
-                'value' => $promise->wait()
+                'value' => $promise->wait(),
             ];
         } catch (RejectionException $e) {
             return ['state' => PromiseInterface::REJECTED, 'reason' => $e->getReason()];
         } catch (\Throwable $e) {
             return ['state' => PromiseInterface::REJECTED, 'reason' => $e];
-        } catch (\Exception $e) {
-            return ['state' => PromiseInterface::REJECTED, 'reason' => $e];
+        }
+    }
     /**
      * Returns an array of inspection state arrays.
+     *
      * @see inspect for the inspection state array format.
+     *
      * @param PromiseInterface[] $promises Traversable of promises to wait upon.
-     *
-     * @return array
      */
-    public static function inspectAll($promises)
+    public static function inspectAll($promises): array
+    {
         $results = [];
         foreach ($promises as $key => $promise) {
-            $results[$key] = inspect($promise);
+            $results[$key] = self::inspect($promise);
+        }
         return $results;
      * order the promises were provided). An exception is thrown if any of the
      * promises are rejected.
+     *
      * @param iterable<PromiseInterface> $promises Iterable of PromiseInterface objects to wait on.
+     *
-     * @return array
-     *
-     * @throws \Exception on error
+     * @throws \Throwable on error
-     * @throws \Throwable on error in PHP >=7
      */
-    public static function unwrap($promises)
+    public static function unwrap($promises): array
+    {
         $results = [];
         foreach ($promises as $key => $promise) {
             $results[$key] = $promise->wait();
+        }
      * respective positions to the original array. If any promise in the array
      * rejects, the returned promise is rejected with the rejection reason.
+     *
      * @param mixed $promises  Promises or values.
      * @param bool  $recursive If true, resolves new promises that might have been added to the stack during its own resolution.
-     *
-     * @return PromiseInterface
      */
-    public static function all($promises, $recursive = false)
+    public static function all($promises, bool $recursive = false): PromiseInterface
+    {
         $results = [];
         $promise = Each::of(
             $promises,
-            function ($value, $idx) use (&$results) {
+            function ($value, $idx) use (&$results): void {
                 $results[$idx] = $value;
             },
-            function ($reason, $idx, Promise $aggregate) {
+            function ($reason, $idx, Promise $aggregate): void {
+                if (Is::pending($aggregate)) {
-                $aggregate->reject($reason);
+                    $aggregate->reject($reason);
+                }
+            }
         )->then(function () use (&$results) {
             ksort($results);
             return $results;
         });
         if (true === $recursive) {
             $promise = $promise->then(function ($results) use ($recursive, &$promises) {
                 foreach ($promises as $promise) {
                     if (Is::pending($promise)) {
                         return self::all($promises, $recursive);
+                    }
+                }
                 return $results;
             });
+        }
      * This promise is rejected with a {@see AggregateException} if the number
      * of fulfilled promises is less than the desired $count.
+     *
      * @param int   $count    Total number of promises.
      * @param mixed $promises Promises or values.
-     *
-     * @return PromiseInterface
      */
-    public static function some($count, $promises)
+    public static function some(int $count, $promises): PromiseInterface
+    {
         $results = [];
         $rejections = [];
         return Each::of(
             $promises,
-            function ($value, $idx, PromiseInterface $p) use (&$results, $count) {
+            function ($value, $idx, PromiseInterface $p) use (&$results, $count): void {
                 if (Is::settled($p)) {
                     return;
+                }
                 $results[$idx] = $value;
                 if (count($results) >= $count) {
                     $p->resolve(null);
+                }
             },
-            function ($reason) use (&$rejections) {
+            function ($reason) use (&$rejections): void {
                 $rejections[] = $reason;
+            }
         )->then(
             function () use (&$results, &$rejections, $count) {
                         'Not enough promises to fulfill count',
                         $rejections
                     );
+                }
                 ksort($results);
                 return array_values($results);
+            }
         );
+    }
     /**
      * Like some(), with 1 as count. However, if the promise fulfills, the
      * fulfillment value is not an array of 1 but the value directly.
+     *
-     * @param mixed $promises Promises or values.
-     *
-     * @return PromiseInterface
+     * @param mixed $promises Promises or values.
      */
-    public static function any($promises)
+    public static function any($promises): PromiseInterface
+    {
         return self::some(1, $promises)->then(function ($values) {
             return $values[0];
         });
      * The returned promise is fulfilled with an array of inspection state arrays.
+     *
      * @see inspect for the inspection state array format.
+     *
      * @param mixed $promises Promises or values.
-     *
-     * @return PromiseInterface
      */
-    public static function settle($promises)
+    public static function settle($promises): PromiseInterface
+    {
         $results = [];
         return Each::of(
             $promises,
-            function ($value, $idx) use (&$results) {
+            function ($value, $idx) use (&$results): void {
                 $results[$idx] = ['state' => PromiseInterface::FULFILLED, 'value' => $value];
             },
-            function ($reason, $idx) use (&$results) {
+            function ($reason, $idx) use (&$results): void {
                 $results[$idx] = ['state' => PromiseInterface::REJECTED, 'reason' => $reason];
+            }
         )->then(function () use (&$results) {
+            ksort($results);
             ksort($results);
             return $results;
         });
+    }

Proyectos de Subversion Moodle

(root)/lib/guzzlehttp/promises/src/Utils.php – Rev 1 → 1441