nextcloud / fulltextsearch_elasticsearch

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(

lib/Vendor/GuzzleHttp/Promise/RejectedPromise.php

Indentation +66 added lines, -66 removed lines

@@ -14,82 +14,82 @@
  */
 class RejectedPromise implements PromiseInterface
 {
-    private $reason;
+	private $reason;
 
-    /**
-     * @param mixed $reason
-     */
-    public function __construct($reason)
-    {
-        if (is_object($reason) && method_exists($reason, 'then')) {
-            throw new \InvalidArgumentException(
-                'You cannot create a RejectedPromise with a promise.'
-            );
-        }
+	/**
+	 * @param mixed $reason
+	 */
+	public function __construct($reason)
+	{
+		if (is_object($reason) && method_exists($reason, 'then')) {
+			throw new \InvalidArgumentException(
+				'You cannot create a RejectedPromise with a promise.'
+			);
+		}
 
-        $this->reason = $reason;
-    }
+		$this->reason = $reason;
+	}
 
-    public function then(
-        callable $onFulfilled = null,
-        callable $onRejected = null
-    ): PromiseInterface {
-        // If there's no onRejected callback then just return self.
-        if (!$onRejected) {
-            return $this;
-        }
+	public function then(
+		callable $onFulfilled = null,
+		callable $onRejected = null
+	): PromiseInterface {
+		// If there's no onRejected callback then just return self.
+		if (!$onRejected) {
+			return $this;
+		}
 
-        $queue = Utils::queue();
-        $reason = $this->reason;
-        $p = new Promise([$queue, 'run']);
-        $queue->add(static function () use ($p, $reason, $onRejected): void {
-            if (Is::pending($p)) {
-                try {
-                    // Return a resolved promise if onRejected does not throw.
-                    $p->resolve($onRejected($reason));
-                } catch (\Throwable $e) {
-                    // onRejected threw, so return a rejected promise.
-                    $p->reject($e);
-                }
-            }
-        });
+		$queue = Utils::queue();
+		$reason = $this->reason;
+		$p = new Promise([$queue, 'run']);
+		$queue->add(static function () use ($p, $reason, $onRejected): void {
+			if (Is::pending($p)) {
+				try {
+					// Return a resolved promise if onRejected does not throw.
+					$p->resolve($onRejected($reason));
+				} catch (\Throwable $e) {
+					// onRejected threw, so return a rejected promise.
+					$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)
-    {
-        if ($unwrap) {
-            throw Create::exceptionFor($this->reason);
-        }
+	public function wait(bool $unwrap = true)
+	{
+		if ($unwrap) {
+			throw Create::exceptionFor($this->reason);
+		}
 
-        return null;
-    }
+		return null;
+	}
 
-    public function getState(): string
-    {
-        return self::REJECTED;
-    }
+	public function getState(): string
+	{
+		return self::REJECTED;
+	}
 
-    public function resolve($value): void
-    {
-        throw new \LogicException('Cannot resolve a rejected promise');
-    }
+	public function resolve($value): void
+	{
+		throw new \LogicException('Cannot resolve a rejected promise');
+	}
 
-    public function reject($reason): void
-    {
-        if ($reason !== $this->reason) {
-            throw new \LogicException('Cannot reject a rejected promise');
-        }
-    }
+	public function reject($reason): void
+	{
+		if ($reason !== $this->reason) {
+			throw new \LogicException('Cannot reject a rejected 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();
         $reason = $this->reason;
         $p = new Promise([$queue, 'run']);
-        $queue->add(static function () use ($p, $reason, $onRejected): void {
+        $queue->add(static function() use ($p, $reason, $onRejected): void {
             if (Is::pending($p)) {
                 try {
                     // Return a resolved promise if onRejected does not throw.

Braces +1 added lines, -2 removed lines

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

lib/Vendor/GuzzleHttp/Promise/Is.php

Indentation +28 added lines, -28 removed lines

@@ -6,35 +6,35 @@
 
 final class Is
 {
-    /**
-     * Returns true if a promise is pending.
-     */
-    public static function pending(PromiseInterface $promise): bool
-    {
-        return $promise->getState() === PromiseInterface::PENDING;
-    }
+	/**
+	 * Returns true if a promise is pending.
+	 */
+	public static function pending(PromiseInterface $promise): bool
+	{
+		return $promise->getState() === PromiseInterface::PENDING;
+	}
 
-    /**
-     * Returns true if a promise is fulfilled or rejected.
-     */
-    public static function settled(PromiseInterface $promise): bool
-    {
-        return $promise->getState() !== PromiseInterface::PENDING;
-    }
+	/**
+	 * Returns true if a promise is fulfilled or rejected.
+	 */
+	public static function settled(PromiseInterface $promise): bool
+	{
+		return $promise->getState() !== PromiseInterface::PENDING;
+	}
 
-    /**
-     * Returns true if a promise is fulfilled.
-     */
-    public static function fulfilled(PromiseInterface $promise): bool
-    {
-        return $promise->getState() === PromiseInterface::FULFILLED;
-    }
+	/**
+	 * Returns true if a promise is fulfilled.
+	 */
+	public static function fulfilled(PromiseInterface $promise): bool
+	{
+		return $promise->getState() === PromiseInterface::FULFILLED;
+	}
 
-    /**
-     * Returns true if a promise is rejected.
-     */
-    public static function rejected(PromiseInterface $promise): bool
-    {
-        return $promise->getState() === PromiseInterface::REJECTED;
-    }
+	/**
+	 * Returns true if a promise is rejected.
+	 */
+	public static function rejected(PromiseInterface $promise): bool
+	{
+		return $promise->getState() === PromiseInterface::REJECTED;
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -4,8 +4,7 @@
 
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
-final class Is
-{
+final class Is {
     /**
      * Returns true if a promise is pending.
      */

lib/Vendor/GuzzleHttp/Middleware.php

Indentation +231 added lines, -231 removed lines

@@ -15,254 +15,254 @@
  */
 final class Middleware
 {
-    /**
-     * Middleware that adds cookies to requests.
-     *
-     * The options array must be set to a CookieJarInterface in order to use
-     * cookies. This is typically handled for you by a client.
-     *
-     * @return callable Returns a function that accepts the next handler.
-     */
-    public static function cookies(): callable
-    {
-        return static function (callable $handler): callable {
-            return static function ($request, array $options) use ($handler) {
-                if (empty($options['cookies'])) {
-                    return $handler($request, $options);
-                } elseif (!($options['cookies'] instanceof CookieJarInterface)) {
-                    throw new \InvalidArgumentException('cookies must be an instance of OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Cookie\CookieJarInterface');
-                }
-                $cookieJar = $options['cookies'];
-                $request = $cookieJar->withCookieHeader($request);
+	/**
+	 * Middleware that adds cookies to requests.
+	 *
+	 * The options array must be set to a CookieJarInterface in order to use
+	 * cookies. This is typically handled for you by a client.
+	 *
+	 * @return callable Returns a function that accepts the next handler.
+	 */
+	public static function cookies(): callable
+	{
+		return static function (callable $handler): callable {
+			return static function ($request, array $options) use ($handler) {
+				if (empty($options['cookies'])) {
+					return $handler($request, $options);
+				} elseif (!($options['cookies'] instanceof CookieJarInterface)) {
+					throw new \InvalidArgumentException('cookies must be an instance of OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Cookie\CookieJarInterface');
+				}
+				$cookieJar = $options['cookies'];
+				$request = $cookieJar->withCookieHeader($request);
 
-                return $handler($request, $options)
-                    ->then(
-                        static function (ResponseInterface $response) use ($cookieJar, $request): ResponseInterface {
-                            $cookieJar->extractCookies($request, $response);
+				return $handler($request, $options)
+					->then(
+						static function (ResponseInterface $response) use ($cookieJar, $request): ResponseInterface {
+							$cookieJar->extractCookies($request, $response);
 
-                            return $response;
-                        }
-                    );
-            };
-        };
-    }
+							return $response;
+						}
+					);
+			};
+		};
+	}
 
-    /**
-     * Middleware that throws exceptions for 4xx or 5xx responses when the
-     * "http_errors" request option is set to true.
-     *
-     * @param BodySummarizerInterface|null $bodySummarizer The body summarizer to use in exception messages.
-     *
-     * @return callable(callable): callable Returns a function that accepts the next handler.
-     */
-    public static function httpErrors(BodySummarizerInterface $bodySummarizer = null): callable
-    {
-        return static function (callable $handler) use ($bodySummarizer): callable {
-            return static function ($request, array $options) use ($handler, $bodySummarizer) {
-                if (empty($options['http_errors'])) {
-                    return $handler($request, $options);
-                }
+	/**
+	 * Middleware that throws exceptions for 4xx or 5xx responses when the
+	 * "http_errors" request option is set to true.
+	 *
+	 * @param BodySummarizerInterface|null $bodySummarizer The body summarizer to use in exception messages.
+	 *
+	 * @return callable(callable): callable Returns a function that accepts the next handler.
+	 */
+	public static function httpErrors(BodySummarizerInterface $bodySummarizer = null): callable
+	{
+		return static function (callable $handler) use ($bodySummarizer): callable {
+			return static function ($request, array $options) use ($handler, $bodySummarizer) {
+				if (empty($options['http_errors'])) {
+					return $handler($request, $options);
+				}
 
-                return $handler($request, $options)->then(
-                    static function (ResponseInterface $response) use ($request, $bodySummarizer) {
-                        $code = $response->getStatusCode();
-                        if ($code < 400) {
-                            return $response;
-                        }
-                        throw RequestException::create($request, $response, null, [], $bodySummarizer);
-                    }
-                );
-            };
-        };
-    }
+				return $handler($request, $options)->then(
+					static function (ResponseInterface $response) use ($request, $bodySummarizer) {
+						$code = $response->getStatusCode();
+						if ($code < 400) {
+							return $response;
+						}
+						throw RequestException::create($request, $response, null, [], $bodySummarizer);
+					}
+				);
+			};
+		};
+	}
 
-    /**
-     * Middleware that pushes history data to an ArrayAccess container.
-     *
-     * @param array|\ArrayAccess<int, array> $container Container to hold the history (by reference).
-     *
-     * @return callable(callable): callable Returns a function that accepts the next handler.
-     *
-     * @throws \InvalidArgumentException if container is not an array or ArrayAccess.
-     */
-    public static function history(&$container): callable
-    {
-        if (!\is_array($container) && !$container instanceof \ArrayAccess) {
-            throw new \InvalidArgumentException('history container must be an array or object implementing ArrayAccess');
-        }
+	/**
+	 * Middleware that pushes history data to an ArrayAccess container.
+	 *
+	 * @param array|\ArrayAccess<int, array> $container Container to hold the history (by reference).
+	 *
+	 * @return callable(callable): callable Returns a function that accepts the next handler.
+	 *
+	 * @throws \InvalidArgumentException if container is not an array or ArrayAccess.
+	 */
+	public static function history(&$container): callable
+	{
+		if (!\is_array($container) && !$container instanceof \ArrayAccess) {
+			throw new \InvalidArgumentException('history container must be an array or object implementing ArrayAccess');
+		}
 
-        return static function (callable $handler) use (&$container): callable {
-            return static function (RequestInterface $request, array $options) use ($handler, &$container) {
-                return $handler($request, $options)->then(
-                    static function ($value) use ($request, &$container, $options) {
-                        $container[] = [
-                            'request' => $request,
-                            'response' => $value,
-                            'error' => null,
-                            'options' => $options,
-                        ];
+		return static function (callable $handler) use (&$container): callable {
+			return static function (RequestInterface $request, array $options) use ($handler, &$container) {
+				return $handler($request, $options)->then(
+					static function ($value) use ($request, &$container, $options) {
+						$container[] = [
+							'request' => $request,
+							'response' => $value,
+							'error' => null,
+							'options' => $options,
+						];
 
-                        return $value;
-                    },
-                    static function ($reason) use ($request, &$container, $options) {
-                        $container[] = [
-                            'request' => $request,
-                            'response' => null,
-                            'error' => $reason,
-                            'options' => $options,
-                        ];
+						return $value;
+					},
+					static function ($reason) use ($request, &$container, $options) {
+						$container[] = [
+							'request' => $request,
+							'response' => null,
+							'error' => $reason,
+							'options' => $options,
+						];
 
-                        return P\Create::rejectionFor($reason);
-                    }
-                );
-            };
-        };
-    }
+						return P\Create::rejectionFor($reason);
+					}
+				);
+			};
+		};
+	}
 
-    /**
-     * Middleware that invokes a callback before and after sending a request.
-     *
-     * The provided listener cannot modify or alter the response. It simply
-     * "taps" into the chain to be notified before returning the promise. The
-     * before listener accepts a request and options array, and the after
-     * listener accepts a request, options array, and response promise.
-     *
-     * @param callable $before Function to invoke before forwarding the request.
-     * @param callable $after  Function invoked after forwarding.
-     *
-     * @return callable Returns a function that accepts the next handler.
-     */
-    public static function tap(callable $before = null, callable $after = null): callable
-    {
-        return static function (callable $handler) use ($before, $after): callable {
-            return static function (RequestInterface $request, array $options) use ($handler, $before, $after) {
-                if ($before) {
-                    $before($request, $options);
-                }
-                $response = $handler($request, $options);
-                if ($after) {
-                    $after($request, $options, $response);
-                }
+	/**
+	 * Middleware that invokes a callback before and after sending a request.
+	 *
+	 * The provided listener cannot modify or alter the response. It simply
+	 * "taps" into the chain to be notified before returning the promise. The
+	 * before listener accepts a request and options array, and the after
+	 * listener accepts a request, options array, and response promise.
+	 *
+	 * @param callable $before Function to invoke before forwarding the request.
+	 * @param callable $after  Function invoked after forwarding.
+	 *
+	 * @return callable Returns a function that accepts the next handler.
+	 */
+	public static function tap(callable $before = null, callable $after = null): callable
+	{
+		return static function (callable $handler) use ($before, $after): callable {
+			return static function (RequestInterface $request, array $options) use ($handler, $before, $after) {
+				if ($before) {
+					$before($request, $options);
+				}
+				$response = $handler($request, $options);
+				if ($after) {
+					$after($request, $options, $response);
+				}
 
-                return $response;
-            };
-        };
-    }
+				return $response;
+			};
+		};
+	}
 
-    /**
-     * Middleware that handles request redirects.
-     *
-     * @return callable Returns a function that accepts the next handler.
-     */
-    public static function redirect(): callable
-    {
-        return static function (callable $handler): RedirectMiddleware {
-            return new RedirectMiddleware($handler);
-        };
-    }
+	/**
+	 * Middleware that handles request redirects.
+	 *
+	 * @return callable Returns a function that accepts the next handler.
+	 */
+	public static function redirect(): callable
+	{
+		return static function (callable $handler): RedirectMiddleware {
+			return new RedirectMiddleware($handler);
+		};
+	}
 
-    /**
-     * Middleware that retries requests based on the boolean result of
-     * invoking the provided "decider" function.
-     *
-     * If no delay function is provided, a simple implementation of exponential
-     * backoff will be utilized.
-     *
-     * @param callable $decider Function that accepts the number of retries,
-     *                          a request, [response], and [exception] and
-     *                          returns true if the request is to be retried.
-     * @param callable $delay   Function that accepts the number of retries and
-     *                          returns the number of milliseconds to delay.
-     *
-     * @return callable Returns a function that accepts the next handler.
-     */
-    public static function retry(callable $decider, callable $delay = null): callable
-    {
-        return static function (callable $handler) use ($decider, $delay): RetryMiddleware {
-            return new RetryMiddleware($decider, $handler, $delay);
-        };
-    }
+	/**
+	 * Middleware that retries requests based on the boolean result of
+	 * invoking the provided "decider" function.
+	 *
+	 * If no delay function is provided, a simple implementation of exponential
+	 * backoff will be utilized.
+	 *
+	 * @param callable $decider Function that accepts the number of retries,
+	 *                          a request, [response], and [exception] and
+	 *                          returns true if the request is to be retried.
+	 * @param callable $delay   Function that accepts the number of retries and
+	 *                          returns the number of milliseconds to delay.
+	 *
+	 * @return callable Returns a function that accepts the next handler.
+	 */
+	public static function retry(callable $decider, callable $delay = null): callable
+	{
+		return static function (callable $handler) use ($decider, $delay): RetryMiddleware {
+			return new RetryMiddleware($decider, $handler, $delay);
+		};
+	}
 
-    /**
-     * Middleware that logs requests, responses, and errors using a message
-     * formatter.
-     *
-     * @phpstan-param \Psr\Log\LogLevel::* $logLevel  Level at which to log requests.
-     *
-     * @param LoggerInterface                            $logger    Logs messages.
-     * @param MessageFormatterInterface|MessageFormatter $formatter Formatter used to create message strings.
-     * @param string                                     $logLevel  Level at which to log requests.
-     *
-     * @return callable Returns a function that accepts the next handler.
-     */
-    public static function log(LoggerInterface $logger, $formatter, string $logLevel = 'info'): callable
-    {
-        // To be compatible with Guzzle 7.1.x we need to allow users to pass a MessageFormatter
-        if (!$formatter instanceof MessageFormatter && !$formatter instanceof MessageFormatterInterface) {
-            throw new \LogicException(sprintf('Argument 2 to %s::log() must be of type %s', self::class, MessageFormatterInterface::class));
-        }
+	/**
+	 * Middleware that logs requests, responses, and errors using a message
+	 * formatter.
+	 *
+	 * @phpstan-param \Psr\Log\LogLevel::* $logLevel  Level at which to log requests.
+	 *
+	 * @param LoggerInterface                            $logger    Logs messages.
+	 * @param MessageFormatterInterface|MessageFormatter $formatter Formatter used to create message strings.
+	 * @param string                                     $logLevel  Level at which to log requests.
+	 *
+	 * @return callable Returns a function that accepts the next handler.
+	 */
+	public static function log(LoggerInterface $logger, $formatter, string $logLevel = 'info'): callable
+	{
+		// To be compatible with Guzzle 7.1.x we need to allow users to pass a MessageFormatter
+		if (!$formatter instanceof MessageFormatter && !$formatter instanceof MessageFormatterInterface) {
+			throw new \LogicException(sprintf('Argument 2 to %s::log() must be of type %s', self::class, MessageFormatterInterface::class));
+		}
 
-        return static function (callable $handler) use ($logger, $formatter, $logLevel): callable {
-            return static function (RequestInterface $request, array $options = []) use ($handler, $logger, $formatter, $logLevel) {
-                return $handler($request, $options)->then(
-                    static function ($response) use ($logger, $request, $formatter, $logLevel): ResponseInterface {
-                        $message = $formatter->format($request, $response);
-                        $logger->log($logLevel, $message);
+		return static function (callable $handler) use ($logger, $formatter, $logLevel): callable {
+			return static function (RequestInterface $request, array $options = []) use ($handler, $logger, $formatter, $logLevel) {
+				return $handler($request, $options)->then(
+					static function ($response) use ($logger, $request, $formatter, $logLevel): ResponseInterface {
+						$message = $formatter->format($request, $response);
+						$logger->log($logLevel, $message);
 
-                        return $response;
-                    },
-                    static function ($reason) use ($logger, $request, $formatter): PromiseInterface {
-                        $response = $reason instanceof RequestException ? $reason->getResponse() : null;
-                        $message = $formatter->format($request, $response, P\Create::exceptionFor($reason));
-                        $logger->error($message);
+						return $response;
+					},
+					static function ($reason) use ($logger, $request, $formatter): PromiseInterface {
+						$response = $reason instanceof RequestException ? $reason->getResponse() : null;
+						$message = $formatter->format($request, $response, P\Create::exceptionFor($reason));
+						$logger->error($message);
 
-                        return P\Create::rejectionFor($reason);
-                    }
-                );
-            };
-        };
-    }
+						return P\Create::rejectionFor($reason);
+					}
+				);
+			};
+		};
+	}
 
-    /**
-     * This middleware adds a default content-type if possible, a default
-     * content-length or transfer-encoding header, and the expect header.
-     */
-    public static function prepareBody(): callable
-    {
-        return static function (callable $handler): PrepareBodyMiddleware {
-            return new PrepareBodyMiddleware($handler);
-        };
-    }
+	/**
+	 * This middleware adds a default content-type if possible, a default
+	 * content-length or transfer-encoding header, and the expect header.
+	 */
+	public static function prepareBody(): callable
+	{
+		return static function (callable $handler): PrepareBodyMiddleware {
+			return new PrepareBodyMiddleware($handler);
+		};
+	}
 
-    /**
-     * Middleware that applies a map function to the request before passing to
-     * the next handler.
-     *
-     * @param callable $fn Function that accepts a RequestInterface and returns
-     *                     a RequestInterface.
-     */
-    public static function mapRequest(callable $fn): callable
-    {
-        return static function (callable $handler) use ($fn): callable {
-            return static function (RequestInterface $request, array $options) use ($handler, $fn) {
-                return $handler($fn($request), $options);
-            };
-        };
-    }
+	/**
+	 * Middleware that applies a map function to the request before passing to
+	 * the next handler.
+	 *
+	 * @param callable $fn Function that accepts a RequestInterface and returns
+	 *                     a RequestInterface.
+	 */
+	public static function mapRequest(callable $fn): callable
+	{
+		return static function (callable $handler) use ($fn): callable {
+			return static function (RequestInterface $request, array $options) use ($handler, $fn) {
+				return $handler($fn($request), $options);
+			};
+		};
+	}
 
-    /**
-     * Middleware that applies a map function to the resolved promise's
-     * response.
-     *
-     * @param callable $fn Function that accepts a ResponseInterface and
-     *                     returns a ResponseInterface.
-     */
-    public static function mapResponse(callable $fn): callable
-    {
-        return static function (callable $handler) use ($fn): callable {
-            return static function (RequestInterface $request, array $options) use ($handler, $fn) {
-                return $handler($request, $options)->then($fn);
-            };
-        };
-    }
+	/**
+	 * Middleware that applies a map function to the resolved promise's
+	 * response.
+	 *
+	 * @param callable $fn Function that accepts a ResponseInterface and
+	 *                     returns a ResponseInterface.
+	 */
+	public static function mapResponse(callable $fn): callable
+	{
+		return static function (callable $handler) use ($fn): callable {
+			return static function (RequestInterface $request, array $options) use ($handler, $fn) {
+				return $handler($request, $options)->then($fn);
+			};
+		};
+	}
 }

Spacing +23 added lines, -23 removed lines

@@ -25,8 +25,8 @@ 
      */
     public static function cookies(): callable
     {
-        return static function (callable $handler): callable {
-            return static function ($request, array $options) use ($handler) {
+        return static function(callable $handler): callable {
+            return static function($request, array $options) use ($handler) {
                 if (empty($options['cookies'])) {
                     return $handler($request, $options);
                 } elseif (!($options['cookies'] instanceof CookieJarInterface)) {
@@ -37,7 +37,7 @@ 
 
                 return $handler($request, $options)
                     ->then(
-                        static function (ResponseInterface $response) use ($cookieJar, $request): ResponseInterface {
+                        static function(ResponseInterface $response) use ($cookieJar, $request): ResponseInterface {
                             $cookieJar->extractCookies($request, $response);
 
                             return $response;
@@ -57,14 +57,14 @@ 
      */
     public static function httpErrors(BodySummarizerInterface $bodySummarizer = null): callable
     {
-        return static function (callable $handler) use ($bodySummarizer): callable {
-            return static function ($request, array $options) use ($handler, $bodySummarizer) {
+        return static function(callable $handler) use ($bodySummarizer): callable {
+            return static function($request, array $options) use ($handler, $bodySummarizer) {
                 if (empty($options['http_errors'])) {
                     return $handler($request, $options);
                 }
 
                 return $handler($request, $options)->then(
-                    static function (ResponseInterface $response) use ($request, $bodySummarizer) {
+                    static function(ResponseInterface $response) use ($request, $bodySummarizer) {
                         $code = $response->getStatusCode();
                         if ($code < 400) {
                             return $response;
@@ -91,10 +91,10 @@ 
             throw new \InvalidArgumentException('history container must be an array or object implementing ArrayAccess');
         }
 
-        return static function (callable $handler) use (&$container): callable {
-            return static function (RequestInterface $request, array $options) use ($handler, &$container) {
+        return static function(callable $handler) use (&$container): callable {
+            return static function(RequestInterface $request, array $options) use ($handler, &$container) {
                 return $handler($request, $options)->then(
-                    static function ($value) use ($request, &$container, $options) {
+                    static function($value) use ($request, &$container, $options) {
                         $container[] = [
                             'request' => $request,
                             'response' => $value,
@@ -104,7 +104,7 @@ 
 
                         return $value;
                     },
-                    static function ($reason) use ($request, &$container, $options) {
+                    static function($reason) use ($request, &$container, $options) {
                         $container[] = [
                             'request' => $request,
                             'response' => null,
@@ -134,8 +134,8 @@ 
      */
     public static function tap(callable $before = null, callable $after = null): callable
     {
-        return static function (callable $handler) use ($before, $after): callable {
-            return static function (RequestInterface $request, array $options) use ($handler, $before, $after) {
+        return static function(callable $handler) use ($before, $after): callable {
+            return static function(RequestInterface $request, array $options) use ($handler, $before, $after) {
                 if ($before) {
                     $before($request, $options);
                 }
@@ -156,7 +156,7 @@ 
      */
     public static function redirect(): callable
     {
-        return static function (callable $handler): RedirectMiddleware {
+        return static function(callable $handler): RedirectMiddleware {
             return new RedirectMiddleware($handler);
         };
     }
@@ -178,7 +178,7 @@ 
      */
     public static function retry(callable $decider, callable $delay = null): callable
     {
-        return static function (callable $handler) use ($decider, $delay): RetryMiddleware {
+        return static function(callable $handler) use ($decider, $delay): RetryMiddleware {
             return new RetryMiddleware($decider, $handler, $delay);
         };
     }
@@ -202,16 +202,16 @@ 
             throw new \LogicException(sprintf('Argument 2 to %s::log() must be of type %s', self::class, MessageFormatterInterface::class));
         }
 
-        return static function (callable $handler) use ($logger, $formatter, $logLevel): callable {
-            return static function (RequestInterface $request, array $options = []) use ($handler, $logger, $formatter, $logLevel) {
+        return static function(callable $handler) use ($logger, $formatter, $logLevel): callable {
+            return static function(RequestInterface $request, array $options = []) use ($handler, $logger, $formatter, $logLevel) {
                 return $handler($request, $options)->then(
-                    static function ($response) use ($logger, $request, $formatter, $logLevel): ResponseInterface {
+                    static function($response) use ($logger, $request, $formatter, $logLevel): ResponseInterface {
                         $message = $formatter->format($request, $response);
                         $logger->log($logLevel, $message);
 
                         return $response;
                     },
-                    static function ($reason) use ($logger, $request, $formatter): PromiseInterface {
+                    static function($reason) use ($logger, $request, $formatter): PromiseInterface {
                         $response = $reason instanceof RequestException ? $reason->getResponse() : null;
                         $message = $formatter->format($request, $response, P\Create::exceptionFor($reason));
                         $logger->error($message);
@@ -229,7 +229,7 @@ 
      */
     public static function prepareBody(): callable
     {
-        return static function (callable $handler): PrepareBodyMiddleware {
+        return static function(callable $handler): PrepareBodyMiddleware {
             return new PrepareBodyMiddleware($handler);
         };
     }
@@ -243,8 +243,8 @@ 
      */
     public static function mapRequest(callable $fn): callable
     {
-        return static function (callable $handler) use ($fn): callable {
-            return static function (RequestInterface $request, array $options) use ($handler, $fn) {
+        return static function(callable $handler) use ($fn): callable {
+            return static function(RequestInterface $request, array $options) use ($handler, $fn) {
                 return $handler($fn($request), $options);
             };
         };
@@ -259,8 +259,8 @@ 
      */
     public static function mapResponse(callable $fn): callable
     {
-        return static function (callable $handler) use ($fn): callable {
-            return static function (RequestInterface $request, array $options) use ($handler, $fn) {
+        return static function(callable $handler) use ($fn): callable {
+            return static function(RequestInterface $request, array $options) use ($handler, $fn) {
                 return $handler($request, $options)->then($fn);
             };
         };

Braces +1 added lines, -2 removed lines

@@ -13,8 +13,7 @@
 /**
  * Functions used to create and wrap handlers with handler middleware.
  */
-final class Middleware
-{
+final class Middleware {
     /**
      * Middleware that adds cookies to requests.
      *

lib/Vendor/GuzzleHttp/functions_include.php

Indentation +1 added lines, -1 removed lines

@@ -2,5 +2,5 @@
 
 // Don't redefine the functions if included multiple times.
 if (!\function_exists('OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\describe_type')) {
-    require __DIR__.'/functions.php';
+	require __DIR__.'/functions.php';
 }