nextcloud / fulltextsearch_elasticsearch

lib/Vendor/GuzzleHttp/Promise/Is.php

Indentation +28 added lines, -28 removed lines

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

Braces +1 added lines, -2 removed lines

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

lib/Vendor/GuzzleHttp/Middleware.php

Indentation +231 added lines, -231 removed lines

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

Spacing +23 added lines, -23 removed lines

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

Braces +1 added lines, -2 removed lines

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

lib/Vendor/GuzzleHttp/functions_include.php

Indentation +1 added lines, -1 removed lines

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

lib/Vendor/GuzzleHttp/HandlerStack.php

Indentation +258 added lines, -258 removed lines

@@ -14,262 +14,262 @@
  */
 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).')';
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -188,7 +188,7 @@
         $idx = \is_callable($remove) ? 0 : 1;
         $this->stack = \array_values(\array_filter(
             $this->stack,
-            static function ($tuple) use ($idx, $remove) {
+            static function($tuple) use ($idx, $remove) {
                 return $tuple[$idx] !== $remove;
             }
         ));

Braces +1 added lines, -2 removed lines

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

lib/Vendor/GuzzleHttp/TransferStats.php

Indentation +118 added lines, -118 removed lines

@@ -12,122 +12,122 @@
  */
 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;
+	}
 }

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