nextcloud / fulltextsearch_elasticsearch

lib/Vendor/GuzzleHttp/Promise/TaskQueueInterface.php

Indentation +13 added lines, -13 removed lines

@@ -6,19 +6,19 @@
 
 interface TaskQueueInterface
 {
-    /**
-     * Returns true if the queue is empty.
-     */
-    public function isEmpty(): bool;
+	/**
+	 * Returns true if the queue is empty.
+	 */
+	public function isEmpty(): bool;
 
-    /**
-     * Adds a task to the queue that will be executed the next time run is
-     * called.
-     */
-    public function add(callable $task): void;
+	/**
+	 * Adds a task to the queue that will be executed the next time run is
+	 * called.
+	 */
+	public function add(callable $task): void;
 
-    /**
-     * Execute all of the pending task in the queue.
-     */
-    public function run(): void;
+	/**
+	 * Execute all of the pending task in the queue.
+	 */
+	public function run(): void;
 }

Braces +1 added lines, -2 removed lines

@@ -4,8 +4,7 @@
 
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
-interface TaskQueueInterface
-{
+interface TaskQueueInterface {
     /**
      * Returns true if the queue is empty.
      */

lib/Vendor/GuzzleHttp/Promise/FulfilledPromise.php

Indentation +61 added lines, -61 removed lines

@@ -14,76 +14,76 @@
  */
 class FulfilledPromise implements PromiseInterface
 {
-    private $value;
+	private $value;
 
-    /**
-     * @param mixed $value
-     */
-    public function __construct($value)
-    {
-        if (is_object($value) && method_exists($value, 'then')) {
-            throw new \InvalidArgumentException(
-                'You cannot create a FulfilledPromise with a promise.'
-            );
-        }
+	/**
+	 * @param mixed $value
+	 */
+	public function __construct($value)
+	{
+		if (is_object($value) && method_exists($value, 'then')) {
+			throw new \InvalidArgumentException(
+				'You cannot create a FulfilledPromise with a promise.'
+			);
+		}
 
-        $this->value = $value;
-    }
+		$this->value = $value;
+	}
 
-    public function then(
-        callable $onFulfilled = null,
-        callable $onRejected = null
-    ): PromiseInterface {
-        // Return itself if there is no onFulfilled function.
-        if (!$onFulfilled) {
-            return $this;
-        }
+	public function then(
+		callable $onFulfilled = null,
+		callable $onRejected = null
+	): PromiseInterface {
+		// Return itself if there is no onFulfilled function.
+		if (!$onFulfilled) {
+			return $this;
+		}
 
-        $queue = Utils::queue();
-        $p = new Promise([$queue, 'run']);
-        $value = $this->value;
-        $queue->add(static function () use ($p, $value, $onFulfilled): void {
-            if (Is::pending($p)) {
-                try {
-                    $p->resolve($onFulfilled($value));
-                } catch (\Throwable $e) {
-                    $p->reject($e);
-                }
-            }
-        });
+		$queue = Utils::queue();
+		$p = new Promise([$queue, 'run']);
+		$value = $this->value;
+		$queue->add(static function () use ($p, $value, $onFulfilled): void {
+			if (Is::pending($p)) {
+				try {
+					$p->resolve($onFulfilled($value));
+				} catch (\Throwable $e) {
+					$p->reject($e);
+				}
+			}
+		});
 
-        return $p;
-    }
+		return $p;
+	}
 
-    public function otherwise(callable $onRejected): PromiseInterface
-    {
-        return $this->then(null, $onRejected);
-    }
+	public function otherwise(callable $onRejected): PromiseInterface
+	{
+		return $this->then(null, $onRejected);
+	}
 
-    public function wait(bool $unwrap = true)
-    {
-        return $unwrap ? $this->value : null;
-    }
+	public function wait(bool $unwrap = true)
+	{
+		return $unwrap ? $this->value : null;
+	}
 
-    public function getState(): string
-    {
-        return self::FULFILLED;
-    }
+	public function getState(): string
+	{
+		return self::FULFILLED;
+	}
 
-    public function resolve($value): void
-    {
-        if ($value !== $this->value) {
-            throw new \LogicException('Cannot resolve a fulfilled promise');
-        }
-    }
+	public function resolve($value): void
+	{
+		if ($value !== $this->value) {
+			throw new \LogicException('Cannot resolve a fulfilled promise');
+		}
+	}
 
-    public function reject($reason): void
-    {
-        throw new \LogicException('Cannot reject a fulfilled promise');
-    }
+	public function reject($reason): void
+	{
+		throw new \LogicException('Cannot reject a fulfilled promise');
+	}
 
-    public function cancel(): void
-    {
-        // pass
-    }
+	public function cancel(): void
+	{
+		// pass
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -42,7 +42,7 @@
         $queue = Utils::queue();
         $p = new Promise([$queue, 'run']);
         $value = $this->value;
-        $queue->add(static function () use ($p, $value, $onFulfilled): void {
+        $queue->add(static function() use ($p, $value, $onFulfilled): void {
             if (Is::pending($p)) {
                 try {
                     $p->resolve($onFulfilled($value));

Braces +1 added lines, -2 removed lines

@@ -12,8 +12,7 @@
  *
  * @final
  */
-class FulfilledPromise implements PromiseInterface
-{
+class FulfilledPromise implements PromiseInterface {
     private $value;
 
     /**

lib/Vendor/GuzzleHttp/Promise/Create.php

Indentation +60 added lines, -60 removed lines

@@ -6,74 +6,74 @@
 
 final class Create
 {
-    /**
-     * Creates a promise for a value if the value is not a promise.
-     *
-     * @param mixed $value Promise or value.
-     */
-    public static function promiseFor($value): PromiseInterface
-    {
-        if ($value instanceof PromiseInterface) {
-            return $value;
-        }
+	/**
+	 * Creates a promise for a value if the value is not a promise.
+	 *
+	 * @param mixed $value Promise or value.
+	 */
+	public static function promiseFor($value): PromiseInterface
+	{
+		if ($value instanceof PromiseInterface) {
+			return $value;
+		}
 
-        // Return a Guzzle promise that shadows the given promise.
-        if (is_object($value) && method_exists($value, 'then')) {
-            $wfn = method_exists($value, 'wait') ? [$value, 'wait'] : null;
-            $cfn = method_exists($value, 'cancel') ? [$value, 'cancel'] : null;
-            $promise = new Promise($wfn, $cfn);
-            $value->then([$promise, 'resolve'], [$promise, 'reject']);
+		// Return a Guzzle promise that shadows the given promise.
+		if (is_object($value) && method_exists($value, 'then')) {
+			$wfn = method_exists($value, 'wait') ? [$value, 'wait'] : null;
+			$cfn = method_exists($value, 'cancel') ? [$value, 'cancel'] : null;
+			$promise = new Promise($wfn, $cfn);
+			$value->then([$promise, 'resolve'], [$promise, 'reject']);
 
-            return $promise;
-        }
+			return $promise;
+		}
 
-        return new FulfilledPromise($value);
-    }
+		return new FulfilledPromise($value);
+	}
 
-    /**
-     * Creates a rejected promise for a reason if the reason is not a promise.
-     * If the provided reason is a promise, then it is returned as-is.
-     *
-     * @param mixed $reason Promise or reason.
-     */
-    public static function rejectionFor($reason): PromiseInterface
-    {
-        if ($reason instanceof PromiseInterface) {
-            return $reason;
-        }
+	/**
+	 * Creates a rejected promise for a reason if the reason is not a promise.
+	 * If the provided reason is a promise, then it is returned as-is.
+	 *
+	 * @param mixed $reason Promise or reason.
+	 */
+	public static function rejectionFor($reason): PromiseInterface
+	{
+		if ($reason instanceof PromiseInterface) {
+			return $reason;
+		}
 
-        return new RejectedPromise($reason);
-    }
+		return new RejectedPromise($reason);
+	}
 
-    /**
-     * Create an exception for a rejected promise value.
-     *
-     * @param mixed $reason
-     */
-    public static function exceptionFor($reason): \Throwable
-    {
-        if ($reason instanceof \Throwable) {
-            return $reason;
-        }
+	/**
+	 * Create an exception for a rejected promise value.
+	 *
+	 * @param mixed $reason
+	 */
+	public static function exceptionFor($reason): \Throwable
+	{
+		if ($reason instanceof \Throwable) {
+			return $reason;
+		}
 
-        return new RejectionException($reason);
-    }
+		return new RejectionException($reason);
+	}
 
-    /**
-     * Returns an iterator for the given value.
-     *
-     * @param mixed $value
-     */
-    public static function iterFor($value): \Iterator
-    {
-        if ($value instanceof \Iterator) {
-            return $value;
-        }
+	/**
+	 * Returns an iterator for the given value.
+	 *
+	 * @param mixed $value
+	 */
+	public static function iterFor($value): \Iterator
+	{
+		if ($value instanceof \Iterator) {
+			return $value;
+		}
 
-        if (is_array($value)) {
-            return new \ArrayIterator($value);
-        }
+		if (is_array($value)) {
+			return new \ArrayIterator($value);
+		}
 
-        return new \ArrayIterator([$value]);
-    }
+		return new \ArrayIterator([$value]);
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -4,8 +4,7 @@
 
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
-final class Create
-{
+final class Create {
     /**
      * Creates a promise for a value if the value is not a promise.
      *

lib/Vendor/GuzzleHttp/Promise/PromiseInterface.php

Indentation +66 added lines, -66 removed lines

@@ -15,77 +15,77 @@
  */
 interface PromiseInterface
 {
-    public const PENDING = 'pending';
-    public const FULFILLED = 'fulfilled';
-    public const REJECTED = 'rejected';
+	public const PENDING = 'pending';
+	public const FULFILLED = 'fulfilled';
+	public const REJECTED = 'rejected';
 
-    /**
-     * Appends fulfillment and rejection handlers to the promise, and returns
-     * a new promise resolving to the return value of the called handler.
-     *
-     * @param callable $onFulfilled Invoked when the promise fulfills.
-     * @param callable $onRejected  Invoked when the promise is rejected.
-     */
-    public function then(
-        callable $onFulfilled = null,
-        callable $onRejected = null
-    ): PromiseInterface;
+	/**
+	 * Appends fulfillment and rejection handlers to the promise, and returns
+	 * a new promise resolving to the return value of the called handler.
+	 *
+	 * @param callable $onFulfilled Invoked when the promise fulfills.
+	 * @param callable $onRejected  Invoked when the promise is rejected.
+	 */
+	public function then(
+		callable $onFulfilled = null,
+		callable $onRejected = null
+	): PromiseInterface;
 
-    /**
-     * Appends a rejection handler callback to the promise, and returns a new
-     * promise resolving to the return value of the callback if it is called,
-     * or to its original fulfillment value if the promise is instead
-     * fulfilled.
-     *
-     * @param callable $onRejected Invoked when the promise is rejected.
-     */
-    public function otherwise(callable $onRejected): PromiseInterface;
+	/**
+	 * Appends a rejection handler callback to the promise, and returns a new
+	 * promise resolving to the return value of the callback if it is called,
+	 * or to its original fulfillment value if the promise is instead
+	 * fulfilled.
+	 *
+	 * @param callable $onRejected Invoked when the promise is rejected.
+	 */
+	public function otherwise(callable $onRejected): PromiseInterface;
 
-    /**
-     * Get the state of the promise ("pending", "rejected", or "fulfilled").
-     *
-     * The three states can be checked against the constants defined on
-     * PromiseInterface: PENDING, FULFILLED, and REJECTED.
-     */
-    public function getState(): string;
+	/**
+	 * Get the state of the promise ("pending", "rejected", or "fulfilled").
+	 *
+	 * The three states can be checked against the constants defined on
+	 * PromiseInterface: PENDING, FULFILLED, and REJECTED.
+	 */
+	public function getState(): string;
 
-    /**
-     * Resolve the promise with the given value.
-     *
-     * @param mixed $value
-     *
-     * @throws \RuntimeException if the promise is already resolved.
-     */
-    public function resolve($value): void;
+	/**
+	 * Resolve the promise with the given value.
+	 *
+	 * @param mixed $value
+	 *
+	 * @throws \RuntimeException if the promise is already resolved.
+	 */
+	public function resolve($value): void;
 
-    /**
-     * Reject the promise with the given reason.
-     *
-     * @param mixed $reason
-     *
-     * @throws \RuntimeException if the promise is already resolved.
-     */
-    public function reject($reason): void;
+	/**
+	 * Reject the promise with the given reason.
+	 *
+	 * @param mixed $reason
+	 *
+	 * @throws \RuntimeException if the promise is already resolved.
+	 */
+	public function reject($reason): void;
 
-    /**
-     * Cancels the promise if possible.
-     *
-     * @see https://github.com/promises-aplus/cancellation-spec/issues/7
-     */
-    public function cancel(): void;
+	/**
+	 * Cancels the promise if possible.
+	 *
+	 * @see https://github.com/promises-aplus/cancellation-spec/issues/7
+	 */
+	public function cancel(): void;
 
-    /**
-     * Waits until the promise completes if possible.
-     *
-     * Pass $unwrap as true to unwrap the result of the promise, either
-     * returning the resolved value or throwing the rejected exception.
-     *
-     * If the promise cannot be waited on, then the promise will be rejected.
-     *
-     * @return mixed
-     *
-     * @throws \LogicException if the promise has no wait function or if the
-     *                         promise does not settle after waiting.
-     */
-    public function wait(bool $unwrap = true);
+	/**
+	 * Waits until the promise completes if possible.
+	 *
+	 * Pass $unwrap as true to unwrap the result of the promise, either
+	 * returning the resolved value or throwing the rejected exception.
+	 *
+	 * If the promise cannot be waited on, then the promise will be rejected.
+	 *
+	 * @return mixed
+	 *
+	 * @throws \LogicException if the promise has no wait function or if the
+	 *                         promise does not settle after waiting.
+	 */
+	public function wait(bool $unwrap = true);
 }

Braces +1 added lines, -2 removed lines

@@ -13,8 +13,7 @@
  *
  * @see https://promisesaplus.com/
  */
-interface PromiseInterface
-{
+interface PromiseInterface {
     public const PENDING = 'pending';
     public const FULFILLED = 'fulfilled';
     public const REJECTED = 'rejected';

lib/Vendor/GuzzleHttp/Promise/CancellationException.php

Braces +1 added lines, -2 removed lines

@@ -7,6 +7,5 @@
 /**
  * Exception that is set as the reason for a promise that has been cancelled.
  */
-class CancellationException extends RejectionException
-{
+class CancellationException extends RejectionException {
 }

lib/Vendor/GuzzleHttp/Promise/EachPromise.php

Indentation +233 added lines, -233 removed lines

@@ -12,237 +12,237 @@
  */
 class EachPromise implements PromisorInterface
 {
-    private $pending = [];
-
-    private $nextPendingIndex = 0;
-
-    /** @var \Iterator|null */
-    private $iterable;
-
-    /** @var callable|int|null */
-    private $concurrency;
-
-    /** @var callable|null */
-    private $onFulfilled;
-
-    /** @var callable|null */
-    private $onRejected;
-
-    /** @var Promise|null */
-    private $aggregate;
-
-    /** @var bool|null */
-    private $mutex;
-
-    /**
-     * Configuration hash can include the following key value pairs:
-     *
-     * - fulfilled: (callable) Invoked when a promise fulfills. The function
-     *   is invoked with three arguments: the fulfillment value, the index
-     *   position from the iterable list of the promise, and the aggregate
-     *   promise that manages all of the promises. The aggregate promise may
-     *   be resolved from within the callback to short-circuit the promise.
-     * - rejected: (callable) Invoked when a promise is rejected. The
-     *   function is invoked with three arguments: the rejection reason, the
-     *   index position from the iterable list of the promise, and the
-     *   aggregate promise that manages all of the promises. The aggregate
-     *   promise may be resolved from within the callback to short-circuit
-     *   the promise.
-     * - concurrency: (integer) Pass this configuration option to limit the
-     *   allowed number of outstanding concurrently executing promises,
-     *   creating a capped pool of promises. There is no limit by default.
-     *
-     * @param mixed $iterable Promises or values to iterate.
-     * @param array $config   Configuration options
-     */
-    public function __construct($iterable, array $config = [])
-    {
-        $this->iterable = Create::iterFor($iterable);
-
-        if (isset($config['concurrency'])) {
-            $this->concurrency = $config['concurrency'];
-        }
-
-        if (isset($config['fulfilled'])) {
-            $this->onFulfilled = $config['fulfilled'];
-        }
-
-        if (isset($config['rejected'])) {
-            $this->onRejected = $config['rejected'];
-        }
-    }
-
-    /** @psalm-suppress InvalidNullableReturnType */
-    public function promise(): PromiseInterface
-    {
-        if ($this->aggregate) {
-            return $this->aggregate;
-        }
-
-        try {
-            $this->createPromise();
-            /** @psalm-assert Promise $this->aggregate */
-            $this->iterable->rewind();
-            $this->refillPending();
-        } catch (\Throwable $e) {
-            $this->aggregate->reject($e);
-        }
-
-        /**
-         * @psalm-suppress NullableReturnStatement
-         */
-        return $this->aggregate;
-    }
-
-    private function createPromise(): void
-    {
-        $this->mutex = false;
-        $this->aggregate = new Promise(function (): void {
-            if ($this->checkIfFinished()) {
-                return;
-            }
-            reset($this->pending);
-            // Consume a potentially fluctuating list of promises while
-            // ensuring that indexes are maintained (precluding array_shift).
-            while ($promise = current($this->pending)) {
-                next($this->pending);
-                $promise->wait();
-                if (Is::settled($this->aggregate)) {
-                    return;
-                }
-            }
-        });
-
-        // Clear the references when the promise is resolved.
-        $clearFn = function (): void {
-            $this->iterable = $this->concurrency = $this->pending = null;
-            $this->onFulfilled = $this->onRejected = null;
-            $this->nextPendingIndex = 0;
-        };
-
-        $this->aggregate->then($clearFn, $clearFn);
-    }
-
-    private function refillPending(): void
-    {
-        if (!$this->concurrency) {
-            // Add all pending promises.
-            while ($this->addPending() && $this->advanceIterator()) {
-            }
-
-            return;
-        }
-
-        // Add only up to N pending promises.
-        $concurrency = is_callable($this->concurrency)
-            ? ($this->concurrency)(count($this->pending))
-            : $this->concurrency;
-        $concurrency = max($concurrency - count($this->pending), 0);
-        // Concurrency may be set to 0 to disallow new promises.
-        if (!$concurrency) {
-            return;
-        }
-        // Add the first pending promise.
-        $this->addPending();
-        // Note this is special handling for concurrency=1 so that we do
-        // not advance the iterator after adding the first promise. This
-        // helps work around issues with generators that might not have the
-        // next value to yield until promise callbacks are called.
-        while (--$concurrency
-            && $this->advanceIterator()
-            && $this->addPending()) {
-        }
-    }
-
-    private function addPending(): bool
-    {
-        if (!$this->iterable || !$this->iterable->valid()) {
-            return false;
-        }
-
-        $promise = Create::promiseFor($this->iterable->current());
-        $key = $this->iterable->key();
-
-        // Iterable keys may not be unique, so we use a counter to
-        // guarantee uniqueness
-        $idx = $this->nextPendingIndex++;
-
-        $this->pending[$idx] = $promise->then(
-            function ($value) use ($idx, $key): void {
-                if ($this->onFulfilled) {
-                    ($this->onFulfilled)(
-                        $value,
-                        $key,
-                        $this->aggregate
-                    );
-                }
-                $this->step($idx);
-            },
-            function ($reason) use ($idx, $key): void {
-                if ($this->onRejected) {
-                    ($this->onRejected)(
-                        $reason,
-                        $key,
-                        $this->aggregate
-                    );
-                }
-                $this->step($idx);
-            }
-        );
-
-        return true;
-    }
-
-    private function advanceIterator(): bool
-    {
-        // Place a lock on the iterator so that we ensure to not recurse,
-        // preventing fatal generator errors.
-        if ($this->mutex) {
-            return false;
-        }
-
-        $this->mutex = true;
-
-        try {
-            $this->iterable->next();
-            $this->mutex = false;
-
-            return true;
-        } catch (\Throwable $e) {
-            $this->aggregate->reject($e);
-            $this->mutex = false;
-
-            return false;
-        }
-    }
-
-    private function step(int $idx): void
-    {
-        // If the promise was already resolved, then ignore this step.
-        if (Is::settled($this->aggregate)) {
-            return;
-        }
-
-        unset($this->pending[$idx]);
-
-        // Only refill pending promises if we are not locked, preventing the
-        // EachPromise to recursively invoke the provided iterator, which
-        // cause a fatal error: "Cannot resume an already running generator"
-        if ($this->advanceIterator() && !$this->checkIfFinished()) {
-            // Add more pending promises if possible.
-            $this->refillPending();
-        }
-    }
-
-    private function checkIfFinished(): bool
-    {
-        if (!$this->pending && !$this->iterable->valid()) {
-            // Resolve the promise if there's nothing left to do.
-            $this->aggregate->resolve(null);
-
-            return true;
-        }
-
-        return false;
-    }
+	private $pending = [];
+
+	private $nextPendingIndex = 0;
+
+	/** @var \Iterator|null */
+	private $iterable;
+
+	/** @var callable|int|null */
+	private $concurrency;
+
+	/** @var callable|null */
+	private $onFulfilled;
+
+	/** @var callable|null */
+	private $onRejected;
+
+	/** @var Promise|null */
+	private $aggregate;
+
+	/** @var bool|null */
+	private $mutex;
+
+	/**
+	 * Configuration hash can include the following key value pairs:
+	 *
+	 * - fulfilled: (callable) Invoked when a promise fulfills. The function
+	 *   is invoked with three arguments: the fulfillment value, the index
+	 *   position from the iterable list of the promise, and the aggregate
+	 *   promise that manages all of the promises. The aggregate promise may
+	 *   be resolved from within the callback to short-circuit the promise.
+	 * - rejected: (callable) Invoked when a promise is rejected. The
+	 *   function is invoked with three arguments: the rejection reason, the
+	 *   index position from the iterable list of the promise, and the
+	 *   aggregate promise that manages all of the promises. The aggregate
+	 *   promise may be resolved from within the callback to short-circuit
+	 *   the promise.
+	 * - concurrency: (integer) Pass this configuration option to limit the
+	 *   allowed number of outstanding concurrently executing promises,
+	 *   creating a capped pool of promises. There is no limit by default.
+	 *
+	 * @param mixed $iterable Promises or values to iterate.
+	 * @param array $config   Configuration options
+	 */
+	public function __construct($iterable, array $config = [])
+	{
+		$this->iterable = Create::iterFor($iterable);
+
+		if (isset($config['concurrency'])) {
+			$this->concurrency = $config['concurrency'];
+		}
+
+		if (isset($config['fulfilled'])) {
+			$this->onFulfilled = $config['fulfilled'];
+		}
+
+		if (isset($config['rejected'])) {
+			$this->onRejected = $config['rejected'];
+		}
+	}
+
+	/** @psalm-suppress InvalidNullableReturnType */
+	public function promise(): PromiseInterface
+	{
+		if ($this->aggregate) {
+			return $this->aggregate;
+		}
+
+		try {
+			$this->createPromise();
+			/** @psalm-assert Promise $this->aggregate */
+			$this->iterable->rewind();
+			$this->refillPending();
+		} catch (\Throwable $e) {
+			$this->aggregate->reject($e);
+		}
+
+		/**
+		 * @psalm-suppress NullableReturnStatement
+		 */
+		return $this->aggregate;
+	}
+
+	private function createPromise(): void
+	{
+		$this->mutex = false;
+		$this->aggregate = new Promise(function (): void {
+			if ($this->checkIfFinished()) {
+				return;
+			}
+			reset($this->pending);
+			// Consume a potentially fluctuating list of promises while
+			// ensuring that indexes are maintained (precluding array_shift).
+			while ($promise = current($this->pending)) {
+				next($this->pending);
+				$promise->wait();
+				if (Is::settled($this->aggregate)) {
+					return;
+				}
+			}
+		});
+
+		// Clear the references when the promise is resolved.
+		$clearFn = function (): void {
+			$this->iterable = $this->concurrency = $this->pending = null;
+			$this->onFulfilled = $this->onRejected = null;
+			$this->nextPendingIndex = 0;
+		};
+
+		$this->aggregate->then($clearFn, $clearFn);
+	}
+
+	private function refillPending(): void
+	{
+		if (!$this->concurrency) {
+			// Add all pending promises.
+			while ($this->addPending() && $this->advanceIterator()) {
+			}
+
+			return;
+		}
+
+		// Add only up to N pending promises.
+		$concurrency = is_callable($this->concurrency)
+			? ($this->concurrency)(count($this->pending))
+			: $this->concurrency;
+		$concurrency = max($concurrency - count($this->pending), 0);
+		// Concurrency may be set to 0 to disallow new promises.
+		if (!$concurrency) {
+			return;
+		}
+		// Add the first pending promise.
+		$this->addPending();
+		// Note this is special handling for concurrency=1 so that we do
+		// not advance the iterator after adding the first promise. This
+		// helps work around issues with generators that might not have the
+		// next value to yield until promise callbacks are called.
+		while (--$concurrency
+			&& $this->advanceIterator()
+			&& $this->addPending()) {
+		}
+	}
+
+	private function addPending(): bool
+	{
+		if (!$this->iterable || !$this->iterable->valid()) {
+			return false;
+		}
+
+		$promise = Create::promiseFor($this->iterable->current());
+		$key = $this->iterable->key();
+
+		// Iterable keys may not be unique, so we use a counter to
+		// guarantee uniqueness
+		$idx = $this->nextPendingIndex++;
+
+		$this->pending[$idx] = $promise->then(
+			function ($value) use ($idx, $key): void {
+				if ($this->onFulfilled) {
+					($this->onFulfilled)(
+						$value,
+						$key,
+						$this->aggregate
+					);
+				}
+				$this->step($idx);
+			},
+			function ($reason) use ($idx, $key): void {
+				if ($this->onRejected) {
+					($this->onRejected)(
+						$reason,
+						$key,
+						$this->aggregate
+					);
+				}
+				$this->step($idx);
+			}
+		);
+
+		return true;
+	}
+
+	private function advanceIterator(): bool
+	{
+		// Place a lock on the iterator so that we ensure to not recurse,
+		// preventing fatal generator errors.
+		if ($this->mutex) {
+			return false;
+		}
+
+		$this->mutex = true;
+
+		try {
+			$this->iterable->next();
+			$this->mutex = false;
+
+			return true;
+		} catch (\Throwable $e) {
+			$this->aggregate->reject($e);
+			$this->mutex = false;
+
+			return false;
+		}
+	}
+
+	private function step(int $idx): void
+	{
+		// If the promise was already resolved, then ignore this step.
+		if (Is::settled($this->aggregate)) {
+			return;
+		}
+
+		unset($this->pending[$idx]);
+
+		// Only refill pending promises if we are not locked, preventing the
+		// EachPromise to recursively invoke the provided iterator, which
+		// cause a fatal error: "Cannot resume an already running generator"
+		if ($this->advanceIterator() && !$this->checkIfFinished()) {
+			// Add more pending promises if possible.
+			$this->refillPending();
+		}
+	}
+
+	private function checkIfFinished(): bool
+	{
+		if (!$this->pending && !$this->iterable->valid()) {
+			// Resolve the promise if there's nothing left to do.
+			$this->aggregate->resolve(null);
+
+			return true;
+		}
+
+		return false;
+	}
 }

Spacing +4 added lines, -4 removed lines

@@ -97,7 +97,7 @@ 
     private function createPromise(): void
     {
         $this->mutex = false;
-        $this->aggregate = new Promise(function (): void {
+        $this->aggregate = new Promise(function(): void {
             if ($this->checkIfFinished()) {
                 return;
             }
@@ -114,7 +114,7 @@ 
         });
 
         // Clear the references when the promise is resolved.
-        $clearFn = function (): void {
+        $clearFn = function(): void {
             $this->iterable = $this->concurrency = $this->pending = null;
             $this->onFulfilled = $this->onRejected = null;
             $this->nextPendingIndex = 0;
@@ -168,7 +168,7 @@ 
         $idx = $this->nextPendingIndex++;
 
         $this->pending[$idx] = $promise->then(
-            function ($value) use ($idx, $key): void {
+            function($value) use ($idx, $key): void {
                 if ($this->onFulfilled) {
                     ($this->onFulfilled)(
                         $value,
@@ -178,7 +178,7 @@ 
                 }
                 $this->step($idx);
             },
-            function ($reason) use ($idx, $key): void {
+            function($reason) use ($idx, $key): void {
                 if ($this->onRejected) {
                     ($this->onRejected)(
                         $reason,

Braces +1 added lines, -2 removed lines

@@ -10,8 +10,7 @@
  *
  * @final
  */
-class EachPromise implements PromisorInterface
-{
+class EachPromise implements PromisorInterface {
     private $pending = [];
 
     private $nextPendingIndex = 0;

lib/Vendor/GuzzleHttp/Promise/Promise.php

Indentation +260 added lines, -260 removed lines

@@ -13,269 +13,269 @@
  */
 class Promise implements PromiseInterface
 {
-    private $state = self::PENDING;
-    private $result;
-    private $cancelFn;
-    private $waitFn;
-    private $waitList;
-    private $handlers = [];
-
-    /**
-     * @param callable $waitFn   Fn that when invoked resolves the promise.
-     * @param callable $cancelFn Fn that when invoked cancels the promise.
-     */
-    public function __construct(
-        callable $waitFn = null,
-        callable $cancelFn = null
-    ) {
-        $this->waitFn = $waitFn;
-        $this->cancelFn = $cancelFn;
-    }
-
-    public function then(
-        callable $onFulfilled = null,
-        callable $onRejected = null
-    ): PromiseInterface {
-        if ($this->state === self::PENDING) {
-            $p = new Promise(null, [$this, 'cancel']);
-            $this->handlers[] = [$p, $onFulfilled, $onRejected];
-            $p->waitList = $this->waitList;
-            $p->waitList[] = $this;
-
-            return $p;
-        }
-
-        // Return a fulfilled promise and immediately invoke any callbacks.
-        if ($this->state === self::FULFILLED) {
-            $promise = Create::promiseFor($this->result);
-
-            return $onFulfilled ? $promise->then($onFulfilled) : $promise;
-        }
-
-        // It's either cancelled or rejected, so return a rejected promise
-        // and immediately invoke any callbacks.
-        $rejection = Create::rejectionFor($this->result);
-
-        return $onRejected ? $rejection->then(null, $onRejected) : $rejection;
-    }
-
-    public function otherwise(callable $onRejected): PromiseInterface
-    {
-        return $this->then(null, $onRejected);
-    }
-
-    public function wait(bool $unwrap = true)
-    {
-        $this->waitIfPending();
-
-        if ($this->result instanceof PromiseInterface) {
-            return $this->result->wait($unwrap);
-        }
-        if ($unwrap) {
-            if ($this->state === self::FULFILLED) {
-                return $this->result;
-            }
-            // It's rejected so "unwrap" and throw an exception.
-            throw Create::exceptionFor($this->result);
-        }
-    }
-
-    public function getState(): string
-    {
-        return $this->state;
-    }
-
-    public function cancel(): void
-    {
-        if ($this->state !== self::PENDING) {
-            return;
-        }
-
-        $this->waitFn = $this->waitList = null;
-
-        if ($this->cancelFn) {
-            $fn = $this->cancelFn;
-            $this->cancelFn = null;
-            try {
-                $fn();
-            } catch (\Throwable $e) {
-                $this->reject($e);
-            }
-        }
-
-        // Reject the promise only if it wasn't rejected in a then callback.
-        /** @psalm-suppress RedundantCondition */
-        if ($this->state === self::PENDING) {
-            $this->reject(new CancellationException('Promise has been cancelled'));
-        }
-    }
-
-    public function resolve($value): void
-    {
-        $this->settle(self::FULFILLED, $value);
-    }
-
-    public function reject($reason): void
-    {
-        $this->settle(self::REJECTED, $reason);
-    }
-
-    private function settle(string $state, $value): void
-    {
-        if ($this->state !== self::PENDING) {
-            // Ignore calls with the same resolution.
-            if ($state === $this->state && $value === $this->result) {
-                return;
-            }
-            throw $this->state === $state
-                ? new \LogicException("The promise is already {$state}.")
-                : new \LogicException("Cannot change a {$this->state} promise to {$state}");
-        }
-
-        if ($value === $this) {
-            throw new \LogicException('Cannot fulfill or reject a promise with itself');
-        }
-
-        // Clear out the state of the promise but stash the handlers.
-        $this->state = $state;
-        $this->result = $value;
-        $handlers = $this->handlers;
-        $this->handlers = null;
-        $this->waitList = $this->waitFn = null;
-        $this->cancelFn = null;
-
-        if (!$handlers) {
-            return;
-        }
-
-        // If the value was not a settled promise or a thenable, then resolve
-        // it in the task queue using the correct ID.
-        if (!is_object($value) || !method_exists($value, 'then')) {
-            $id = $state === self::FULFILLED ? 1 : 2;
-            // It's a success, so resolve the handlers in the queue.
-            Utils::queue()->add(static function () use ($id, $value, $handlers): void {
-                foreach ($handlers as $handler) {
-                    self::callHandler($id, $value, $handler);
-                }
-            });
-        } elseif ($value instanceof Promise && Is::pending($value)) {
-            // We can just merge our handlers onto the next promise.
-            $value->handlers = array_merge($value->handlers, $handlers);
-        } else {
-            // Resolve the handlers when the forwarded promise is resolved.
-            $value->then(
-                static function ($value) use ($handlers): void {
-                    foreach ($handlers as $handler) {
-                        self::callHandler(1, $value, $handler);
-                    }
-                },
-                static function ($reason) use ($handlers): void {
-                    foreach ($handlers as $handler) {
-                        self::callHandler(2, $reason, $handler);
-                    }
-                }
-            );
-        }
-    }
-
-    /**
-     * Call a stack of handlers using a specific callback index and value.
-     *
-     * @param int   $index   1 (resolve) or 2 (reject).
-     * @param mixed $value   Value to pass to the callback.
-     * @param array $handler Array of handler data (promise and callbacks).
-     */
-    private static function callHandler(int $index, $value, array $handler): void
-    {
-        /** @var PromiseInterface $promise */
-        $promise = $handler[0];
-
-        // The promise may have been cancelled or resolved before placing
-        // this thunk in the queue.
-        if (Is::settled($promise)) {
-            return;
-        }
-
-        try {
-            if (isset($handler[$index])) {
-                /*
+	private $state = self::PENDING;
+	private $result;
+	private $cancelFn;
+	private $waitFn;
+	private $waitList;
+	private $handlers = [];
+
+	/**
+	 * @param callable $waitFn   Fn that when invoked resolves the promise.
+	 * @param callable $cancelFn Fn that when invoked cancels the promise.
+	 */
+	public function __construct(
+		callable $waitFn = null,
+		callable $cancelFn = null
+	) {
+		$this->waitFn = $waitFn;
+		$this->cancelFn = $cancelFn;
+	}
+
+	public function then(
+		callable $onFulfilled = null,
+		callable $onRejected = null
+	): PromiseInterface {
+		if ($this->state === self::PENDING) {
+			$p = new Promise(null, [$this, 'cancel']);
+			$this->handlers[] = [$p, $onFulfilled, $onRejected];
+			$p->waitList = $this->waitList;
+			$p->waitList[] = $this;
+
+			return $p;
+		}
+
+		// Return a fulfilled promise and immediately invoke any callbacks.
+		if ($this->state === self::FULFILLED) {
+			$promise = Create::promiseFor($this->result);
+
+			return $onFulfilled ? $promise->then($onFulfilled) : $promise;
+		}
+
+		// It's either cancelled or rejected, so return a rejected promise
+		// and immediately invoke any callbacks.
+		$rejection = Create::rejectionFor($this->result);
+
+		return $onRejected ? $rejection->then(null, $onRejected) : $rejection;
+	}
+
+	public function otherwise(callable $onRejected): PromiseInterface
+	{
+		return $this->then(null, $onRejected);
+	}
+
+	public function wait(bool $unwrap = true)
+	{
+		$this->waitIfPending();
+
+		if ($this->result instanceof PromiseInterface) {
+			return $this->result->wait($unwrap);
+		}
+		if ($unwrap) {
+			if ($this->state === self::FULFILLED) {
+				return $this->result;
+			}
+			// It's rejected so "unwrap" and throw an exception.
+			throw Create::exceptionFor($this->result);
+		}
+	}
+
+	public function getState(): string
+	{
+		return $this->state;
+	}
+
+	public function cancel(): void
+	{
+		if ($this->state !== self::PENDING) {
+			return;
+		}
+
+		$this->waitFn = $this->waitList = null;
+
+		if ($this->cancelFn) {
+			$fn = $this->cancelFn;
+			$this->cancelFn = null;
+			try {
+				$fn();
+			} catch (\Throwable $e) {
+				$this->reject($e);
+			}
+		}
+
+		// Reject the promise only if it wasn't rejected in a then callback.
+		/** @psalm-suppress RedundantCondition */
+		if ($this->state === self::PENDING) {
+			$this->reject(new CancellationException('Promise has been cancelled'));
+		}
+	}
+
+	public function resolve($value): void
+	{
+		$this->settle(self::FULFILLED, $value);
+	}
+
+	public function reject($reason): void
+	{
+		$this->settle(self::REJECTED, $reason);
+	}
+
+	private function settle(string $state, $value): void
+	{
+		if ($this->state !== self::PENDING) {
+			// Ignore calls with the same resolution.
+			if ($state === $this->state && $value === $this->result) {
+				return;
+			}
+			throw $this->state === $state
+				? new \LogicException("The promise is already {$state}.")
+				: new \LogicException("Cannot change a {$this->state} promise to {$state}");
+		}
+
+		if ($value === $this) {
+			throw new \LogicException('Cannot fulfill or reject a promise with itself');
+		}
+
+		// Clear out the state of the promise but stash the handlers.
+		$this->state = $state;
+		$this->result = $value;
+		$handlers = $this->handlers;
+		$this->handlers = null;
+		$this->waitList = $this->waitFn = null;
+		$this->cancelFn = null;
+
+		if (!$handlers) {
+			return;
+		}
+
+		// If the value was not a settled promise or a thenable, then resolve
+		// it in the task queue using the correct ID.
+		if (!is_object($value) || !method_exists($value, 'then')) {
+			$id = $state === self::FULFILLED ? 1 : 2;
+			// It's a success, so resolve the handlers in the queue.
+			Utils::queue()->add(static function () use ($id, $value, $handlers): void {
+				foreach ($handlers as $handler) {
+					self::callHandler($id, $value, $handler);
+				}
+			});
+		} elseif ($value instanceof Promise && Is::pending($value)) {
+			// We can just merge our handlers onto the next promise.
+			$value->handlers = array_merge($value->handlers, $handlers);
+		} else {
+			// Resolve the handlers when the forwarded promise is resolved.
+			$value->then(
+				static function ($value) use ($handlers): void {
+					foreach ($handlers as $handler) {
+						self::callHandler(1, $value, $handler);
+					}
+				},
+				static function ($reason) use ($handlers): void {
+					foreach ($handlers as $handler) {
+						self::callHandler(2, $reason, $handler);
+					}
+				}
+			);
+		}
+	}
+
+	/**
+	 * Call a stack of handlers using a specific callback index and value.
+	 *
+	 * @param int   $index   1 (resolve) or 2 (reject).
+	 * @param mixed $value   Value to pass to the callback.
+	 * @param array $handler Array of handler data (promise and callbacks).
+	 */
+	private static function callHandler(int $index, $value, array $handler): void
+	{
+		/** @var PromiseInterface $promise */
+		$promise = $handler[0];
+
+		// The promise may have been cancelled or resolved before placing
+		// this thunk in the queue.
+		if (Is::settled($promise)) {
+			return;
+		}
+
+		try {
+			if (isset($handler[$index])) {
+				/*
                  * If $f throws an exception, then $handler will be in the exception
                  * stack trace. Since $handler contains a reference to the callable
                  * itself we get a circular reference. We clear the $handler
                  * here to avoid that memory leak.
                  */
-                $f = $handler[$index];
-                unset($handler);
-                $promise->resolve($f($value));
-            } elseif ($index === 1) {
-                // Forward resolution values as-is.
-                $promise->resolve($value);
-            } else {
-                // Forward rejections down the chain.
-                $promise->reject($value);
-            }
-        } catch (\Throwable $reason) {
-            $promise->reject($reason);
-        }
-    }
-
-    private function waitIfPending(): void
-    {
-        if ($this->state !== self::PENDING) {
-            return;
-        } elseif ($this->waitFn) {
-            $this->invokeWaitFn();
-        } elseif ($this->waitList) {
-            $this->invokeWaitList();
-        } else {
-            // If there's no wait function, then reject the promise.
-            $this->reject('Cannot wait on a promise that has '
-                .'no internal wait function. You must provide a wait '
-                .'function when constructing the promise to be able to '
-                .'wait on a promise.');
-        }
-
-        Utils::queue()->run();
-
-        /** @psalm-suppress RedundantCondition */
-        if ($this->state === self::PENDING) {
-            $this->reject('Invoking the wait callback did not resolve the promise');
-        }
-    }
-
-    private function invokeWaitFn(): void
-    {
-        try {
-            $wfn = $this->waitFn;
-            $this->waitFn = null;
-            $wfn(true);
-        } catch (\Throwable $reason) {
-            if ($this->state === self::PENDING) {
-                // The promise has not been resolved yet, so reject the promise
-                // with the exception.
-                $this->reject($reason);
-            } else {
-                // The promise was already resolved, so there's a problem in
-                // the application.
-                throw $reason;
-            }
-        }
-    }
-
-    private function invokeWaitList(): void
-    {
-        $waitList = $this->waitList;
-        $this->waitList = null;
-
-        foreach ($waitList as $result) {
-            do {
-                $result->waitIfPending();
-                $result = $result->result;
-            } while ($result instanceof Promise);
-
-            if ($result instanceof PromiseInterface) {
-                $result->wait(false);
-            }
-        }
-    }
+				$f = $handler[$index];
+				unset($handler);
+				$promise->resolve($f($value));
+			} elseif ($index === 1) {
+				// Forward resolution values as-is.
+				$promise->resolve($value);
+			} else {
+				// Forward rejections down the chain.
+				$promise->reject($value);
+			}
+		} catch (\Throwable $reason) {
+			$promise->reject($reason);
+		}
+	}
+
+	private function waitIfPending(): void
+	{
+		if ($this->state !== self::PENDING) {
+			return;
+		} elseif ($this->waitFn) {
+			$this->invokeWaitFn();
+		} elseif ($this->waitList) {
+			$this->invokeWaitList();
+		} else {
+			// If there's no wait function, then reject the promise.
+			$this->reject('Cannot wait on a promise that has '
+				.'no internal wait function. You must provide a wait '
+				.'function when constructing the promise to be able to '
+				.'wait on a promise.');
+		}
+
+		Utils::queue()->run();
+
+		/** @psalm-suppress RedundantCondition */
+		if ($this->state === self::PENDING) {
+			$this->reject('Invoking the wait callback did not resolve the promise');
+		}
+	}
+
+	private function invokeWaitFn(): void
+	{
+		try {
+			$wfn = $this->waitFn;
+			$this->waitFn = null;
+			$wfn(true);
+		} catch (\Throwable $reason) {
+			if ($this->state === self::PENDING) {
+				// The promise has not been resolved yet, so reject the promise
+				// with the exception.
+				$this->reject($reason);
+			} else {
+				// The promise was already resolved, so there's a problem in
+				// the application.
+				throw $reason;
+			}
+		}
+	}
+
+	private function invokeWaitList(): void
+	{
+		$waitList = $this->waitList;
+		$this->waitList = null;
+
+		foreach ($waitList as $result) {
+			do {
+				$result->waitIfPending();
+				$result = $result->result;
+			} while ($result instanceof Promise);
+
+			if ($result instanceof PromiseInterface) {
+				$result->wait(false);
+			}
+		}
+	}
 }

Spacing +3 added lines, -3 removed lines

@@ -153,7 +153,7 @@ 
         if (!is_object($value) || !method_exists($value, 'then')) {
             $id = $state === self::FULFILLED ? 1 : 2;
             // It's a success, so resolve the handlers in the queue.
-            Utils::queue()->add(static function () use ($id, $value, $handlers): void {
+            Utils::queue()->add(static function() use ($id, $value, $handlers): void {
                 foreach ($handlers as $handler) {
                     self::callHandler($id, $value, $handler);
                 }
@@ -164,12 +164,12 @@ 
         } else {
             // Resolve the handlers when the forwarded promise is resolved.
             $value->then(
-                static function ($value) use ($handlers): void {
+                static function($value) use ($handlers): void {
                     foreach ($handlers as $handler) {
                         self::callHandler(1, $value, $handler);
                     }
                 },
-                static function ($reason) use ($handlers): void {
+                static function($reason) use ($handlers): void {
                     foreach ($handlers as $handler) {
                         self::callHandler(2, $reason, $handler);
                     }

Braces +1 added lines, -2 removed lines

@@ -11,8 +11,7 @@
  *
  * @final
  */
-class Promise implements PromiseInterface
-{
+class Promise implements PromiseInterface {
     private $state = self::PENDING;
     private $result;
     private $cancelFn;

lib/Vendor/GuzzleHttp/Promise/PromisorInterface.php

Indentation +4 added lines, -4 removed lines

@@ -9,8 +9,8 @@
  */
 interface PromisorInterface
 {
-    /**
-     * Returns a promise.
-     */
-    public function promise(): PromiseInterface;
+	/**
+	 * Returns a promise.
+	 */
+	public function promise(): PromiseInterface;
 }

Braces +1 added lines, -2 removed lines

@@ -7,8 +7,7 @@
 /**
  * Interface used with classes that return a promise.
  */
-interface PromisorInterface
-{
+interface PromisorInterface {
     /**
      * Returns a promise.
      */

lib/Vendor/GuzzleHttp/Promise/AggregateException.php

Indentation +7 added lines, -7 removed lines

@@ -9,11 +9,11 @@
  */
 class AggregateException extends RejectionException
 {
-    public function __construct(string $msg, array $reasons)
-    {
-        parent::__construct(
-            $reasons,
-            sprintf('%s; %d rejected promises', $msg, count($reasons))
-        );
-    }
+	public function __construct(string $msg, array $reasons)
+	{
+		parent::__construct(
+			$reasons,
+			sprintf('%s; %d rejected promises', $msg, count($reasons))
+		);
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -7,8 +7,7 @@
 /**
  * Exception thrown when too many errors occur in the some() or any() methods.
  */
-class AggregateException extends RejectionException
-{
+class AggregateException extends RejectionException {
     public function __construct(string $msg, array $reasons)
     {
         parent::__construct(