nextcloud / fulltextsearch_elasticsearch

lib/Vendor/GuzzleHttp/Handler/MockHandler.php

Indentation +153 added lines, -153 removed lines

@@ -18,157 +18,157 @@
  */
 class MockHandler implements \Countable
 {
-    /**
-     * @var array
-     */
-    private $queue = [];
-    /**
-     * @var RequestInterface|null
-     */
-    private $lastRequest;
-    /**
-     * @var array
-     */
-    private $lastOptions = [];
-    /**
-     * @var callable|null
-     */
-    private $onFulfilled;
-    /**
-     * @var callable|null
-     */
-    private $onRejected;
-    /**
-     * Creates a new MockHandler that uses the default handler stack list of
-     * middlewares.
-     *
-     * @param array|null    $queue       Array of responses, callables, or exceptions.
-     * @param callable|null $onFulfilled Callback to invoke when the return value is fulfilled.
-     * @param callable|null $onRejected  Callback to invoke when the return value is rejected.
-     */
-    public static function createWithMiddleware(array $queue = null, callable $onFulfilled = null, callable $onRejected = null) : HandlerStack
-    {
-        return HandlerStack::create(new self($queue, $onFulfilled, $onRejected));
-    }
-    /**
-     * The passed in value must be an array of
-     * {@see \Psr\Http\Message\ResponseInterface} objects, Exceptions,
-     * callables, or Promises.
-     *
-     * @param array<int, mixed>|null $queue       The parameters to be passed to the append function, as an indexed array.
-     * @param callable|null          $onFulfilled Callback to invoke when the return value is fulfilled.
-     * @param callable|null          $onRejected  Callback to invoke when the return value is rejected.
-     */
-    public function __construct(array $queue = null, callable $onFulfilled = null, callable $onRejected = null)
-    {
-        $this->onFulfilled = $onFulfilled;
-        $this->onRejected = $onRejected;
-        if ($queue) {
-            // array_values included for BC
-            $this->append(...\array_values($queue));
-        }
-    }
-    public function __invoke(RequestInterface $request, array $options) : PromiseInterface
-    {
-        if (!$this->queue) {
-            throw new \OutOfBoundsException('Mock queue is empty');
-        }
-        if (isset($options['delay']) && \is_numeric($options['delay'])) {
-            \usleep((int) $options['delay'] * 1000);
-        }
-        $this->lastRequest = $request;
-        $this->lastOptions = $options;
-        $response = \array_shift($this->queue);
-        if (isset($options['on_headers'])) {
-            if (!\is_callable($options['on_headers'])) {
-                throw new \InvalidArgumentException('on_headers must be callable');
-            }
-            try {
-                $options['on_headers']($response);
-            } catch (\Exception $e) {
-                $msg = 'An error was encountered during the on_headers event';
-                $response = new RequestException($msg, $request, $response, $e);
-            }
-        }
-        if (\is_callable($response)) {
-            $response = $response($request, $options);
-        }
-        $response = $response instanceof \Throwable ? P\Create::rejectionFor($response) : P\Create::promiseFor($response);
-        return $response->then(function (?ResponseInterface $value) use($request, $options) {
-            $this->invokeStats($request, $options, $value);
-            if ($this->onFulfilled) {
-                ($this->onFulfilled)($value);
-            }
-            if ($value !== null && isset($options['sink'])) {
-                $contents = (string) $value->getBody();
-                $sink = $options['sink'];
-                if (\is_resource($sink)) {
-                    \fwrite($sink, $contents);
-                } elseif (\is_string($sink)) {
-                    \file_put_contents($sink, $contents);
-                } elseif ($sink instanceof StreamInterface) {
-                    $sink->write($contents);
-                }
-            }
-            return $value;
-        }, function ($reason) use($request, $options) {
-            $this->invokeStats($request, $options, null, $reason);
-            if ($this->onRejected) {
-                ($this->onRejected)($reason);
-            }
-            return P\Create::rejectionFor($reason);
-        });
-    }
-    /**
-     * Adds one or more variadic requests, exceptions, callables, or promises
-     * to the queue.
-     *
-     * @param mixed ...$values
-     */
-    public function append(...$values) : void
-    {
-        foreach ($values as $value) {
-            if ($value instanceof ResponseInterface || $value instanceof \Throwable || $value instanceof PromiseInterface || \is_callable($value)) {
-                $this->queue[] = $value;
-            } else {
-                throw new \TypeError('Expected a Response, Promise, Throwable or callable. Found ' . Utils::describeType($value));
-            }
-        }
-    }
-    /**
-     * Get the last received request.
-     */
-    public function getLastRequest() : ?RequestInterface
-    {
-        return $this->lastRequest;
-    }
-    /**
-     * Get the last received request options.
-     */
-    public function getLastOptions() : array
-    {
-        return $this->lastOptions;
-    }
-    /**
-     * Returns the number of remaining items in the queue.
-     */
-    public function count() : int
-    {
-        return \count($this->queue);
-    }
-    public function reset() : void
-    {
-        $this->queue = [];
-    }
-    /**
-     * @param mixed $reason Promise or reason.
-     */
-    private function invokeStats(RequestInterface $request, array $options, ResponseInterface $response = null, $reason = null) : void
-    {
-        if (isset($options['on_stats'])) {
-            $transferTime = $options['transfer_time'] ?? 0;
-            $stats = new TransferStats($request, $response, $transferTime, $reason);
-            $options['on_stats']($stats);
-        }
-    }
+	/**
+	 * @var array
+	 */
+	private $queue = [];
+	/**
+	 * @var RequestInterface|null
+	 */
+	private $lastRequest;
+	/**
+	 * @var array
+	 */
+	private $lastOptions = [];
+	/**
+	 * @var callable|null
+	 */
+	private $onFulfilled;
+	/**
+	 * @var callable|null
+	 */
+	private $onRejected;
+	/**
+	 * Creates a new MockHandler that uses the default handler stack list of
+	 * middlewares.
+	 *
+	 * @param array|null    $queue       Array of responses, callables, or exceptions.
+	 * @param callable|null $onFulfilled Callback to invoke when the return value is fulfilled.
+	 * @param callable|null $onRejected  Callback to invoke when the return value is rejected.
+	 */
+	public static function createWithMiddleware(array $queue = null, callable $onFulfilled = null, callable $onRejected = null) : HandlerStack
+	{
+		return HandlerStack::create(new self($queue, $onFulfilled, $onRejected));
+	}
+	/**
+	 * The passed in value must be an array of
+	 * {@see \Psr\Http\Message\ResponseInterface} objects, Exceptions,
+	 * callables, or Promises.
+	 *
+	 * @param array<int, mixed>|null $queue       The parameters to be passed to the append function, as an indexed array.
+	 * @param callable|null          $onFulfilled Callback to invoke when the return value is fulfilled.
+	 * @param callable|null          $onRejected  Callback to invoke when the return value is rejected.
+	 */
+	public function __construct(array $queue = null, callable $onFulfilled = null, callable $onRejected = null)
+	{
+		$this->onFulfilled = $onFulfilled;
+		$this->onRejected = $onRejected;
+		if ($queue) {
+			// array_values included for BC
+			$this->append(...\array_values($queue));
+		}
+	}
+	public function __invoke(RequestInterface $request, array $options) : PromiseInterface
+	{
+		if (!$this->queue) {
+			throw new \OutOfBoundsException('Mock queue is empty');
+		}
+		if (isset($options['delay']) && \is_numeric($options['delay'])) {
+			\usleep((int) $options['delay'] * 1000);
+		}
+		$this->lastRequest = $request;
+		$this->lastOptions = $options;
+		$response = \array_shift($this->queue);
+		if (isset($options['on_headers'])) {
+			if (!\is_callable($options['on_headers'])) {
+				throw new \InvalidArgumentException('on_headers must be callable');
+			}
+			try {
+				$options['on_headers']($response);
+			} catch (\Exception $e) {
+				$msg = 'An error was encountered during the on_headers event';
+				$response = new RequestException($msg, $request, $response, $e);
+			}
+		}
+		if (\is_callable($response)) {
+			$response = $response($request, $options);
+		}
+		$response = $response instanceof \Throwable ? P\Create::rejectionFor($response) : P\Create::promiseFor($response);
+		return $response->then(function (?ResponseInterface $value) use($request, $options) {
+			$this->invokeStats($request, $options, $value);
+			if ($this->onFulfilled) {
+				($this->onFulfilled)($value);
+			}
+			if ($value !== null && isset($options['sink'])) {
+				$contents = (string) $value->getBody();
+				$sink = $options['sink'];
+				if (\is_resource($sink)) {
+					\fwrite($sink, $contents);
+				} elseif (\is_string($sink)) {
+					\file_put_contents($sink, $contents);
+				} elseif ($sink instanceof StreamInterface) {
+					$sink->write($contents);
+				}
+			}
+			return $value;
+		}, function ($reason) use($request, $options) {
+			$this->invokeStats($request, $options, null, $reason);
+			if ($this->onRejected) {
+				($this->onRejected)($reason);
+			}
+			return P\Create::rejectionFor($reason);
+		});
+	}
+	/**
+	 * Adds one or more variadic requests, exceptions, callables, or promises
+	 * to the queue.
+	 *
+	 * @param mixed ...$values
+	 */
+	public function append(...$values) : void
+	{
+		foreach ($values as $value) {
+			if ($value instanceof ResponseInterface || $value instanceof \Throwable || $value instanceof PromiseInterface || \is_callable($value)) {
+				$this->queue[] = $value;
+			} else {
+				throw new \TypeError('Expected a Response, Promise, Throwable or callable. Found ' . Utils::describeType($value));
+			}
+		}
+	}
+	/**
+	 * Get the last received request.
+	 */
+	public function getLastRequest() : ?RequestInterface
+	{
+		return $this->lastRequest;
+	}
+	/**
+	 * Get the last received request options.
+	 */
+	public function getLastOptions() : array
+	{
+		return $this->lastOptions;
+	}
+	/**
+	 * Returns the number of remaining items in the queue.
+	 */
+	public function count() : int
+	{
+		return \count($this->queue);
+	}
+	public function reset() : void
+	{
+		$this->queue = [];
+	}
+	/**
+	 * @param mixed $reason Promise or reason.
+	 */
+	private function invokeStats(RequestInterface $request, array $options, ResponseInterface $response = null, $reason = null) : void
+	{
+		if (isset($options['on_stats'])) {
+			$transferTime = $options['transfer_time'] ?? 0;
+			$stats = new TransferStats($request, $response, $transferTime, $reason);
+			$options['on_stats']($stats);
+		}
+	}
 }

Spacing +5 added lines, -5 removed lines

@@ -74,7 +74,7 @@ 
             throw new \OutOfBoundsException('Mock queue is empty');
         }
         if (isset($options['delay']) && \is_numeric($options['delay'])) {
-            \usleep((int) $options['delay'] * 1000);
+            \usleep((int)$options['delay'] * 1000);
         }
         $this->lastRequest = $request;
         $this->lastOptions = $options;
@@ -94,13 +94,13 @@ 
             $response = $response($request, $options);
         }
         $response = $response instanceof \Throwable ? P\Create::rejectionFor($response) : P\Create::promiseFor($response);
-        return $response->then(function (?ResponseInterface $value) use($request, $options) {
+        return $response->then(function(?ResponseInterface $value) use($request, $options) {
             $this->invokeStats($request, $options, $value);
             if ($this->onFulfilled) {
                 ($this->onFulfilled)($value);
             }
             if ($value !== null && isset($options['sink'])) {
-                $contents = (string) $value->getBody();
+                $contents = (string)$value->getBody();
                 $sink = $options['sink'];
                 if (\is_resource($sink)) {
                     \fwrite($sink, $contents);
@@ -111,7 +111,7 @@ 
                 }
             }
             return $value;
-        }, function ($reason) use($request, $options) {
+        }, function($reason) use($request, $options) {
             $this->invokeStats($request, $options, null, $reason);
             if ($this->onRejected) {
                 ($this->onRejected)($reason);
@@ -131,7 +131,7 @@ 
             if ($value instanceof ResponseInterface || $value instanceof \Throwable || $value instanceof PromiseInterface || \is_callable($value)) {
                 $this->queue[] = $value;
             } else {
-                throw new \TypeError('Expected a Response, Promise, Throwable or callable. Found ' . Utils::describeType($value));
+                throw new \TypeError('Expected a Response, Promise, Throwable or callable. Found '.Utils::describeType($value));
             }
         }
     }

lib/Vendor/GuzzleHttp/functions.php

Indentation +10 added lines, -10 removed lines

@@ -15,7 +15,7 @@ 
  */
 function describe_type($input) : string
 {
-    return Utils::describeType($input);
+	return Utils::describeType($input);
 }
 /**
  * Parses an array of header lines into an associative array of headers.
@@ -27,7 +27,7 @@ 
  */
 function headers_from_lines(iterable $lines) : array
 {
-    return Utils::headersFromLines($lines);
+	return Utils::headersFromLines($lines);
 }
 /**
  * Returns a debug stream based on the provided variable.
@@ -40,7 +40,7 @@ 
  */
 function debug_resource($value = null)
 {
-    return Utils::debugResource($value);
+	return Utils::debugResource($value);
 }
 /**
  * Chooses and creates a default handler to use based on the environment.
@@ -55,7 +55,7 @@ 
  */
 function choose_handler() : callable
 {
-    return Utils::chooseHandler();
+	return Utils::chooseHandler();
 }
 /**
  * Get the default User-Agent string to use with Guzzle.
@@ -64,7 +64,7 @@ 
  */
 function default_user_agent() : string
 {
-    return Utils::defaultUserAgent();
+	return Utils::defaultUserAgent();
 }
 /**
  * Returns the default cacert bundle for the current system.
@@ -83,7 +83,7 @@ 
  */
 function default_ca_bundle() : string
 {
-    return Utils::defaultCaBundle();
+	return Utils::defaultCaBundle();
 }
 /**
  * Creates an associative array of lowercase header names to the actual
@@ -93,7 +93,7 @@ 
  */
 function normalize_header_keys(array $headers) : array
 {
-    return Utils::normalizeHeaderKeys($headers);
+	return Utils::normalizeHeaderKeys($headers);
 }
 /**
  * Returns true if the provided host matches any of the no proxy areas.
@@ -118,7 +118,7 @@ 
  */
 function is_host_in_noproxy(string $host, array $noProxyArray) : bool
 {
-    return Utils::isHostInNoProxy($host, $noProxyArray);
+	return Utils::isHostInNoProxy($host, $noProxyArray);
 }
 /**
  * Wrapper for json_decode that throws when an error occurs.
@@ -138,7 +138,7 @@ 
  */
 function json_decode(string $json, bool $assoc = \false, int $depth = 512, int $options = 0)
 {
-    return Utils::jsonDecode($json, $assoc, $depth, $options);
+	return Utils::jsonDecode($json, $assoc, $depth, $options);
 }
 /**
  * Wrapper for JSON encoding that throws when an error occurs.
@@ -154,5 +154,5 @@ 
  */
 function json_encode($value, int $options = 0, int $depth = 512) : string
 {
-    return Utils::jsonEncode($value, $options, $depth);
+	return Utils::jsonEncode($value, $options, $depth);
 }

lib/Vendor/GuzzleHttp/Promise/TaskQueueInterface.php

Indentation +13 added lines, -13 removed lines

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

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;
 
 interface TaskQueueInterface

Braces +1 added lines, -2 removed lines

@@ -3,8 +3,7 @@
 declare (strict_types=1);
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
-interface TaskQueueInterface
-{
+interface TaskQueueInterface {
     /**
      * Returns true if the queue is empty.
      */

lib/Vendor/GuzzleHttp/Promise/RejectionException.php

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;
+	}
 }

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);
     }

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

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
+	}
 }

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

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

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
+	}
 }

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