nextcloud / fulltextsearch_elasticsearch

lib/Vendor/GuzzleHttp/Promise/RejectionException.php

Spacing +4 added lines, -4 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare (strict_types=1);
+declare(strict_types=1);
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
 /**
@@ -21,11 +21,11 @@ 
         $this->reason = $reason;
         $message = 'The promise was rejected';
         if ($description) {
-            $message .= ' with reason: ' . $description;
+            $message .= ' with reason: '.$description;
         } elseif (\is_string($reason) || \is_object($reason) && \method_exists($reason, '__toString')) {
-            $message .= ' with reason: ' . $this->reason;
+            $message .= ' with reason: '.$this->reason;
         } elseif ($reason instanceof \JsonSerializable) {
-            $message .= ' with reason: ' . \json_encode($this->reason, \JSON_PRETTY_PRINT);
+            $message .= ' with reason: '.\json_encode($this->reason, \JSON_PRETTY_PRINT);
         }
         parent::__construct($message);
     }

Indentation +28 added lines, -28 removed lines

@@ -10,32 +10,32 @@
  */
 class RejectionException extends \RuntimeException
 {
-    /** @var mixed Rejection reason. */
-    private $reason;
-    /**
-     * @param mixed       $reason      Rejection reason.
-     * @param string|null $description Optional description.
-     */
-    public function __construct($reason, ?string $description = null)
-    {
-        $this->reason = $reason;
-        $message = 'The promise was rejected';
-        if ($description) {
-            $message .= ' with reason: ' . $description;
-        } elseif (\is_string($reason) || \is_object($reason) && \method_exists($reason, '__toString')) {
-            $message .= ' with reason: ' . $this->reason;
-        } elseif ($reason instanceof \JsonSerializable) {
-            $message .= ' with reason: ' . \json_encode($this->reason, \JSON_PRETTY_PRINT);
-        }
-        parent::__construct($message);
-    }
-    /**
-     * Returns the rejection reason.
-     *
-     * @return mixed
-     */
-    public function getReason()
-    {
-        return $this->reason;
-    }
+	/** @var mixed Rejection reason. */
+	private $reason;
+	/**
+	 * @param mixed       $reason      Rejection reason.
+	 * @param string|null $description Optional description.
+	 */
+	public function __construct($reason, ?string $description = null)
+	{
+		$this->reason = $reason;
+		$message = 'The promise was rejected';
+		if ($description) {
+			$message .= ' with reason: ' . $description;
+		} elseif (\is_string($reason) || \is_object($reason) && \method_exists($reason, '__toString')) {
+			$message .= ' with reason: ' . $this->reason;
+		} elseif ($reason instanceof \JsonSerializable) {
+			$message .= ' with reason: ' . \json_encode($this->reason, \JSON_PRETTY_PRINT);
+		}
+		parent::__construct($message);
+	}
+	/**
+	 * Returns the rejection reason.
+	 *
+	 * @return mixed
+	 */
+	public function getReason()
+	{
+		return $this->reason;
+	}
 }

lib/Vendor/GuzzleHttp/Promise/TaskQueue.php

Indentation +46 added lines, -46 removed lines

@@ -16,50 +16,50 @@
  */
 class TaskQueue implements TaskQueueInterface
 {
-    private $enableShutdown = \true;
-    private $queue = [];
-    public function __construct(bool $withShutdown = \true)
-    {
-        if ($withShutdown) {
-            \register_shutdown_function(function () : void {
-                if ($this->enableShutdown) {
-                    // Only run the tasks if an E_ERROR didn't occur.
-                    $err = \error_get_last();
-                    if (!$err || $err['type'] ^ \E_ERROR) {
-                        $this->run();
-                    }
-                }
-            });
-        }
-    }
-    public function isEmpty() : bool
-    {
-        return !$this->queue;
-    }
-    public function add(callable $task) : void
-    {
-        $this->queue[] = $task;
-    }
-    public function run() : void
-    {
-        while ($task = \array_shift($this->queue)) {
-            /** @var callable $task */
-            $task();
-        }
-    }
-    /**
-     * The task queue will be run and exhausted by default when the process
-     * exits IFF the exit is not the result of a PHP E_ERROR error.
-     *
-     * You can disable running the automatic shutdown of the queue by calling
-     * this function. If you disable the task queue shutdown process, then you
-     * MUST either run the task queue (as a result of running your event loop
-     * or manually using the run() method) or wait on each outstanding promise.
-     *
-     * Note: This shutdown will occur before any destructors are triggered.
-     */
-    public function disableShutdown() : void
-    {
-        $this->enableShutdown = \false;
-    }
+	private $enableShutdown = \true;
+	private $queue = [];
+	public function __construct(bool $withShutdown = \true)
+	{
+		if ($withShutdown) {
+			\register_shutdown_function(function () : void {
+				if ($this->enableShutdown) {
+					// Only run the tasks if an E_ERROR didn't occur.
+					$err = \error_get_last();
+					if (!$err || $err['type'] ^ \E_ERROR) {
+						$this->run();
+					}
+				}
+			});
+		}
+	}
+	public function isEmpty() : bool
+	{
+		return !$this->queue;
+	}
+	public function add(callable $task) : void
+	{
+		$this->queue[] = $task;
+	}
+	public function run() : void
+	{
+		while ($task = \array_shift($this->queue)) {
+			/** @var callable $task */
+			$task();
+		}
+	}
+	/**
+	 * The task queue will be run and exhausted by default when the process
+	 * exits IFF the exit is not the result of a PHP E_ERROR error.
+	 *
+	 * You can disable running the automatic shutdown of the queue by calling
+	 * this function. If you disable the task queue shutdown process, then you
+	 * MUST either run the task queue (as a result of running your event loop
+	 * or manually using the run() method) or wait on each outstanding promise.
+	 *
+	 * Note: This shutdown will occur before any destructors are triggered.
+	 */
+	public function disableShutdown() : void
+	{
+		$this->enableShutdown = \false;
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare (strict_types=1);
+declare(strict_types=1);
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
 /**
@@ -21,7 +21,7 @@ 
     public function __construct(bool $withShutdown = \true)
     {
         if ($withShutdown) {
-            \register_shutdown_function(function () : void {
+            \register_shutdown_function(function() : void {
                 if ($this->enableShutdown) {
                     // Only run the tasks if an E_ERROR didn't occur.
                     $err = \error_get_last();

Braces +1 added lines, -2 removed lines

@@ -14,8 +14,7 @@
  *
  * @final
  */
-class TaskQueue implements TaskQueueInterface
-{
+class TaskQueue implements TaskQueueInterface {
     private $enableShutdown = \true;
     private $queue = [];
     public function __construct(bool $withShutdown = \true)

lib/Vendor/GuzzleHttp/Promise/FulfilledPromise.php

Spacing +2 added lines, -2 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare (strict_types=1);
+declare(strict_types=1);
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
 /**
@@ -33,7 +33,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

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

Indentation +57 added lines, -57 removed lines

@@ -13,61 +13,61 @@
  */
 class FulfilledPromise implements PromiseInterface
 {
-    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.');
-        }
-        $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;
-        }
-        $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;
-    }
-    public function otherwise(callable $onRejected) : PromiseInterface
-    {
-        return $this->then(null, $onRejected);
-    }
-    public function wait(bool $unwrap = \true)
-    {
-        return $unwrap ? $this->value : null;
-    }
-    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 reject($reason) : void
-    {
-        throw new \LogicException('Cannot reject a fulfilled promise');
-    }
-    public function cancel() : void
-    {
-        // pass
-    }
+	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.');
+		}
+		$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;
+		}
+		$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;
+	}
+	public function otherwise(callable $onRejected) : PromiseInterface
+	{
+		return $this->then(null, $onRejected);
+	}
+	public function wait(bool $unwrap = \true)
+	{
+		return $unwrap ? $this->value : null;
+	}
+	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 reject($reason) : void
+	{
+		throw new \LogicException('Cannot reject a fulfilled promise');
+	}
+	public function cancel() : void
+	{
+		// pass
+	}
 }

lib/Vendor/GuzzleHttp/Promise/EachPromise.php

Indentation +182 added lines, -182 removed lines

@@ -11,186 +11,186 @@
  */
 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 +5 added lines, -5 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare (strict_types=1);
+declare(strict_types=1);
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
 /**
@@ -81,7 +81,7 @@ 
     private function createPromise() : void
     {
         $this->mutex = \false;
-        $this->aggregate = new Promise(function () : void {
+        $this->aggregate = new Promise(function() : void {
             if ($this->checkIfFinished()) {
                 return;
             }
@@ -97,7 +97,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;
@@ -138,12 +138,12 @@ 
         // 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 {
+        $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 {
+        }, function($reason) use($idx, $key) : void {
             if ($this->onRejected) {
                 ($this->onRejected)($reason, $key, $this->aggregate);
             }

Braces +1 added lines, -2 removed lines

@@ -9,8 +9,7 @@
  *
  * @final
  */
-class EachPromise implements PromisorInterface
-{
+class EachPromise implements PromisorInterface {
     private $pending = [];
     private $nextPendingIndex = 0;
     /** @var \Iterator|null */

lib/Vendor/GuzzleHttp/Promise/Is.php

Indentation +28 added lines, -28 removed lines

@@ -5,32 +5,32 @@
 
 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 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 rejected.
-     */
-    public static function rejected(PromiseInterface $promise) : bool
-    {
-        return $promise->getState() === PromiseInterface::REJECTED;
-    }
+	/**
+	 * 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.
+	 */
+	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;
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -1,6 +1,6 @@
 <?php
 
-declare (strict_types=1);
+declare(strict_types=1);
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
 final class Is

Braces +1 added lines, -2 removed lines

@@ -3,8 +3,7 @@
 declare (strict_types=1);
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
-final class Is
-{
+final class Is {
     /**
      * Returns true if a promise is pending.
      */

lib/Vendor/GuzzleHttp/Promise/RejectedPromise.php

Spacing +2 added lines, -2 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare (strict_types=1);
+declare(strict_types=1);
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
 /**
@@ -33,7 +33,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

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

Indentation +62 added lines, -62 removed lines

@@ -13,66 +13,66 @@
  */
 class RejectedPromise implements PromiseInterface
 {
-    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.');
-        }
-        $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;
-        }
-        $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;
-    }
-    public function otherwise(callable $onRejected) : PromiseInterface
-    {
-        return $this->then(null, $onRejected);
-    }
-    public function wait(bool $unwrap = \true)
-    {
-        if ($unwrap) {
-            throw Create::exceptionFor($this->reason);
-        }
-        return null;
-    }
-    public function getState() : string
-    {
-        return self::REJECTED;
-    }
-    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 cancel() : void
-    {
-        // pass
-    }
+	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.');
+		}
+		$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;
+		}
+		$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;
+	}
+	public function otherwise(callable $onRejected) : PromiseInterface
+	{
+		return $this->then(null, $onRejected);
+	}
+	public function wait(bool $unwrap = \true)
+	{
+		if ($unwrap) {
+			throw Create::exceptionFor($this->reason);
+		}
+		return null;
+	}
+	public function getState() : string
+	{
+		return self::REJECTED;
+	}
+	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 cancel() : void
+	{
+		// pass
+	}
 }

lib/Vendor/GuzzleHttp/Promise/Create.php

Indentation +60 added lines, -60 removed lines

@@ -5,64 +5,64 @@
 
 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;
-        }
-        // 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 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;
-        }
-        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;
-        }
-        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;
-        }
-        if (\is_array($value)) {
-            return new \ArrayIterator($value);
-        }
-        return new \ArrayIterator([$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 $promise;
+		}
+		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;
+		}
+		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;
+		}
+		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;
+		}
+		if (\is_array($value)) {
+			return new \ArrayIterator($value);
+		}
+		return new \ArrayIterator([$value]);
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -1,6 +1,6 @@
 <?php
 
-declare (strict_types=1);
+declare(strict_types=1);
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
 final class Create

Braces +1 added lines, -2 removed lines

@@ -3,8 +3,7 @@
 declare (strict_types=1);
 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/Each.php

Braces +1 added lines, -2 removed lines

@@ -3,8 +3,7 @@
 declare (strict_types=1);
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
-final class Each
-{
+final class Each {
     /**
      * Given an iterator that yields promises or values, returns a promise that
      * is fulfilled with a null value when the iterator has been consumed or

Indentation +48 added lines, -48 removed lines

@@ -5,52 +5,52 @@
 
 final class Each
 {
-    /**
-     * Given an iterator that yields promises or values, returns a promise that
-     * is fulfilled with a null value when the iterator has been consumed or
-     * the aggregate promise has been fulfilled or rejected.
-     *
-     * $onFulfilled is a function that accepts the fulfilled value, iterator
-     * index, and the aggregate promise. The callback can invoke any necessary
-     * side effects and choose to resolve or reject the aggregate if needed.
-     *
-     * $onRejected is a function that accepts the rejection reason, iterator
-     * index, and the aggregate promise. The callback can invoke any necessary
-     * side effects and choose to resolve or reject the aggregate if needed.
-     *
-     * @param mixed $iterable Iterator or array to iterate over.
-     */
-    public static function of($iterable, ?callable $onFulfilled = null, ?callable $onRejected = null) : PromiseInterface
-    {
-        return (new EachPromise($iterable, ['fulfilled' => $onFulfilled, 'rejected' => $onRejected]))->promise();
-    }
-    /**
-     * Like of, but only allows a certain number of outstanding promises at any
-     * given time.
-     *
-     * $concurrency may be an integer or a function that accepts the number of
-     * pending promises and returns a numeric concurrency limit value to allow
-     * for dynamic a concurrency size.
-     *
-     * @param mixed        $iterable
-     * @param int|callable $concurrency
-     */
-    public static function ofLimit($iterable, $concurrency, ?callable $onFulfilled = null, ?callable $onRejected = null) : PromiseInterface
-    {
-        return (new EachPromise($iterable, ['fulfilled' => $onFulfilled, 'rejected' => $onRejected, 'concurrency' => $concurrency]))->promise();
-    }
-    /**
-     * Like limit, but ensures that no promise in the given $iterable argument
-     * is rejected. If any promise is rejected, then the aggregate promise is
-     * rejected with the encountered rejection.
-     *
-     * @param mixed        $iterable
-     * @param int|callable $concurrency
-     */
-    public static function ofLimitAll($iterable, $concurrency, ?callable $onFulfilled = null) : PromiseInterface
-    {
-        return self::ofLimit($iterable, $concurrency, $onFulfilled, function ($reason, $idx, PromiseInterface $aggregate) : void {
-            $aggregate->reject($reason);
-        });
-    }
+	/**
+	 * Given an iterator that yields promises or values, returns a promise that
+	 * is fulfilled with a null value when the iterator has been consumed or
+	 * the aggregate promise has been fulfilled or rejected.
+	 *
+	 * $onFulfilled is a function that accepts the fulfilled value, iterator
+	 * index, and the aggregate promise. The callback can invoke any necessary
+	 * side effects and choose to resolve or reject the aggregate if needed.
+	 *
+	 * $onRejected is a function that accepts the rejection reason, iterator
+	 * index, and the aggregate promise. The callback can invoke any necessary
+	 * side effects and choose to resolve or reject the aggregate if needed.
+	 *
+	 * @param mixed $iterable Iterator or array to iterate over.
+	 */
+	public static function of($iterable, ?callable $onFulfilled = null, ?callable $onRejected = null) : PromiseInterface
+	{
+		return (new EachPromise($iterable, ['fulfilled' => $onFulfilled, 'rejected' => $onRejected]))->promise();
+	}
+	/**
+	 * Like of, but only allows a certain number of outstanding promises at any
+	 * given time.
+	 *
+	 * $concurrency may be an integer or a function that accepts the number of
+	 * pending promises and returns a numeric concurrency limit value to allow
+	 * for dynamic a concurrency size.
+	 *
+	 * @param mixed        $iterable
+	 * @param int|callable $concurrency
+	 */
+	public static function ofLimit($iterable, $concurrency, ?callable $onFulfilled = null, ?callable $onRejected = null) : PromiseInterface
+	{
+		return (new EachPromise($iterable, ['fulfilled' => $onFulfilled, 'rejected' => $onRejected, 'concurrency' => $concurrency]))->promise();
+	}
+	/**
+	 * Like limit, but ensures that no promise in the given $iterable argument
+	 * is rejected. If any promise is rejected, then the aggregate promise is
+	 * rejected with the encountered rejection.
+	 *
+	 * @param mixed        $iterable
+	 * @param int|callable $concurrency
+	 */
+	public static function ofLimitAll($iterable, $concurrency, ?callable $onFulfilled = null) : PromiseInterface
+	{
+		return self::ofLimit($iterable, $concurrency, $onFulfilled, function ($reason, $idx, PromiseInterface $aggregate) : void {
+			$aggregate->reject($reason);
+		});
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare (strict_types=1);
+declare(strict_types=1);
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
 final class Each
@@ -49,7 +49,7 @@ 
      */
     public static function ofLimitAll($iterable, $concurrency, ?callable $onFulfilled = null) : PromiseInterface
     {
-        return self::ofLimit($iterable, $concurrency, $onFulfilled, function ($reason, $idx, PromiseInterface $aggregate) : void {
+        return self::ofLimit($iterable, $concurrency, $onFulfilled, function($reason, $idx, PromiseInterface $aggregate) : void {
             $aggregate->reject($reason);
         });
     }

lib/Vendor/GuzzleHttp/Promise/AggregateException.php

Indentation +4 added lines, -4 removed lines

@@ -8,8 +8,8 @@
  */
 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

@@ -6,8 +6,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($reasons, \sprintf('%s; %d rejected promises', $msg, \count($reasons)));

Spacing +1 added lines, -1 removed lines

@@ -1,6 +1,6 @@
 <?php
 
-declare (strict_types=1);
+declare(strict_types=1);
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
 /**