nextcloud / fulltextsearch_elasticsearch

lib/Vendor/GuzzleHttp/Promise/PromiseInterface.php

Braces +1 added lines, -2 removed lines

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

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;
 
 /**

Indentation +63 added lines, -63 removed lines

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

lib/Vendor/GuzzleHttp/Promise/CancellationException.php

Braces +1 added lines, -2 removed lines

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

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;
 
 /**

lib/Vendor/GuzzleHttp/Promise/Promise.php

Braces +1 added lines, -2 removed lines

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

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;
 
 /**
@@ -124,7 +124,7 @@ 
         if (!\is_object($value) || !\method_exists($value, 'then')) {
             $id = $state === self::FULFILLED ? 1 : 2;
             // It's a success, so resolve the handlers in the queue.
-            Utils::queue()->add(static function () use($id, $value, $handlers) : void {
+            Utils::queue()->add(static function() use($id, $value, $handlers) : void {
                 foreach ($handlers as $handler) {
                     self::callHandler($id, $value, $handler);
                 }
@@ -134,11 +134,11 @@ 
             $value->handlers = \array_merge($value->handlers, $handlers);
         } else {
             // Resolve the handlers when the forwarded promise is resolved.
-            $value->then(static function ($value) use($handlers) : void {
+            $value->then(static function($value) use($handlers) : void {
                 foreach ($handlers as $handler) {
                     self::callHandler(1, $value, $handler);
                 }
-            }, static function ($reason) use($handlers) : void {
+            }, static function($reason) use($handlers) : void {
                 foreach ($handlers as $handler) {
                     self::callHandler(2, $reason, $handler);
                 }
@@ -193,7 +193,7 @@ 
             $this->invokeWaitList();
         } else {
             // If there's no wait function, then reject the promise.
-            $this->reject('Cannot wait on a promise that has ' . 'no internal wait function. You must provide a wait ' . 'function when constructing the promise to be able to ' . 'wait on a promise.');
+            $this->reject('Cannot wait on a promise that has '.'no internal wait function. You must provide a wait '.'function when constructing the promise to be able to '.'wait on a promise.');
         }
         Utils::queue()->run();
         /** @psalm-suppress RedundantCondition */

Indentation +216 added lines, -216 removed lines

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

lib/Vendor/GuzzleHttp/Promise/PromisorInterface.php

Braces +1 added lines, -2 removed lines

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

Indentation +4 added lines, -4 removed lines

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

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;
 
 /**

lib/Vendor/GuzzleHttp/Middleware.php

Braces +1 added lines, -2 removed lines

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

Indentation +210 added lines, -210 removed lines

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

Spacing +23 added lines, -23 removed lines

@@ -24,8 +24,8 @@ 
      */
     public static function cookies() : callable
     {
-        return static function (callable $handler) : callable {
-            return static function ($request, array $options) use($handler) {
+        return static function(callable $handler) : callable {
+            return static function($request, array $options) use($handler) {
                 if (empty($options['cookies'])) {
                     return $handler($request, $options);
                 } elseif (!$options['cookies'] instanceof CookieJarInterface) {
@@ -33,7 +33,7 @@ 
                 }
                 $cookieJar = $options['cookies'];
                 $request = $cookieJar->withCookieHeader($request);
-                return $handler($request, $options)->then(static function (ResponseInterface $response) use($cookieJar, $request) : ResponseInterface {
+                return $handler($request, $options)->then(static function(ResponseInterface $response) use($cookieJar, $request) : ResponseInterface {
                     $cookieJar->extractCookies($request, $response);
                     return $response;
                 });
@@ -50,12 +50,12 @@ 
      */
     public static function httpErrors(?BodySummarizerInterface $bodySummarizer = null) : callable
     {
-        return static function (callable $handler) use($bodySummarizer) : callable {
-            return static function ($request, array $options) use($handler, $bodySummarizer) {
+        return static function(callable $handler) use($bodySummarizer) : callable {
+            return static function($request, array $options) use($handler, $bodySummarizer) {
                 if (empty($options['http_errors'])) {
                     return $handler($request, $options);
                 }
-                return $handler($request, $options)->then(static function (ResponseInterface $response) use($request, $bodySummarizer) {
+                return $handler($request, $options)->then(static function(ResponseInterface $response) use($request, $bodySummarizer) {
                     $code = $response->getStatusCode();
                     if ($code < 400) {
                         return $response;
@@ -79,12 +79,12 @@ 
         if (!\is_array($container) && !$container instanceof \ArrayAccess) {
             throw new \InvalidArgumentException('history container must be an array or object implementing ArrayAccess');
         }
-        return static function (callable $handler) use(&$container) : callable {
-            return static function (RequestInterface $request, array $options) use($handler, &$container) {
-                return $handler($request, $options)->then(static function ($value) use($request, &$container, $options) {
+        return static function(callable $handler) use(&$container) : callable {
+            return static function(RequestInterface $request, array $options) use($handler, &$container) {
+                return $handler($request, $options)->then(static function($value) use($request, &$container, $options) {
                     $container[] = ['request' => $request, 'response' => $value, 'error' => null, 'options' => $options];
                     return $value;
-                }, static function ($reason) use($request, &$container, $options) {
+                }, static function($reason) use($request, &$container, $options) {
                     $container[] = ['request' => $request, 'response' => null, 'error' => $reason, 'options' => $options];
                     return P\Create::rejectionFor($reason);
                 });
@@ -106,8 +106,8 @@ 
      */
     public static function tap(?callable $before = null, ?callable $after = null) : callable
     {
-        return static function (callable $handler) use($before, $after) : callable {
-            return static function (RequestInterface $request, array $options) use($handler, $before, $after) {
+        return static function(callable $handler) use($before, $after) : callable {
+            return static function(RequestInterface $request, array $options) use($handler, $before, $after) {
                 if ($before) {
                     $before($request, $options);
                 }
@@ -126,7 +126,7 @@ 
      */
     public static function redirect() : callable
     {
-        return static function (callable $handler) : RedirectMiddleware {
+        return static function(callable $handler) : RedirectMiddleware {
             return new RedirectMiddleware($handler);
         };
     }
@@ -147,7 +147,7 @@ 
      */
     public static function retry(callable $decider, ?callable $delay = null) : callable
     {
-        return static function (callable $handler) use($decider, $delay) : RetryMiddleware {
+        return static function(callable $handler) use($decider, $delay) : RetryMiddleware {
             return new RetryMiddleware($decider, $handler, $delay);
         };
     }
@@ -169,13 +169,13 @@ 
         if (!$formatter instanceof MessageFormatter && !$formatter instanceof MessageFormatterInterface) {
             throw new \LogicException(\sprintf('Argument 2 to %s::log() must be of type %s', self::class, MessageFormatterInterface::class));
         }
-        return static function (callable $handler) use($logger, $formatter, $logLevel) : callable {
-            return static function (RequestInterface $request, array $options = []) use($handler, $logger, $formatter, $logLevel) {
-                return $handler($request, $options)->then(static function ($response) use($logger, $request, $formatter, $logLevel) : ResponseInterface {
+        return static function(callable $handler) use($logger, $formatter, $logLevel) : callable {
+            return static function(RequestInterface $request, array $options = []) use($handler, $logger, $formatter, $logLevel) {
+                return $handler($request, $options)->then(static function($response) use($logger, $request, $formatter, $logLevel) : ResponseInterface {
                     $message = $formatter->format($request, $response);
                     $logger->log($logLevel, $message);
                     return $response;
-                }, static function ($reason) use($logger, $request, $formatter) : PromiseInterface {
+                }, static function($reason) use($logger, $request, $formatter) : PromiseInterface {
                     $response = $reason instanceof RequestException ? $reason->getResponse() : null;
                     $message = $formatter->format($request, $response, P\Create::exceptionFor($reason));
                     $logger->error($message);
@@ -190,7 +190,7 @@ 
      */
     public static function prepareBody() : callable
     {
-        return static function (callable $handler) : PrepareBodyMiddleware {
+        return static function(callable $handler) : PrepareBodyMiddleware {
             return new PrepareBodyMiddleware($handler);
         };
     }
@@ -203,8 +203,8 @@ 
      */
     public static function mapRequest(callable $fn) : callable
     {
-        return static function (callable $handler) use($fn) : callable {
-            return static function (RequestInterface $request, array $options) use($handler, $fn) {
+        return static function(callable $handler) use($fn) : callable {
+            return static function(RequestInterface $request, array $options) use($handler, $fn) {
                 return $handler($fn($request), $options);
             };
         };
@@ -218,8 +218,8 @@ 
      */
     public static function mapResponse(callable $fn) : callable
     {
-        return static function (callable $handler) use($fn) : callable {
-            return static function (RequestInterface $request, array $options) use($handler, $fn) {
+        return static function(callable $handler) use($fn) : callable {
+            return static function(RequestInterface $request, array $options) use($handler, $fn) {
                 return $handler($request, $options)->then($fn);
             };
         };

lib/Vendor/GuzzleHttp/HandlerStack.php

Braces +1 added lines, -2 removed lines

@@ -12,8 +12,7 @@
  *
  * @final
  */
-class HandlerStack
-{
+class HandlerStack {
     /**
      * @var (callable(RequestInterface, array): PromiseInterface)|null
      */

Spacing +5 added lines, -5 removed lines

@@ -76,13 +76,13 @@ 
         $depth = 0;
         $stack = [];
         if ($this->handler !== null) {
-            $stack[] = '0) Handler: ' . $this->debugCallable($this->handler);
+            $stack[] = '0) Handler: '.$this->debugCallable($this->handler);
         }
         $result = '';
         foreach (\array_reverse($this->stack) as $tuple) {
             ++$depth;
             $str = "{$depth}) Name: '{$tuple[1]}', ";
-            $str .= 'Function: ' . $this->debugCallable($tuple[0]);
+            $str .= 'Function: '.$this->debugCallable($tuple[0]);
             $result = "> {$str}\n{$result}";
             $stack[] = $str;
         }
@@ -165,7 +165,7 @@ 
         }
         $this->cached = null;
         $idx = \is_callable($remove) ? 0 : 1;
-        $this->stack = \array_values(\array_filter($this->stack, static function ($tuple) use($idx, $remove) {
+        $this->stack = \array_values(\array_filter($this->stack, static function($tuple) use($idx, $remove) {
             return $tuple[$idx] !== $remove;
         }));
     }
@@ -230,9 +230,9 @@ 
             return "callable({$fn})";
         }
         if (\is_array($fn)) {
-            return \is_string($fn[0]) ? "callable({$fn[0]}::{$fn[1]})" : "callable(['" . \get_class($fn[0]) . "', '{$fn[1]}'])";
+            return \is_string($fn[0]) ? "callable({$fn[0]}::{$fn[1]})" : "callable(['".\get_class($fn[0])."', '{$fn[1]}'])";
         }
         /** @var object $fn */
-        return 'callable(' . \spl_object_hash($fn) . ')';
+        return 'callable('.\spl_object_hash($fn).')';
     }
 }

Indentation +222 added lines, -222 removed lines

@@ -13,226 +13,226 @@
  */
 class HandlerStack
 {
-    /**
-     * @var (callable(RequestInterface, array): PromiseInterface)|null
-     */
-    private $handler;
-    /**
-     * @var array{(callable(callable(RequestInterface, array): PromiseInterface): callable), (string|null)}[]
-     */
-    private $stack = [];
-    /**
-     * @var (callable(RequestInterface, array): PromiseInterface)|null
-     */
-    private $cached;
-    /**
-     * Creates a default handler stack that can be used by clients.
-     *
-     * The returned handler will wrap the provided handler or use the most
-     * appropriate default handler for your system. The returned HandlerStack has
-     * support for cookies, redirects, HTTP error exceptions, and preparing a body
-     * before sending.
-     *
-     * The returned handler stack can be passed to a client in the "handler"
-     * option.
-     *
-     * @param (callable(RequestInterface, array): PromiseInterface)|null $handler HTTP handler function to use with the stack. If no
-     *                                                                            handler is provided, the best handler for your
-     *                                                                            system will be utilized.
-     */
-    public static function create(?callable $handler = null) : self
-    {
-        $stack = new self($handler ?: Utils::chooseHandler());
-        $stack->push(Middleware::httpErrors(), 'http_errors');
-        $stack->push(Middleware::redirect(), 'allow_redirects');
-        $stack->push(Middleware::cookies(), 'cookies');
-        $stack->push(Middleware::prepareBody(), 'prepare_body');
-        return $stack;
-    }
-    /**
-     * @param (callable(RequestInterface, array): PromiseInterface)|null $handler Underlying HTTP handler.
-     */
-    public function __construct(?callable $handler = null)
-    {
-        $this->handler = $handler;
-    }
-    /**
-     * Invokes the handler stack as a composed handler
-     *
-     * @return ResponseInterface|PromiseInterface
-     */
-    public function __invoke(RequestInterface $request, array $options)
-    {
-        $handler = $this->resolve();
-        return $handler($request, $options);
-    }
-    /**
-     * Dumps a string representation of the stack.
-     *
-     * @return string
-     */
-    public function __toString()
-    {
-        $depth = 0;
-        $stack = [];
-        if ($this->handler !== null) {
-            $stack[] = '0) Handler: ' . $this->debugCallable($this->handler);
-        }
-        $result = '';
-        foreach (\array_reverse($this->stack) as $tuple) {
-            ++$depth;
-            $str = "{$depth}) Name: '{$tuple[1]}', ";
-            $str .= 'Function: ' . $this->debugCallable($tuple[0]);
-            $result = "> {$str}\n{$result}";
-            $stack[] = $str;
-        }
-        foreach (\array_keys($stack) as $k) {
-            $result .= "< {$stack[$k]}\n";
-        }
-        return $result;
-    }
-    /**
-     * Set the HTTP handler that actually returns a promise.
-     *
-     * @param callable(RequestInterface, array): PromiseInterface $handler Accepts a request and array of options and
-     *                                                                     returns a Promise.
-     */
-    public function setHandler(callable $handler) : void
-    {
-        $this->handler = $handler;
-        $this->cached = null;
-    }
-    /**
-     * Returns true if the builder has a handler.
-     */
-    public function hasHandler() : bool
-    {
-        return $this->handler !== null;
-    }
-    /**
-     * Unshift a middleware to the bottom of the stack.
-     *
-     * @param callable(callable): callable $middleware Middleware function
-     * @param string                       $name       Name to register for this middleware.
-     */
-    public function unshift(callable $middleware, ?string $name = null) : void
-    {
-        \array_unshift($this->stack, [$middleware, $name]);
-        $this->cached = null;
-    }
-    /**
-     * Push a middleware to the top of the stack.
-     *
-     * @param callable(callable): callable $middleware Middleware function
-     * @param string                       $name       Name to register for this middleware.
-     */
-    public function push(callable $middleware, string $name = '') : void
-    {
-        $this->stack[] = [$middleware, $name];
-        $this->cached = null;
-    }
-    /**
-     * Add a middleware before another middleware by name.
-     *
-     * @param string                       $findName   Middleware to find
-     * @param callable(callable): callable $middleware Middleware function
-     * @param string                       $withName   Name to register for this middleware.
-     */
-    public function before(string $findName, callable $middleware, string $withName = '') : void
-    {
-        $this->splice($findName, $withName, $middleware, \true);
-    }
-    /**
-     * Add a middleware after another middleware by name.
-     *
-     * @param string                       $findName   Middleware to find
-     * @param callable(callable): callable $middleware Middleware function
-     * @param string                       $withName   Name to register for this middleware.
-     */
-    public function after(string $findName, callable $middleware, string $withName = '') : void
-    {
-        $this->splice($findName, $withName, $middleware, \false);
-    }
-    /**
-     * Remove a middleware by instance or name from the stack.
-     *
-     * @param callable|string $remove Middleware to remove by instance or name.
-     */
-    public function remove($remove) : void
-    {
-        if (!\is_string($remove) && !\is_callable($remove)) {
-            trigger_deprecation('guzzlehttp/guzzle', '7.4', 'Not passing a callable or string to %s::%s() is deprecated and will cause an error in 8.0.', __CLASS__, __FUNCTION__);
-        }
-        $this->cached = null;
-        $idx = \is_callable($remove) ? 0 : 1;
-        $this->stack = \array_values(\array_filter($this->stack, static function ($tuple) use($idx, $remove) {
-            return $tuple[$idx] !== $remove;
-        }));
-    }
-    /**
-     * Compose the middleware and handler into a single callable function.
-     *
-     * @return callable(RequestInterface, array): PromiseInterface
-     */
-    public function resolve() : callable
-    {
-        if ($this->cached === null) {
-            if (($prev = $this->handler) === null) {
-                throw new \LogicException('No handler has been specified');
-            }
-            foreach (\array_reverse($this->stack) as $fn) {
-                /** @var callable(RequestInterface, array): PromiseInterface $prev */
-                $prev = $fn[0]($prev);
-            }
-            $this->cached = $prev;
-        }
-        return $this->cached;
-    }
-    private function findByName(string $name) : int
-    {
-        foreach ($this->stack as $k => $v) {
-            if ($v[1] === $name) {
-                return $k;
-            }
-        }
-        throw new \InvalidArgumentException("Middleware not found: {$name}");
-    }
-    /**
-     * Splices a function into the middleware list at a specific position.
-     */
-    private function splice(string $findName, string $withName, callable $middleware, bool $before) : void
-    {
-        $this->cached = null;
-        $idx = $this->findByName($findName);
-        $tuple = [$middleware, $withName];
-        if ($before) {
-            if ($idx === 0) {
-                \array_unshift($this->stack, $tuple);
-            } else {
-                $replacement = [$tuple, $this->stack[$idx]];
-                \array_splice($this->stack, $idx, 1, $replacement);
-            }
-        } elseif ($idx === \count($this->stack) - 1) {
-            $this->stack[] = $tuple;
-        } else {
-            $replacement = [$this->stack[$idx], $tuple];
-            \array_splice($this->stack, $idx, 1, $replacement);
-        }
-    }
-    /**
-     * Provides a debug string for a given callable.
-     *
-     * @param callable|string $fn Function to write as a string.
-     */
-    private function debugCallable($fn) : string
-    {
-        if (\is_string($fn)) {
-            return "callable({$fn})";
-        }
-        if (\is_array($fn)) {
-            return \is_string($fn[0]) ? "callable({$fn[0]}::{$fn[1]})" : "callable(['" . \get_class($fn[0]) . "', '{$fn[1]}'])";
-        }
-        /** @var object $fn */
-        return 'callable(' . \spl_object_hash($fn) . ')';
-    }
+	/**
+	 * @var (callable(RequestInterface, array): PromiseInterface)|null
+	 */
+	private $handler;
+	/**
+	 * @var array{(callable(callable(RequestInterface, array): PromiseInterface): callable), (string|null)}[]
+	 */
+	private $stack = [];
+	/**
+	 * @var (callable(RequestInterface, array): PromiseInterface)|null
+	 */
+	private $cached;
+	/**
+	 * Creates a default handler stack that can be used by clients.
+	 *
+	 * The returned handler will wrap the provided handler or use the most
+	 * appropriate default handler for your system. The returned HandlerStack has
+	 * support for cookies, redirects, HTTP error exceptions, and preparing a body
+	 * before sending.
+	 *
+	 * The returned handler stack can be passed to a client in the "handler"
+	 * option.
+	 *
+	 * @param (callable(RequestInterface, array): PromiseInterface)|null $handler HTTP handler function to use with the stack. If no
+	 *                                                                            handler is provided, the best handler for your
+	 *                                                                            system will be utilized.
+	 */
+	public static function create(?callable $handler = null) : self
+	{
+		$stack = new self($handler ?: Utils::chooseHandler());
+		$stack->push(Middleware::httpErrors(), 'http_errors');
+		$stack->push(Middleware::redirect(), 'allow_redirects');
+		$stack->push(Middleware::cookies(), 'cookies');
+		$stack->push(Middleware::prepareBody(), 'prepare_body');
+		return $stack;
+	}
+	/**
+	 * @param (callable(RequestInterface, array): PromiseInterface)|null $handler Underlying HTTP handler.
+	 */
+	public function __construct(?callable $handler = null)
+	{
+		$this->handler = $handler;
+	}
+	/**
+	 * Invokes the handler stack as a composed handler
+	 *
+	 * @return ResponseInterface|PromiseInterface
+	 */
+	public function __invoke(RequestInterface $request, array $options)
+	{
+		$handler = $this->resolve();
+		return $handler($request, $options);
+	}
+	/**
+	 * Dumps a string representation of the stack.
+	 *
+	 * @return string
+	 */
+	public function __toString()
+	{
+		$depth = 0;
+		$stack = [];
+		if ($this->handler !== null) {
+			$stack[] = '0) Handler: ' . $this->debugCallable($this->handler);
+		}
+		$result = '';
+		foreach (\array_reverse($this->stack) as $tuple) {
+			++$depth;
+			$str = "{$depth}) Name: '{$tuple[1]}', ";
+			$str .= 'Function: ' . $this->debugCallable($tuple[0]);
+			$result = "> {$str}\n{$result}";
+			$stack[] = $str;
+		}
+		foreach (\array_keys($stack) as $k) {
+			$result .= "< {$stack[$k]}\n";
+		}
+		return $result;
+	}
+	/**
+	 * Set the HTTP handler that actually returns a promise.
+	 *
+	 * @param callable(RequestInterface, array): PromiseInterface $handler Accepts a request and array of options and
+	 *                                                                     returns a Promise.
+	 */
+	public function setHandler(callable $handler) : void
+	{
+		$this->handler = $handler;
+		$this->cached = null;
+	}
+	/**
+	 * Returns true if the builder has a handler.
+	 */
+	public function hasHandler() : bool
+	{
+		return $this->handler !== null;
+	}
+	/**
+	 * Unshift a middleware to the bottom of the stack.
+	 *
+	 * @param callable(callable): callable $middleware Middleware function
+	 * @param string                       $name       Name to register for this middleware.
+	 */
+	public function unshift(callable $middleware, ?string $name = null) : void
+	{
+		\array_unshift($this->stack, [$middleware, $name]);
+		$this->cached = null;
+	}
+	/**
+	 * Push a middleware to the top of the stack.
+	 *
+	 * @param callable(callable): callable $middleware Middleware function
+	 * @param string                       $name       Name to register for this middleware.
+	 */
+	public function push(callable $middleware, string $name = '') : void
+	{
+		$this->stack[] = [$middleware, $name];
+		$this->cached = null;
+	}
+	/**
+	 * Add a middleware before another middleware by name.
+	 *
+	 * @param string                       $findName   Middleware to find
+	 * @param callable(callable): callable $middleware Middleware function
+	 * @param string                       $withName   Name to register for this middleware.
+	 */
+	public function before(string $findName, callable $middleware, string $withName = '') : void
+	{
+		$this->splice($findName, $withName, $middleware, \true);
+	}
+	/**
+	 * Add a middleware after another middleware by name.
+	 *
+	 * @param string                       $findName   Middleware to find
+	 * @param callable(callable): callable $middleware Middleware function
+	 * @param string                       $withName   Name to register for this middleware.
+	 */
+	public function after(string $findName, callable $middleware, string $withName = '') : void
+	{
+		$this->splice($findName, $withName, $middleware, \false);
+	}
+	/**
+	 * Remove a middleware by instance or name from the stack.
+	 *
+	 * @param callable|string $remove Middleware to remove by instance or name.
+	 */
+	public function remove($remove) : void
+	{
+		if (!\is_string($remove) && !\is_callable($remove)) {
+			trigger_deprecation('guzzlehttp/guzzle', '7.4', 'Not passing a callable or string to %s::%s() is deprecated and will cause an error in 8.0.', __CLASS__, __FUNCTION__);
+		}
+		$this->cached = null;
+		$idx = \is_callable($remove) ? 0 : 1;
+		$this->stack = \array_values(\array_filter($this->stack, static function ($tuple) use($idx, $remove) {
+			return $tuple[$idx] !== $remove;
+		}));
+	}
+	/**
+	 * Compose the middleware and handler into a single callable function.
+	 *
+	 * @return callable(RequestInterface, array): PromiseInterface
+	 */
+	public function resolve() : callable
+	{
+		if ($this->cached === null) {
+			if (($prev = $this->handler) === null) {
+				throw new \LogicException('No handler has been specified');
+			}
+			foreach (\array_reverse($this->stack) as $fn) {
+				/** @var callable(RequestInterface, array): PromiseInterface $prev */
+				$prev = $fn[0]($prev);
+			}
+			$this->cached = $prev;
+		}
+		return $this->cached;
+	}
+	private function findByName(string $name) : int
+	{
+		foreach ($this->stack as $k => $v) {
+			if ($v[1] === $name) {
+				return $k;
+			}
+		}
+		throw new \InvalidArgumentException("Middleware not found: {$name}");
+	}
+	/**
+	 * Splices a function into the middleware list at a specific position.
+	 */
+	private function splice(string $findName, string $withName, callable $middleware, bool $before) : void
+	{
+		$this->cached = null;
+		$idx = $this->findByName($findName);
+		$tuple = [$middleware, $withName];
+		if ($before) {
+			if ($idx === 0) {
+				\array_unshift($this->stack, $tuple);
+			} else {
+				$replacement = [$tuple, $this->stack[$idx]];
+				\array_splice($this->stack, $idx, 1, $replacement);
+			}
+		} elseif ($idx === \count($this->stack) - 1) {
+			$this->stack[] = $tuple;
+		} else {
+			$replacement = [$this->stack[$idx], $tuple];
+			\array_splice($this->stack, $idx, 1, $replacement);
+		}
+	}
+	/**
+	 * Provides a debug string for a given callable.
+	 *
+	 * @param callable|string $fn Function to write as a string.
+	 */
+	private function debugCallable($fn) : string
+	{
+		if (\is_string($fn)) {
+			return "callable({$fn})";
+		}
+		if (\is_array($fn)) {
+			return \is_string($fn[0]) ? "callable({$fn[0]}::{$fn[1]})" : "callable(['" . \get_class($fn[0]) . "', '{$fn[1]}'])";
+		}
+		/** @var object $fn */
+		return 'callable(' . \spl_object_hash($fn) . ')';
+	}
 }

lib/Vendor/GuzzleHttp/TransferStats.php

Braces +1 added lines, -2 removed lines

@@ -10,8 +10,7 @@
  * Represents data at the point after it was transferred either successfully
  * or after a network error.
  */
-final class TransferStats
-{
+final class TransferStats {
     /**
      * @var RequestInterface
      */

Indentation +100 added lines, -100 removed lines

@@ -11,104 +11,104 @@
  */
 final class TransferStats
 {
-    /**
-     * @var RequestInterface
-     */
-    private $request;
-    /**
-     * @var ResponseInterface|null
-     */
-    private $response;
-    /**
-     * @var float|null
-     */
-    private $transferTime;
-    /**
-     * @var array
-     */
-    private $handlerStats;
-    /**
-     * @var mixed|null
-     */
-    private $handlerErrorData;
-    /**
-     * @param RequestInterface       $request          Request that was sent.
-     * @param ResponseInterface|null $response         Response received (if any)
-     * @param float|null             $transferTime     Total handler transfer time.
-     * @param mixed                  $handlerErrorData Handler error data.
-     * @param array                  $handlerStats     Handler specific stats.
-     */
-    public function __construct(RequestInterface $request, ?ResponseInterface $response = null, ?float $transferTime = null, $handlerErrorData = null, array $handlerStats = [])
-    {
-        $this->request = $request;
-        $this->response = $response;
-        $this->transferTime = $transferTime;
-        $this->handlerErrorData = $handlerErrorData;
-        $this->handlerStats = $handlerStats;
-    }
-    public function getRequest() : RequestInterface
-    {
-        return $this->request;
-    }
-    /**
-     * Returns the response that was received (if any).
-     */
-    public function getResponse() : ?ResponseInterface
-    {
-        return $this->response;
-    }
-    /**
-     * Returns true if a response was received.
-     */
-    public function hasResponse() : bool
-    {
-        return $this->response !== null;
-    }
-    /**
-     * Gets handler specific error data.
-     *
-     * This might be an exception, a integer representing an error code, or
-     * anything else. Relying on this value assumes that you know what handler
-     * you are using.
-     *
-     * @return mixed
-     */
-    public function getHandlerErrorData()
-    {
-        return $this->handlerErrorData;
-    }
-    /**
-     * Get the effective URI the request was sent to.
-     */
-    public function getEffectiveUri() : UriInterface
-    {
-        return $this->request->getUri();
-    }
-    /**
-     * Get the estimated time the request was being transferred by the handler.
-     *
-     * @return float|null Time in seconds.
-     */
-    public function getTransferTime() : ?float
-    {
-        return $this->transferTime;
-    }
-    /**
-     * Gets an array of all of the handler specific transfer data.
-     */
-    public function getHandlerStats() : array
-    {
-        return $this->handlerStats;
-    }
-    /**
-     * Get a specific handler statistic from the handler by name.
-     *
-     * @param string $stat Handler specific transfer stat to retrieve.
-     *
-     * @return mixed|null
-     */
-    public function getHandlerStat(string $stat)
-    {
-        return $this->handlerStats[$stat] ?? null;
-    }
+	/**
+	 * @var RequestInterface
+	 */
+	private $request;
+	/**
+	 * @var ResponseInterface|null
+	 */
+	private $response;
+	/**
+	 * @var float|null
+	 */
+	private $transferTime;
+	/**
+	 * @var array
+	 */
+	private $handlerStats;
+	/**
+	 * @var mixed|null
+	 */
+	private $handlerErrorData;
+	/**
+	 * @param RequestInterface       $request          Request that was sent.
+	 * @param ResponseInterface|null $response         Response received (if any)
+	 * @param float|null             $transferTime     Total handler transfer time.
+	 * @param mixed                  $handlerErrorData Handler error data.
+	 * @param array                  $handlerStats     Handler specific stats.
+	 */
+	public function __construct(RequestInterface $request, ?ResponseInterface $response = null, ?float $transferTime = null, $handlerErrorData = null, array $handlerStats = [])
+	{
+		$this->request = $request;
+		$this->response = $response;
+		$this->transferTime = $transferTime;
+		$this->handlerErrorData = $handlerErrorData;
+		$this->handlerStats = $handlerStats;
+	}
+	public function getRequest() : RequestInterface
+	{
+		return $this->request;
+	}
+	/**
+	 * Returns the response that was received (if any).
+	 */
+	public function getResponse() : ?ResponseInterface
+	{
+		return $this->response;
+	}
+	/**
+	 * Returns true if a response was received.
+	 */
+	public function hasResponse() : bool
+	{
+		return $this->response !== null;
+	}
+	/**
+	 * Gets handler specific error data.
+	 *
+	 * This might be an exception, a integer representing an error code, or
+	 * anything else. Relying on this value assumes that you know what handler
+	 * you are using.
+	 *
+	 * @return mixed
+	 */
+	public function getHandlerErrorData()
+	{
+		return $this->handlerErrorData;
+	}
+	/**
+	 * Get the effective URI the request was sent to.
+	 */
+	public function getEffectiveUri() : UriInterface
+	{
+		return $this->request->getUri();
+	}
+	/**
+	 * Get the estimated time the request was being transferred by the handler.
+	 *
+	 * @return float|null Time in seconds.
+	 */
+	public function getTransferTime() : ?float
+	{
+		return $this->transferTime;
+	}
+	/**
+	 * Gets an array of all of the handler specific transfer data.
+	 */
+	public function getHandlerStats() : array
+	{
+		return $this->handlerStats;
+	}
+	/**
+	 * Get a specific handler statistic from the handler by name.
+	 *
+	 * @param string $stat Handler specific transfer stat to retrieve.
+	 *
+	 * @return mixed|null
+	 */
+	public function getHandlerStat(string $stat)
+	{
+		return $this->handlerStats[$stat] ?? null;
+	}
 }

lib/Vendor/GuzzleHttp/functions_include.php

Indentation +1 added lines, -1 removed lines

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

Spacing +1 added lines, -1 removed lines

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

lib/Vendor/GuzzleHttp/RedirectMiddleware.php

Indentation +141 added lines, -141 removed lines

@@ -18,145 +18,145 @@
  */
 class RedirectMiddleware
 {
-    public const HISTORY_HEADER = 'X-Guzzle-Redirect-History';
-    public const STATUS_HISTORY_HEADER = 'X-Guzzle-Redirect-Status-History';
-    /**
-     * @var array
-     */
-    public static $defaultSettings = ['max' => 5, 'protocols' => ['http', 'https'], 'strict' => \false, 'referer' => \false, 'track_redirects' => \false];
-    /**
-     * @var callable(RequestInterface, array): PromiseInterface
-     */
-    private $nextHandler;
-    /**
-     * @param callable(RequestInterface, array): PromiseInterface $nextHandler Next handler to invoke.
-     */
-    public function __construct(callable $nextHandler)
-    {
-        $this->nextHandler = $nextHandler;
-    }
-    public function __invoke(RequestInterface $request, array $options) : PromiseInterface
-    {
-        $fn = $this->nextHandler;
-        if (empty($options['allow_redirects'])) {
-            return $fn($request, $options);
-        }
-        if ($options['allow_redirects'] === \true) {
-            $options['allow_redirects'] = self::$defaultSettings;
-        } elseif (!\is_array($options['allow_redirects'])) {
-            throw new \InvalidArgumentException('allow_redirects must be true, false, or array');
-        } else {
-            // Merge the default settings with the provided settings
-            $options['allow_redirects'] += self::$defaultSettings;
-        }
-        if (empty($options['allow_redirects']['max'])) {
-            return $fn($request, $options);
-        }
-        return $fn($request, $options)->then(function (ResponseInterface $response) use($request, $options) {
-            return $this->checkRedirect($request, $options, $response);
-        });
-    }
-    /**
-     * @return ResponseInterface|PromiseInterface
-     */
-    public function checkRedirect(RequestInterface $request, array $options, ResponseInterface $response)
-    {
-        if (\strpos((string) $response->getStatusCode(), '3') !== 0 || !$response->hasHeader('Location')) {
-            return $response;
-        }
-        $this->guardMax($request, $response, $options);
-        $nextRequest = $this->modifyRequest($request, $options, $response);
-        // If authorization is handled by curl, unset it if URI is cross-origin.
-        if (Psr7\UriComparator::isCrossOrigin($request->getUri(), $nextRequest->getUri()) && \defined('\\CURLOPT_HTTPAUTH')) {
-            unset($options['curl'][\CURLOPT_HTTPAUTH], $options['curl'][\CURLOPT_USERPWD]);
-        }
-        if (isset($options['allow_redirects']['on_redirect'])) {
-            $options['allow_redirects']['on_redirect']($request, $response, $nextRequest->getUri());
-        }
-        $promise = $this($nextRequest, $options);
-        // Add headers to be able to track history of redirects.
-        if (!empty($options['allow_redirects']['track_redirects'])) {
-            return $this->withTracking($promise, (string) $nextRequest->getUri(), $response->getStatusCode());
-        }
-        return $promise;
-    }
-    /**
-     * Enable tracking on promise.
-     */
-    private function withTracking(PromiseInterface $promise, string $uri, int $statusCode) : PromiseInterface
-    {
-        return $promise->then(static function (ResponseInterface $response) use($uri, $statusCode) {
-            // Note that we are pushing to the front of the list as this
-            // would be an earlier response than what is currently present
-            // in the history header.
-            $historyHeader = $response->getHeader(self::HISTORY_HEADER);
-            $statusHeader = $response->getHeader(self::STATUS_HISTORY_HEADER);
-            \array_unshift($historyHeader, $uri);
-            \array_unshift($statusHeader, (string) $statusCode);
-            return $response->withHeader(self::HISTORY_HEADER, $historyHeader)->withHeader(self::STATUS_HISTORY_HEADER, $statusHeader);
-        });
-    }
-    /**
-     * Check for too many redirects.
-     *
-     * @throws TooManyRedirectsException Too many redirects.
-     */
-    private function guardMax(RequestInterface $request, ResponseInterface $response, array &$options) : void
-    {
-        $current = $options['__redirect_count'] ?? 0;
-        $options['__redirect_count'] = $current + 1;
-        $max = $options['allow_redirects']['max'];
-        if ($options['__redirect_count'] > $max) {
-            throw new TooManyRedirectsException("Will not follow more than {$max} redirects", $request, $response);
-        }
-    }
-    public function modifyRequest(RequestInterface $request, array $options, ResponseInterface $response) : RequestInterface
-    {
-        // Request modifications to apply.
-        $modify = [];
-        $protocols = $options['allow_redirects']['protocols'];
-        // Use a GET request if this is an entity enclosing request and we are
-        // not forcing RFC compliance, but rather emulating what all browsers
-        // would do.
-        $statusCode = $response->getStatusCode();
-        if ($statusCode == 303 || $statusCode <= 302 && !$options['allow_redirects']['strict']) {
-            $safeMethods = ['GET', 'HEAD', 'OPTIONS'];
-            $requestMethod = $request->getMethod();
-            $modify['method'] = \in_array($requestMethod, $safeMethods) ? $requestMethod : 'GET';
-            $modify['body'] = '';
-        }
-        $uri = self::redirectUri($request, $response, $protocols);
-        if (isset($options['idn_conversion']) && $options['idn_conversion'] !== \false) {
-            $idnOptions = $options['idn_conversion'] === \true ? \IDNA_DEFAULT : $options['idn_conversion'];
-            $uri = Utils::idnUriConvert($uri, $idnOptions);
-        }
-        $modify['uri'] = $uri;
-        Psr7\Message::rewindBody($request);
-        // Add the Referer header if it is told to do so and only
-        // add the header if we are not redirecting from https to http.
-        if ($options['allow_redirects']['referer'] && $modify['uri']->getScheme() === $request->getUri()->getScheme()) {
-            $uri = $request->getUri()->withUserInfo('');
-            $modify['set_headers']['Referer'] = (string) $uri;
-        } else {
-            $modify['remove_headers'][] = 'Referer';
-        }
-        // Remove Authorization and Cookie headers if URI is cross-origin.
-        if (Psr7\UriComparator::isCrossOrigin($request->getUri(), $modify['uri'])) {
-            $modify['remove_headers'][] = 'Authorization';
-            $modify['remove_headers'][] = 'Cookie';
-        }
-        return Psr7\Utils::modifyRequest($request, $modify);
-    }
-    /**
-     * Set the appropriate URL on the request based on the location header.
-     */
-    private static function redirectUri(RequestInterface $request, ResponseInterface $response, array $protocols) : UriInterface
-    {
-        $location = Psr7\UriResolver::resolve($request->getUri(), new Psr7\Uri($response->getHeaderLine('Location')));
-        // Ensure that the redirect URI is allowed based on the protocols.
-        if (!\in_array($location->getScheme(), $protocols)) {
-            throw new BadResponseException(\sprintf('Redirect URI, %s, does not use one of the allowed redirect protocols: %s', $location, \implode(', ', $protocols)), $request, $response);
-        }
-        return $location;
-    }
+	public const HISTORY_HEADER = 'X-Guzzle-Redirect-History';
+	public const STATUS_HISTORY_HEADER = 'X-Guzzle-Redirect-Status-History';
+	/**
+	 * @var array
+	 */
+	public static $defaultSettings = ['max' => 5, 'protocols' => ['http', 'https'], 'strict' => \false, 'referer' => \false, 'track_redirects' => \false];
+	/**
+	 * @var callable(RequestInterface, array): PromiseInterface
+	 */
+	private $nextHandler;
+	/**
+	 * @param callable(RequestInterface, array): PromiseInterface $nextHandler Next handler to invoke.
+	 */
+	public function __construct(callable $nextHandler)
+	{
+		$this->nextHandler = $nextHandler;
+	}
+	public function __invoke(RequestInterface $request, array $options) : PromiseInterface
+	{
+		$fn = $this->nextHandler;
+		if (empty($options['allow_redirects'])) {
+			return $fn($request, $options);
+		}
+		if ($options['allow_redirects'] === \true) {
+			$options['allow_redirects'] = self::$defaultSettings;
+		} elseif (!\is_array($options['allow_redirects'])) {
+			throw new \InvalidArgumentException('allow_redirects must be true, false, or array');
+		} else {
+			// Merge the default settings with the provided settings
+			$options['allow_redirects'] += self::$defaultSettings;
+		}
+		if (empty($options['allow_redirects']['max'])) {
+			return $fn($request, $options);
+		}
+		return $fn($request, $options)->then(function (ResponseInterface $response) use($request, $options) {
+			return $this->checkRedirect($request, $options, $response);
+		});
+	}
+	/**
+	 * @return ResponseInterface|PromiseInterface
+	 */
+	public function checkRedirect(RequestInterface $request, array $options, ResponseInterface $response)
+	{
+		if (\strpos((string) $response->getStatusCode(), '3') !== 0 || !$response->hasHeader('Location')) {
+			return $response;
+		}
+		$this->guardMax($request, $response, $options);
+		$nextRequest = $this->modifyRequest($request, $options, $response);
+		// If authorization is handled by curl, unset it if URI is cross-origin.
+		if (Psr7\UriComparator::isCrossOrigin($request->getUri(), $nextRequest->getUri()) && \defined('\\CURLOPT_HTTPAUTH')) {
+			unset($options['curl'][\CURLOPT_HTTPAUTH], $options['curl'][\CURLOPT_USERPWD]);
+		}
+		if (isset($options['allow_redirects']['on_redirect'])) {
+			$options['allow_redirects']['on_redirect']($request, $response, $nextRequest->getUri());
+		}
+		$promise = $this($nextRequest, $options);
+		// Add headers to be able to track history of redirects.
+		if (!empty($options['allow_redirects']['track_redirects'])) {
+			return $this->withTracking($promise, (string) $nextRequest->getUri(), $response->getStatusCode());
+		}
+		return $promise;
+	}
+	/**
+	 * Enable tracking on promise.
+	 */
+	private function withTracking(PromiseInterface $promise, string $uri, int $statusCode) : PromiseInterface
+	{
+		return $promise->then(static function (ResponseInterface $response) use($uri, $statusCode) {
+			// Note that we are pushing to the front of the list as this
+			// would be an earlier response than what is currently present
+			// in the history header.
+			$historyHeader = $response->getHeader(self::HISTORY_HEADER);
+			$statusHeader = $response->getHeader(self::STATUS_HISTORY_HEADER);
+			\array_unshift($historyHeader, $uri);
+			\array_unshift($statusHeader, (string) $statusCode);
+			return $response->withHeader(self::HISTORY_HEADER, $historyHeader)->withHeader(self::STATUS_HISTORY_HEADER, $statusHeader);
+		});
+	}
+	/**
+	 * Check for too many redirects.
+	 *
+	 * @throws TooManyRedirectsException Too many redirects.
+	 */
+	private function guardMax(RequestInterface $request, ResponseInterface $response, array &$options) : void
+	{
+		$current = $options['__redirect_count'] ?? 0;
+		$options['__redirect_count'] = $current + 1;
+		$max = $options['allow_redirects']['max'];
+		if ($options['__redirect_count'] > $max) {
+			throw new TooManyRedirectsException("Will not follow more than {$max} redirects", $request, $response);
+		}
+	}
+	public function modifyRequest(RequestInterface $request, array $options, ResponseInterface $response) : RequestInterface
+	{
+		// Request modifications to apply.
+		$modify = [];
+		$protocols = $options['allow_redirects']['protocols'];
+		// Use a GET request if this is an entity enclosing request and we are
+		// not forcing RFC compliance, but rather emulating what all browsers
+		// would do.
+		$statusCode = $response->getStatusCode();
+		if ($statusCode == 303 || $statusCode <= 302 && !$options['allow_redirects']['strict']) {
+			$safeMethods = ['GET', 'HEAD', 'OPTIONS'];
+			$requestMethod = $request->getMethod();
+			$modify['method'] = \in_array($requestMethod, $safeMethods) ? $requestMethod : 'GET';
+			$modify['body'] = '';
+		}
+		$uri = self::redirectUri($request, $response, $protocols);
+		if (isset($options['idn_conversion']) && $options['idn_conversion'] !== \false) {
+			$idnOptions = $options['idn_conversion'] === \true ? \IDNA_DEFAULT : $options['idn_conversion'];
+			$uri = Utils::idnUriConvert($uri, $idnOptions);
+		}
+		$modify['uri'] = $uri;
+		Psr7\Message::rewindBody($request);
+		// Add the Referer header if it is told to do so and only
+		// add the header if we are not redirecting from https to http.
+		if ($options['allow_redirects']['referer'] && $modify['uri']->getScheme() === $request->getUri()->getScheme()) {
+			$uri = $request->getUri()->withUserInfo('');
+			$modify['set_headers']['Referer'] = (string) $uri;
+		} else {
+			$modify['remove_headers'][] = 'Referer';
+		}
+		// Remove Authorization and Cookie headers if URI is cross-origin.
+		if (Psr7\UriComparator::isCrossOrigin($request->getUri(), $modify['uri'])) {
+			$modify['remove_headers'][] = 'Authorization';
+			$modify['remove_headers'][] = 'Cookie';
+		}
+		return Psr7\Utils::modifyRequest($request, $modify);
+	}
+	/**
+	 * Set the appropriate URL on the request based on the location header.
+	 */
+	private static function redirectUri(RequestInterface $request, ResponseInterface $response, array $protocols) : UriInterface
+	{
+		$location = Psr7\UriResolver::resolve($request->getUri(), new Psr7\Uri($response->getHeaderLine('Location')));
+		// Ensure that the redirect URI is allowed based on the protocols.
+		if (!\in_array($location->getScheme(), $protocols)) {
+			throw new BadResponseException(\sprintf('Redirect URI, %s, does not use one of the allowed redirect protocols: %s', $location, \implode(', ', $protocols)), $request, $response);
+		}
+		return $location;
+	}
 }

Spacing +6 added lines, -6 removed lines

@@ -52,7 +52,7 @@ 
         if (empty($options['allow_redirects']['max'])) {
             return $fn($request, $options);
         }
-        return $fn($request, $options)->then(function (ResponseInterface $response) use($request, $options) {
+        return $fn($request, $options)->then(function(ResponseInterface $response) use($request, $options) {
             return $this->checkRedirect($request, $options, $response);
         });
     }
@@ -61,7 +61,7 @@ 
      */
     public function checkRedirect(RequestInterface $request, array $options, ResponseInterface $response)
     {
-        if (\strpos((string) $response->getStatusCode(), '3') !== 0 || !$response->hasHeader('Location')) {
+        if (\strpos((string)$response->getStatusCode(), '3') !== 0 || !$response->hasHeader('Location')) {
             return $response;
         }
         $this->guardMax($request, $response, $options);
@@ -76,7 +76,7 @@ 
         $promise = $this($nextRequest, $options);
         // Add headers to be able to track history of redirects.
         if (!empty($options['allow_redirects']['track_redirects'])) {
-            return $this->withTracking($promise, (string) $nextRequest->getUri(), $response->getStatusCode());
+            return $this->withTracking($promise, (string)$nextRequest->getUri(), $response->getStatusCode());
         }
         return $promise;
     }
@@ -85,14 +85,14 @@ 
      */
     private function withTracking(PromiseInterface $promise, string $uri, int $statusCode) : PromiseInterface
     {
-        return $promise->then(static function (ResponseInterface $response) use($uri, $statusCode) {
+        return $promise->then(static function(ResponseInterface $response) use($uri, $statusCode) {
             // Note that we are pushing to the front of the list as this
             // would be an earlier response than what is currently present
             // in the history header.
             $historyHeader = $response->getHeader(self::HISTORY_HEADER);
             $statusHeader = $response->getHeader(self::STATUS_HISTORY_HEADER);
             \array_unshift($historyHeader, $uri);
-            \array_unshift($statusHeader, (string) $statusCode);
+            \array_unshift($statusHeader, (string)$statusCode);
             return $response->withHeader(self::HISTORY_HEADER, $historyHeader)->withHeader(self::STATUS_HISTORY_HEADER, $statusHeader);
         });
     }
@@ -136,7 +136,7 @@ 
         // add the header if we are not redirecting from https to http.
         if ($options['allow_redirects']['referer'] && $modify['uri']->getScheme() === $request->getUri()->getScheme()) {
             $uri = $request->getUri()->withUserInfo('');
-            $modify['set_headers']['Referer'] = (string) $uri;
+            $modify['set_headers']['Referer'] = (string)$uri;
         } else {
             $modify['remove_headers'][] = 'Referer';
         }

Braces +1 added lines, -2 removed lines

@@ -16,8 +16,7 @@
  *
  * @final
  */
-class RedirectMiddleware
-{
+class RedirectMiddleware {
     public const HISTORY_HEADER = 'X-Guzzle-Redirect-History';
     public const STATUS_HISTORY_HEADER = 'X-Guzzle-Redirect-Status-History';
     /**