nextcloud / fulltextsearch_elasticsearch

lib/Vendor/GuzzleHttp/Cookie/CookieJar.php

Indentation +294 added lines, -294 removed lines

@@ -10,298 +10,298 @@
  */
 class CookieJar implements CookieJarInterface
 {
-    /**
-     * @var SetCookie[] Loaded cookie data
-     */
-    private $cookies = [];
-
-    /**
-     * @var bool
-     */
-    private $strictMode;
-
-    /**
-     * @param bool  $strictMode  Set to true to throw exceptions when invalid
-     *                           cookies are added to the cookie jar.
-     * @param array $cookieArray Array of SetCookie objects or a hash of
-     *                           arrays that can be used with the SetCookie
-     *                           constructor
-     */
-    public function __construct(bool $strictMode = false, array $cookieArray = [])
-    {
-        $this->strictMode = $strictMode;
-
-        foreach ($cookieArray as $cookie) {
-            if (!($cookie instanceof SetCookie)) {
-                $cookie = new SetCookie($cookie);
-            }
-            $this->setCookie($cookie);
-        }
-    }
-
-    /**
-     * Create a new Cookie jar from an associative array and domain.
-     *
-     * @param array  $cookies Cookies to create the jar from
-     * @param string $domain  Domain to set the cookies to
-     */
-    public static function fromArray(array $cookies, string $domain): self
-    {
-        $cookieJar = new self();
-        foreach ($cookies as $name => $value) {
-            $cookieJar->setCookie(new SetCookie([
-                'Domain' => $domain,
-                'Name' => $name,
-                'Value' => $value,
-                'Discard' => true,
-            ]));
-        }
-
-        return $cookieJar;
-    }
-
-    /**
-     * Evaluate if this cookie should be persisted to storage
-     * that survives between requests.
-     *
-     * @param SetCookie $cookie              Being evaluated.
-     * @param bool      $allowSessionCookies If we should persist session cookies
-     */
-    public static function shouldPersist(SetCookie $cookie, bool $allowSessionCookies = false): bool
-    {
-        if ($cookie->getExpires() || $allowSessionCookies) {
-            if (!$cookie->getDiscard()) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Finds and returns the cookie based on the name
-     *
-     * @param string $name cookie name to search for
-     *
-     * @return SetCookie|null cookie that was found or null if not found
-     */
-    public function getCookieByName(string $name): ?SetCookie
-    {
-        foreach ($this->cookies as $cookie) {
-            if ($cookie->getName() !== null && \strcasecmp($cookie->getName(), $name) === 0) {
-                return $cookie;
-            }
-        }
-
-        return null;
-    }
-
-    public function toArray(): array
-    {
-        return \array_map(static function (SetCookie $cookie): array {
-            return $cookie->toArray();
-        }, $this->getIterator()->getArrayCopy());
-    }
-
-    public function clear(string $domain = null, string $path = null, string $name = null): void
-    {
-        if (!$domain) {
-            $this->cookies = [];
-
-            return;
-        } elseif (!$path) {
-            $this->cookies = \array_filter(
-                $this->cookies,
-                static function (SetCookie $cookie) use ($domain): bool {
-                    return !$cookie->matchesDomain($domain);
-                }
-            );
-        } elseif (!$name) {
-            $this->cookies = \array_filter(
-                $this->cookies,
-                static function (SetCookie $cookie) use ($path, $domain): bool {
-                    return !($cookie->matchesPath($path)
-                        && $cookie->matchesDomain($domain));
-                }
-            );
-        } else {
-            $this->cookies = \array_filter(
-                $this->cookies,
-                static function (SetCookie $cookie) use ($path, $domain, $name) {
-                    return !($cookie->getName() == $name
-                        && $cookie->matchesPath($path)
-                        && $cookie->matchesDomain($domain));
-                }
-            );
-        }
-    }
-
-    public function clearSessionCookies(): void
-    {
-        $this->cookies = \array_filter(
-            $this->cookies,
-            static function (SetCookie $cookie): bool {
-                return !$cookie->getDiscard() && $cookie->getExpires();
-            }
-        );
-    }
-
-    public function setCookie(SetCookie $cookie): bool
-    {
-        // If the name string is empty (but not 0), ignore the set-cookie
-        // string entirely.
-        $name = $cookie->getName();
-        if (!$name && $name !== '0') {
-            return false;
-        }
-
-        // Only allow cookies with set and valid domain, name, value
-        $result = $cookie->validate();
-        if ($result !== true) {
-            if ($this->strictMode) {
-                throw new \RuntimeException('Invalid cookie: '.$result);
-            }
-            $this->removeCookieIfEmpty($cookie);
-
-            return false;
-        }
-
-        // Resolve conflicts with previously set cookies
-        foreach ($this->cookies as $i => $c) {
-            // Two cookies are identical, when their path, and domain are
-            // identical.
-            if ($c->getPath() != $cookie->getPath()
-                || $c->getDomain() != $cookie->getDomain()
-                || $c->getName() != $cookie->getName()
-            ) {
-                continue;
-            }
-
-            // The previously set cookie is a discard cookie and this one is
-            // not so allow the new cookie to be set
-            if (!$cookie->getDiscard() && $c->getDiscard()) {
-                unset($this->cookies[$i]);
-                continue;
-            }
-
-            // If the new cookie's expiration is further into the future, then
-            // replace the old cookie
-            if ($cookie->getExpires() > $c->getExpires()) {
-                unset($this->cookies[$i]);
-                continue;
-            }
-
-            // If the value has changed, we better change it
-            if ($cookie->getValue() !== $c->getValue()) {
-                unset($this->cookies[$i]);
-                continue;
-            }
-
-            // The cookie exists, so no need to continue
-            return false;
-        }
-
-        $this->cookies[] = $cookie;
-
-        return true;
-    }
-
-    public function count(): int
-    {
-        return \count($this->cookies);
-    }
-
-    /**
-     * @return \ArrayIterator<int, SetCookie>
-     */
-    public function getIterator(): \ArrayIterator
-    {
-        return new \ArrayIterator(\array_values($this->cookies));
-    }
-
-    public function extractCookies(RequestInterface $request, ResponseInterface $response): void
-    {
-        if ($cookieHeader = $response->getHeader('Set-Cookie')) {
-            foreach ($cookieHeader as $cookie) {
-                $sc = SetCookie::fromString($cookie);
-                if (!$sc->getDomain()) {
-                    $sc->setDomain($request->getUri()->getHost());
-                }
-                if (0 !== \strpos($sc->getPath(), '/')) {
-                    $sc->setPath($this->getCookiePathFromRequest($request));
-                }
-                if (!$sc->matchesDomain($request->getUri()->getHost())) {
-                    continue;
-                }
-                // Note: At this point `$sc->getDomain()` being a public suffix should
-                // be rejected, but we don't want to pull in the full PSL dependency.
-                $this->setCookie($sc);
-            }
-        }
-    }
-
-    /**
-     * Computes cookie path following RFC 6265 section 5.1.4
-     *
-     * @see https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.4
-     */
-    private function getCookiePathFromRequest(RequestInterface $request): string
-    {
-        $uriPath = $request->getUri()->getPath();
-        if ('' === $uriPath) {
-            return '/';
-        }
-        if (0 !== \strpos($uriPath, '/')) {
-            return '/';
-        }
-        if ('/' === $uriPath) {
-            return '/';
-        }
-        $lastSlashPos = \strrpos($uriPath, '/');
-        if (0 === $lastSlashPos || false === $lastSlashPos) {
-            return '/';
-        }
-
-        return \substr($uriPath, 0, $lastSlashPos);
-    }
-
-    public function withCookieHeader(RequestInterface $request): RequestInterface
-    {
-        $values = [];
-        $uri = $request->getUri();
-        $scheme = $uri->getScheme();
-        $host = $uri->getHost();
-        $path = $uri->getPath() ?: '/';
-
-        foreach ($this->cookies as $cookie) {
-            if ($cookie->matchesPath($path)
-                && $cookie->matchesDomain($host)
-                && !$cookie->isExpired()
-                && (!$cookie->getSecure() || $scheme === 'https')
-            ) {
-                $values[] = $cookie->getName().'='
-                    .$cookie->getValue();
-            }
-        }
-
-        return $values
-            ? $request->withHeader('Cookie', \implode('; ', $values))
-            : $request;
-    }
-
-    /**
-     * If a cookie already exists and the server asks to set it again with a
-     * null value, the cookie must be deleted.
-     */
-    private function removeCookieIfEmpty(SetCookie $cookie): void
-    {
-        $cookieValue = $cookie->getValue();
-        if ($cookieValue === null || $cookieValue === '') {
-            $this->clear(
-                $cookie->getDomain(),
-                $cookie->getPath(),
-                $cookie->getName()
-            );
-        }
-    }
+	/**
+	 * @var SetCookie[] Loaded cookie data
+	 */
+	private $cookies = [];
+
+	/**
+	 * @var bool
+	 */
+	private $strictMode;
+
+	/**
+	 * @param bool  $strictMode  Set to true to throw exceptions when invalid
+	 *                           cookies are added to the cookie jar.
+	 * @param array $cookieArray Array of SetCookie objects or a hash of
+	 *                           arrays that can be used with the SetCookie
+	 *                           constructor
+	 */
+	public function __construct(bool $strictMode = false, array $cookieArray = [])
+	{
+		$this->strictMode = $strictMode;
+
+		foreach ($cookieArray as $cookie) {
+			if (!($cookie instanceof SetCookie)) {
+				$cookie = new SetCookie($cookie);
+			}
+			$this->setCookie($cookie);
+		}
+	}
+
+	/**
+	 * Create a new Cookie jar from an associative array and domain.
+	 *
+	 * @param array  $cookies Cookies to create the jar from
+	 * @param string $domain  Domain to set the cookies to
+	 */
+	public static function fromArray(array $cookies, string $domain): self
+	{
+		$cookieJar = new self();
+		foreach ($cookies as $name => $value) {
+			$cookieJar->setCookie(new SetCookie([
+				'Domain' => $domain,
+				'Name' => $name,
+				'Value' => $value,
+				'Discard' => true,
+			]));
+		}
+
+		return $cookieJar;
+	}
+
+	/**
+	 * Evaluate if this cookie should be persisted to storage
+	 * that survives between requests.
+	 *
+	 * @param SetCookie $cookie              Being evaluated.
+	 * @param bool      $allowSessionCookies If we should persist session cookies
+	 */
+	public static function shouldPersist(SetCookie $cookie, bool $allowSessionCookies = false): bool
+	{
+		if ($cookie->getExpires() || $allowSessionCookies) {
+			if (!$cookie->getDiscard()) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Finds and returns the cookie based on the name
+	 *
+	 * @param string $name cookie name to search for
+	 *
+	 * @return SetCookie|null cookie that was found or null if not found
+	 */
+	public function getCookieByName(string $name): ?SetCookie
+	{
+		foreach ($this->cookies as $cookie) {
+			if ($cookie->getName() !== null && \strcasecmp($cookie->getName(), $name) === 0) {
+				return $cookie;
+			}
+		}
+
+		return null;
+	}
+
+	public function toArray(): array
+	{
+		return \array_map(static function (SetCookie $cookie): array {
+			return $cookie->toArray();
+		}, $this->getIterator()->getArrayCopy());
+	}
+
+	public function clear(string $domain = null, string $path = null, string $name = null): void
+	{
+		if (!$domain) {
+			$this->cookies = [];
+
+			return;
+		} elseif (!$path) {
+			$this->cookies = \array_filter(
+				$this->cookies,
+				static function (SetCookie $cookie) use ($domain): bool {
+					return !$cookie->matchesDomain($domain);
+				}
+			);
+		} elseif (!$name) {
+			$this->cookies = \array_filter(
+				$this->cookies,
+				static function (SetCookie $cookie) use ($path, $domain): bool {
+					return !($cookie->matchesPath($path)
+						&& $cookie->matchesDomain($domain));
+				}
+			);
+		} else {
+			$this->cookies = \array_filter(
+				$this->cookies,
+				static function (SetCookie $cookie) use ($path, $domain, $name) {
+					return !($cookie->getName() == $name
+						&& $cookie->matchesPath($path)
+						&& $cookie->matchesDomain($domain));
+				}
+			);
+		}
+	}
+
+	public function clearSessionCookies(): void
+	{
+		$this->cookies = \array_filter(
+			$this->cookies,
+			static function (SetCookie $cookie): bool {
+				return !$cookie->getDiscard() && $cookie->getExpires();
+			}
+		);
+	}
+
+	public function setCookie(SetCookie $cookie): bool
+	{
+		// If the name string is empty (but not 0), ignore the set-cookie
+		// string entirely.
+		$name = $cookie->getName();
+		if (!$name && $name !== '0') {
+			return false;
+		}
+
+		// Only allow cookies with set and valid domain, name, value
+		$result = $cookie->validate();
+		if ($result !== true) {
+			if ($this->strictMode) {
+				throw new \RuntimeException('Invalid cookie: '.$result);
+			}
+			$this->removeCookieIfEmpty($cookie);
+
+			return false;
+		}
+
+		// Resolve conflicts with previously set cookies
+		foreach ($this->cookies as $i => $c) {
+			// Two cookies are identical, when their path, and domain are
+			// identical.
+			if ($c->getPath() != $cookie->getPath()
+				|| $c->getDomain() != $cookie->getDomain()
+				|| $c->getName() != $cookie->getName()
+			) {
+				continue;
+			}
+
+			// The previously set cookie is a discard cookie and this one is
+			// not so allow the new cookie to be set
+			if (!$cookie->getDiscard() && $c->getDiscard()) {
+				unset($this->cookies[$i]);
+				continue;
+			}
+
+			// If the new cookie's expiration is further into the future, then
+			// replace the old cookie
+			if ($cookie->getExpires() > $c->getExpires()) {
+				unset($this->cookies[$i]);
+				continue;
+			}
+
+			// If the value has changed, we better change it
+			if ($cookie->getValue() !== $c->getValue()) {
+				unset($this->cookies[$i]);
+				continue;
+			}
+
+			// The cookie exists, so no need to continue
+			return false;
+		}
+
+		$this->cookies[] = $cookie;
+
+		return true;
+	}
+
+	public function count(): int
+	{
+		return \count($this->cookies);
+	}
+
+	/**
+	 * @return \ArrayIterator<int, SetCookie>
+	 */
+	public function getIterator(): \ArrayIterator
+	{
+		return new \ArrayIterator(\array_values($this->cookies));
+	}
+
+	public function extractCookies(RequestInterface $request, ResponseInterface $response): void
+	{
+		if ($cookieHeader = $response->getHeader('Set-Cookie')) {
+			foreach ($cookieHeader as $cookie) {
+				$sc = SetCookie::fromString($cookie);
+				if (!$sc->getDomain()) {
+					$sc->setDomain($request->getUri()->getHost());
+				}
+				if (0 !== \strpos($sc->getPath(), '/')) {
+					$sc->setPath($this->getCookiePathFromRequest($request));
+				}
+				if (!$sc->matchesDomain($request->getUri()->getHost())) {
+					continue;
+				}
+				// Note: At this point `$sc->getDomain()` being a public suffix should
+				// be rejected, but we don't want to pull in the full PSL dependency.
+				$this->setCookie($sc);
+			}
+		}
+	}
+
+	/**
+	 * Computes cookie path following RFC 6265 section 5.1.4
+	 *
+	 * @see https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.4
+	 */
+	private function getCookiePathFromRequest(RequestInterface $request): string
+	{
+		$uriPath = $request->getUri()->getPath();
+		if ('' === $uriPath) {
+			return '/';
+		}
+		if (0 !== \strpos($uriPath, '/')) {
+			return '/';
+		}
+		if ('/' === $uriPath) {
+			return '/';
+		}
+		$lastSlashPos = \strrpos($uriPath, '/');
+		if (0 === $lastSlashPos || false === $lastSlashPos) {
+			return '/';
+		}
+
+		return \substr($uriPath, 0, $lastSlashPos);
+	}
+
+	public function withCookieHeader(RequestInterface $request): RequestInterface
+	{
+		$values = [];
+		$uri = $request->getUri();
+		$scheme = $uri->getScheme();
+		$host = $uri->getHost();
+		$path = $uri->getPath() ?: '/';
+
+		foreach ($this->cookies as $cookie) {
+			if ($cookie->matchesPath($path)
+				&& $cookie->matchesDomain($host)
+				&& !$cookie->isExpired()
+				&& (!$cookie->getSecure() || $scheme === 'https')
+			) {
+				$values[] = $cookie->getName().'='
+					.$cookie->getValue();
+			}
+		}
+
+		return $values
+			? $request->withHeader('Cookie', \implode('; ', $values))
+			: $request;
+	}
+
+	/**
+	 * If a cookie already exists and the server asks to set it again with a
+	 * null value, the cookie must be deleted.
+	 */
+	private function removeCookieIfEmpty(SetCookie $cookie): void
+	{
+		$cookieValue = $cookie->getValue();
+		if ($cookieValue === null || $cookieValue === '') {
+			$this->clear(
+				$cookie->getDomain(),
+				$cookie->getPath(),
+				$cookie->getName()
+			);
+		}
+	}
 }

Spacing +5 added lines, -5 removed lines

@@ -98,7 +98,7 @@ 
 
     public function toArray(): array
     {
-        return \array_map(static function (SetCookie $cookie): array {
+        return \array_map(static function(SetCookie $cookie): array {
             return $cookie->toArray();
         }, $this->getIterator()->getArrayCopy());
     }
@@ -112,14 +112,14 @@ 
         } elseif (!$path) {
             $this->cookies = \array_filter(
                 $this->cookies,
-                static function (SetCookie $cookie) use ($domain): bool {
+                static function(SetCookie $cookie) use ($domain): bool {
                     return !$cookie->matchesDomain($domain);
                 }
             );
         } elseif (!$name) {
             $this->cookies = \array_filter(
                 $this->cookies,
-                static function (SetCookie $cookie) use ($path, $domain): bool {
+                static function(SetCookie $cookie) use ($path, $domain): bool {
                     return !($cookie->matchesPath($path)
                         && $cookie->matchesDomain($domain));
                 }
@@ -127,7 +127,7 @@ 
         } else {
             $this->cookies = \array_filter(
                 $this->cookies,
-                static function (SetCookie $cookie) use ($path, $domain, $name) {
+                static function(SetCookie $cookie) use ($path, $domain, $name) {
                     return !($cookie->getName() == $name
                         && $cookie->matchesPath($path)
                         && $cookie->matchesDomain($domain));
@@ -140,7 +140,7 @@ 
     {
         $this->cookies = \array_filter(
             $this->cookies,
-            static function (SetCookie $cookie): bool {
+            static function(SetCookie $cookie): bool {
                 return !$cookie->getDiscard() && $cookie->getExpires();
             }
         );

Braces +1 added lines, -2 removed lines

@@ -8,8 +8,7 @@
 /**
  * Cookie jar that stores cookies as an array
  */
-class CookieJar implements CookieJarInterface
-{
+class CookieJar implements CookieJarInterface {
     /**
      * @var SetCookie[] Loaded cookie data
      */

lib/Vendor/GuzzleHttp/Exception/TooManyRedirectsException.php

Braces +1 added lines, -2 removed lines

@@ -2,6 +2,5 @@
 
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Exception;
 
-class TooManyRedirectsException extends RequestException
-{
+class TooManyRedirectsException extends RequestException {
 }

lib/Vendor/GuzzleHttp/Exception/ClientException.php

Braces +1 added lines, -2 removed lines

@@ -5,6 +5,5 @@
 /**
  * Exception when a client error is encountered (4xx codes)
  */
-class ClientException extends BadResponseException
-{
+class ClientException extends BadResponseException {
 }

lib/Vendor/GuzzleHttp/Exception/ServerException.php

Braces +1 added lines, -2 removed lines

@@ -5,6 +5,5 @@
 /**
  * Exception when a server error is encountered (5xx codes)
  */
-class ServerException extends BadResponseException
-{
+class ServerException extends BadResponseException {
 }

lib/Vendor/GuzzleHttp/Exception/GuzzleException.php

Braces +1 added lines, -2 removed lines

@@ -4,6 +4,5 @@
 
 use OCA\FullTextSearch_Elasticsearch\Vendor\Psr\Http\Client\ClientExceptionInterface;
 
-interface GuzzleException extends ClientExceptionInterface
-{
+interface GuzzleException extends ClientExceptionInterface {
 }

lib/Vendor/GuzzleHttp/Exception/RequestException.php

Indentation +149 added lines, -149 removed lines

@@ -14,153 +14,153 @@
  */
 class RequestException extends TransferException implements RequestExceptionInterface
 {
-    /**
-     * @var RequestInterface
-     */
-    private $request;
-
-    /**
-     * @var ResponseInterface|null
-     */
-    private $response;
-
-    /**
-     * @var array
-     */
-    private $handlerContext;
-
-    public function __construct(
-        string $message,
-        RequestInterface $request,
-        ResponseInterface $response = null,
-        \Throwable $previous = null,
-        array $handlerContext = []
-    ) {
-        // Set the code of the exception if the response is set and not future.
-        $code = $response ? $response->getStatusCode() : 0;
-        parent::__construct($message, $code, $previous);
-        $this->request = $request;
-        $this->response = $response;
-        $this->handlerContext = $handlerContext;
-    }
-
-    /**
-     * Wrap non-RequestExceptions with a RequestException
-     */
-    public static function wrapException(RequestInterface $request, \Throwable $e): RequestException
-    {
-        return $e instanceof RequestException ? $e : new RequestException($e->getMessage(), $request, null, $e);
-    }
-
-    /**
-     * Factory method to create a new exception with a normalized error message
-     *
-     * @param RequestInterface             $request        Request sent
-     * @param ResponseInterface            $response       Response received
-     * @param \Throwable|null              $previous       Previous exception
-     * @param array                        $handlerContext Optional handler context
-     * @param BodySummarizerInterface|null $bodySummarizer Optional body summarizer
-     */
-    public static function create(
-        RequestInterface $request,
-        ResponseInterface $response = null,
-        \Throwable $previous = null,
-        array $handlerContext = [],
-        BodySummarizerInterface $bodySummarizer = null
-    ): self {
-        if (!$response) {
-            return new self(
-                'Error completing request',
-                $request,
-                null,
-                $previous,
-                $handlerContext
-            );
-        }
-
-        $level = (int) \floor($response->getStatusCode() / 100);
-        if ($level === 4) {
-            $label = 'Client error';
-            $className = ClientException::class;
-        } elseif ($level === 5) {
-            $label = 'Server error';
-            $className = ServerException::class;
-        } else {
-            $label = 'Unsuccessful request';
-            $className = __CLASS__;
-        }
-
-        $uri = $request->getUri();
-        $uri = static::obfuscateUri($uri);
-
-        // Client Error: `GET /` resulted in a `404 Not Found` response:
-        // <html> ... (truncated)
-        $message = \sprintf(
-            '%s: `%s %s` resulted in a `%s %s` response',
-            $label,
-            $request->getMethod(),
-            $uri->__toString(),
-            $response->getStatusCode(),
-            $response->getReasonPhrase()
-        );
-
-        $summary = ($bodySummarizer ?? new BodySummarizer())->summarize($response);
-
-        if ($summary !== null) {
-            $message .= ":\n{$summary}\n";
-        }
-
-        return new $className($message, $request, $response, $previous, $handlerContext);
-    }
-
-    /**
-     * Obfuscates URI if there is a username and a password present
-     */
-    private static function obfuscateUri(UriInterface $uri): UriInterface
-    {
-        $userInfo = $uri->getUserInfo();
-
-        if (false !== ($pos = \strpos($userInfo, ':'))) {
-            return $uri->withUserInfo(\substr($userInfo, 0, $pos), '***');
-        }
-
-        return $uri;
-    }
-
-    /**
-     * Get the request that caused the exception
-     */
-    public function getRequest(): RequestInterface
-    {
-        return $this->request;
-    }
-
-    /**
-     * Get the associated response
-     */
-    public function getResponse(): ?ResponseInterface
-    {
-        return $this->response;
-    }
-
-    /**
-     * Check if a response was received
-     */
-    public function hasResponse(): bool
-    {
-        return $this->response !== null;
-    }
-
-    /**
-     * Get contextual information about the error from the underlying handler.
-     *
-     * The contents of this array will vary depending on which handler you are
-     * using. It may also be just an empty array. Relying on this data will
-     * couple you to a specific handler, but can give more debug information
-     * when needed.
-     */
-    public function getHandlerContext(): array
-    {
-        return $this->handlerContext;
-    }
+	/**
+	 * @var RequestInterface
+	 */
+	private $request;
+
+	/**
+	 * @var ResponseInterface|null
+	 */
+	private $response;
+
+	/**
+	 * @var array
+	 */
+	private $handlerContext;
+
+	public function __construct(
+		string $message,
+		RequestInterface $request,
+		ResponseInterface $response = null,
+		\Throwable $previous = null,
+		array $handlerContext = []
+	) {
+		// Set the code of the exception if the response is set and not future.
+		$code = $response ? $response->getStatusCode() : 0;
+		parent::__construct($message, $code, $previous);
+		$this->request = $request;
+		$this->response = $response;
+		$this->handlerContext = $handlerContext;
+	}
+
+	/**
+	 * Wrap non-RequestExceptions with a RequestException
+	 */
+	public static function wrapException(RequestInterface $request, \Throwable $e): RequestException
+	{
+		return $e instanceof RequestException ? $e : new RequestException($e->getMessage(), $request, null, $e);
+	}
+
+	/**
+	 * Factory method to create a new exception with a normalized error message
+	 *
+	 * @param RequestInterface             $request        Request sent
+	 * @param ResponseInterface            $response       Response received
+	 * @param \Throwable|null              $previous       Previous exception
+	 * @param array                        $handlerContext Optional handler context
+	 * @param BodySummarizerInterface|null $bodySummarizer Optional body summarizer
+	 */
+	public static function create(
+		RequestInterface $request,
+		ResponseInterface $response = null,
+		\Throwable $previous = null,
+		array $handlerContext = [],
+		BodySummarizerInterface $bodySummarizer = null
+	): self {
+		if (!$response) {
+			return new self(
+				'Error completing request',
+				$request,
+				null,
+				$previous,
+				$handlerContext
+			);
+		}
+
+		$level = (int) \floor($response->getStatusCode() / 100);
+		if ($level === 4) {
+			$label = 'Client error';
+			$className = ClientException::class;
+		} elseif ($level === 5) {
+			$label = 'Server error';
+			$className = ServerException::class;
+		} else {
+			$label = 'Unsuccessful request';
+			$className = __CLASS__;
+		}
+
+		$uri = $request->getUri();
+		$uri = static::obfuscateUri($uri);
+
+		// Client Error: `GET /` resulted in a `404 Not Found` response:
+		// <html> ... (truncated)
+		$message = \sprintf(
+			'%s: `%s %s` resulted in a `%s %s` response',
+			$label,
+			$request->getMethod(),
+			$uri->__toString(),
+			$response->getStatusCode(),
+			$response->getReasonPhrase()
+		);
+
+		$summary = ($bodySummarizer ?? new BodySummarizer())->summarize($response);
+
+		if ($summary !== null) {
+			$message .= ":\n{$summary}\n";
+		}
+
+		return new $className($message, $request, $response, $previous, $handlerContext);
+	}
+
+	/**
+	 * Obfuscates URI if there is a username and a password present
+	 */
+	private static function obfuscateUri(UriInterface $uri): UriInterface
+	{
+		$userInfo = $uri->getUserInfo();
+
+		if (false !== ($pos = \strpos($userInfo, ':'))) {
+			return $uri->withUserInfo(\substr($userInfo, 0, $pos), '***');
+		}
+
+		return $uri;
+	}
+
+	/**
+	 * Get the request that caused the exception
+	 */
+	public function getRequest(): RequestInterface
+	{
+		return $this->request;
+	}
+
+	/**
+	 * Get the associated response
+	 */
+	public function getResponse(): ?ResponseInterface
+	{
+		return $this->response;
+	}
+
+	/**
+	 * Check if a response was received
+	 */
+	public function hasResponse(): bool
+	{
+		return $this->response !== null;
+	}
+
+	/**
+	 * Get contextual information about the error from the underlying handler.
+	 *
+	 * The contents of this array will vary depending on which handler you are
+	 * using. It may also be just an empty array. Relying on this data will
+	 * couple you to a specific handler, but can give more debug information
+	 * when needed.
+	 */
+	public function getHandlerContext(): array
+	{
+		return $this->handlerContext;
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -78,7 +78,7 @@
             );
         }
 
-        $level = (int) \floor($response->getStatusCode() / 100);
+        $level = (int)\floor($response->getStatusCode() / 100);
         if ($level === 4) {
             $label = 'Client error';
             $className = ClientException::class;

Braces +1 added lines, -2 removed lines

@@ -12,8 +12,7 @@
 /**
  * HTTP Request exception
  */
-class RequestException extends TransferException implements RequestExceptionInterface
-{
+class RequestException extends TransferException implements RequestExceptionInterface {
     /**
      * @var RequestInterface
      */

lib/Vendor/GuzzleHttp/Exception/BadResponseException.php

Indentation +24 added lines, -24 removed lines

@@ -10,30 +10,30 @@
  */
 class BadResponseException extends RequestException
 {
-    public function __construct(
-        string $message,
-        RequestInterface $request,
-        ResponseInterface $response,
-        \Throwable $previous = null,
-        array $handlerContext = []
-    ) {
-        parent::__construct($message, $request, $response, $previous, $handlerContext);
-    }
+	public function __construct(
+		string $message,
+		RequestInterface $request,
+		ResponseInterface $response,
+		\Throwable $previous = null,
+		array $handlerContext = []
+	) {
+		parent::__construct($message, $request, $response, $previous, $handlerContext);
+	}
 
-    /**
-     * Current exception and the ones that extend it will always have a response.
-     */
-    public function hasResponse(): bool
-    {
-        return true;
-    }
+	/**
+	 * Current exception and the ones that extend it will always have a response.
+	 */
+	public function hasResponse(): bool
+	{
+		return true;
+	}
 
-    /**
-     * This function narrows the return type from the parent class and does not allow it to be nullable.
-     */
-    public function getResponse(): ResponseInterface
-    {
-        /** @var ResponseInterface */
-        return parent::getResponse();
-    }
+	/**
+	 * This function narrows the return type from the parent class and does not allow it to be nullable.
+	 */
+	public function getResponse(): ResponseInterface
+	{
+		/** @var ResponseInterface */
+		return parent::getResponse();
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -8,8 +8,7 @@
 /**
  * Exception when an HTTP error occurs (4xx or 5xx error)
  */
-class BadResponseException extends RequestException
-{
+class BadResponseException extends RequestException {
     public function __construct(
         string $message,
         RequestInterface $request,

lib/Vendor/GuzzleHttp/Exception/ConnectException.php

Indentation +37 added lines, -37 removed lines

@@ -12,45 +12,45 @@
  */
 class ConnectException extends TransferException implements NetworkExceptionInterface
 {
-    /**
-     * @var RequestInterface
-     */
-    private $request;
+	/**
+	 * @var RequestInterface
+	 */
+	private $request;
 
-    /**
-     * @var array
-     */
-    private $handlerContext;
+	/**
+	 * @var array
+	 */
+	private $handlerContext;
 
-    public function __construct(
-        string $message,
-        RequestInterface $request,
-        \Throwable $previous = null,
-        array $handlerContext = []
-    ) {
-        parent::__construct($message, 0, $previous);
-        $this->request = $request;
-        $this->handlerContext = $handlerContext;
-    }
+	public function __construct(
+		string $message,
+		RequestInterface $request,
+		\Throwable $previous = null,
+		array $handlerContext = []
+	) {
+		parent::__construct($message, 0, $previous);
+		$this->request = $request;
+		$this->handlerContext = $handlerContext;
+	}
 
-    /**
-     * Get the request that caused the exception
-     */
-    public function getRequest(): RequestInterface
-    {
-        return $this->request;
-    }
+	/**
+	 * Get the request that caused the exception
+	 */
+	public function getRequest(): RequestInterface
+	{
+		return $this->request;
+	}
 
-    /**
-     * Get contextual information about the error from the underlying handler.
-     *
-     * The contents of this array will vary depending on which handler you are
-     * using. It may also be just an empty array. Relying on this data will
-     * couple you to a specific handler, but can give more debug information
-     * when needed.
-     */
-    public function getHandlerContext(): array
-    {
-        return $this->handlerContext;
-    }
+	/**
+	 * Get contextual information about the error from the underlying handler.
+	 *
+	 * The contents of this array will vary depending on which handler you are
+	 * using. It may also be just an empty array. Relying on this data will
+	 * couple you to a specific handler, but can give more debug information
+	 * when needed.
+	 */
+	public function getHandlerContext(): array
+	{
+		return $this->handlerContext;
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -10,8 +10,7 @@
  *
  * Note that no response is present for a ConnectException
  */
-class ConnectException extends TransferException implements NetworkExceptionInterface
-{
+class ConnectException extends TransferException implements NetworkExceptionInterface {
     /**
      * @var RequestInterface
      */

lib/Vendor/GuzzleHttp/Psr7/Utils.php

Indentation +445 added lines, -445 removed lines

@@ -11,453 +11,453 @@
 
 final class Utils
 {
-    /**
-     * Remove the items given by the keys, case insensitively from the data.
-     *
-     * @param (string|int)[] $keys
-     */
-    public static function caselessRemove(array $keys, array $data): array
-    {
-        $result = [];
-
-        foreach ($keys as &$key) {
-            $key = strtolower((string) $key);
-        }
-
-        foreach ($data as $k => $v) {
-            if (!in_array(strtolower((string) $k), $keys)) {
-                $result[$k] = $v;
-            }
-        }
-
-        return $result;
-    }
-
-    /**
-     * Copy the contents of a stream into another stream until the given number
-     * of bytes have been read.
-     *
-     * @param StreamInterface $source Stream to read from
-     * @param StreamInterface $dest   Stream to write to
-     * @param int             $maxLen Maximum number of bytes to read. Pass -1
-     *                                to read the entire stream.
-     *
-     * @throws \RuntimeException on error.
-     */
-    public static function copyToStream(StreamInterface $source, StreamInterface $dest, int $maxLen = -1): void
-    {
-        $bufferSize = 8192;
-
-        if ($maxLen === -1) {
-            while (!$source->eof()) {
-                if (!$dest->write($source->read($bufferSize))) {
-                    break;
-                }
-            }
-        } else {
-            $remaining = $maxLen;
-            while ($remaining > 0 && !$source->eof()) {
-                $buf = $source->read(min($bufferSize, $remaining));
-                $len = strlen($buf);
-                if (!$len) {
-                    break;
-                }
-                $remaining -= $len;
-                $dest->write($buf);
-            }
-        }
-    }
-
-    /**
-     * Copy the contents of a stream into a string until the given number of
-     * bytes have been read.
-     *
-     * @param StreamInterface $stream Stream to read
-     * @param int             $maxLen Maximum number of bytes to read. Pass -1
-     *                                to read the entire stream.
-     *
-     * @throws \RuntimeException on error.
-     */
-    public static function copyToString(StreamInterface $stream, int $maxLen = -1): string
-    {
-        $buffer = '';
-
-        if ($maxLen === -1) {
-            while (!$stream->eof()) {
-                $buf = $stream->read(1048576);
-                if ($buf === '') {
-                    break;
-                }
-                $buffer .= $buf;
-            }
-
-            return $buffer;
-        }
-
-        $len = 0;
-        while (!$stream->eof() && $len < $maxLen) {
-            $buf = $stream->read($maxLen - $len);
-            if ($buf === '') {
-                break;
-            }
-            $buffer .= $buf;
-            $len = strlen($buffer);
-        }
-
-        return $buffer;
-    }
-
-    /**
-     * Calculate a hash of a stream.
-     *
-     * This method reads the entire stream to calculate a rolling hash, based
-     * on PHP's `hash_init` functions.
-     *
-     * @param StreamInterface $stream    Stream to calculate the hash for
-     * @param string          $algo      Hash algorithm (e.g. md5, crc32, etc)
-     * @param bool            $rawOutput Whether or not to use raw output
-     *
-     * @throws \RuntimeException on error.
-     */
-    public static function hash(StreamInterface $stream, string $algo, bool $rawOutput = false): string
-    {
-        $pos = $stream->tell();
-
-        if ($pos > 0) {
-            $stream->rewind();
-        }
-
-        $ctx = hash_init($algo);
-        while (!$stream->eof()) {
-            hash_update($ctx, $stream->read(1048576));
-        }
-
-        $out = hash_final($ctx, $rawOutput);
-        $stream->seek($pos);
-
-        return $out;
-    }
-
-    /**
-     * Clone and modify a request with the given changes.
-     *
-     * This method is useful for reducing the number of clones needed to mutate
-     * a message.
-     *
-     * The changes can be one of:
-     * - method: (string) Changes the HTTP method.
-     * - set_headers: (array) Sets the given headers.
-     * - remove_headers: (array) Remove the given headers.
-     * - body: (mixed) Sets the given body.
-     * - uri: (UriInterface) Set the URI.
-     * - query: (string) Set the query string value of the URI.
-     * - version: (string) Set the protocol version.
-     *
-     * @param RequestInterface $request Request to clone and modify.
-     * @param array            $changes Changes to apply.
-     */
-    public static function modifyRequest(RequestInterface $request, array $changes): RequestInterface
-    {
-        if (!$changes) {
-            return $request;
-        }
-
-        $headers = $request->getHeaders();
-
-        if (!isset($changes['uri'])) {
-            $uri = $request->getUri();
-        } else {
-            // Remove the host header if one is on the URI
-            if ($host = $changes['uri']->getHost()) {
-                $changes['set_headers']['Host'] = $host;
-
-                if ($port = $changes['uri']->getPort()) {
-                    $standardPorts = ['http' => 80, 'https' => 443];
-                    $scheme = $changes['uri']->getScheme();
-                    if (isset($standardPorts[$scheme]) && $port != $standardPorts[$scheme]) {
-                        $changes['set_headers']['Host'] .= ':'.$port;
-                    }
-                }
-            }
-            $uri = $changes['uri'];
-        }
-
-        if (!empty($changes['remove_headers'])) {
-            $headers = self::caselessRemove($changes['remove_headers'], $headers);
-        }
-
-        if (!empty($changes['set_headers'])) {
-            $headers = self::caselessRemove(array_keys($changes['set_headers']), $headers);
-            $headers = $changes['set_headers'] + $headers;
-        }
-
-        if (isset($changes['query'])) {
-            $uri = $uri->withQuery($changes['query']);
-        }
-
-        if ($request instanceof ServerRequestInterface) {
-            $new = (new ServerRequest(
-                $changes['method'] ?? $request->getMethod(),
-                $uri,
-                $headers,
-                $changes['body'] ?? $request->getBody(),
-                $changes['version'] ?? $request->getProtocolVersion(),
-                $request->getServerParams()
-            ))
-            ->withParsedBody($request->getParsedBody())
-            ->withQueryParams($request->getQueryParams())
-            ->withCookieParams($request->getCookieParams())
-            ->withUploadedFiles($request->getUploadedFiles());
-
-            foreach ($request->getAttributes() as $key => $value) {
-                $new = $new->withAttribute($key, $value);
-            }
-
-            return $new;
-        }
-
-        return new Request(
-            $changes['method'] ?? $request->getMethod(),
-            $uri,
-            $headers,
-            $changes['body'] ?? $request->getBody(),
-            $changes['version'] ?? $request->getProtocolVersion()
-        );
-    }
-
-    /**
-     * Read a line from the stream up to the maximum allowed buffer length.
-     *
-     * @param StreamInterface $stream    Stream to read from
-     * @param int|null        $maxLength Maximum buffer length
-     */
-    public static function readLine(StreamInterface $stream, int $maxLength = null): string
-    {
-        $buffer = '';
-        $size = 0;
-
-        while (!$stream->eof()) {
-            if ('' === ($byte = $stream->read(1))) {
-                return $buffer;
-            }
-            $buffer .= $byte;
-            // Break when a new line is found or the max length - 1 is reached
-            if ($byte === "\n" || ++$size === $maxLength - 1) {
-                break;
-            }
-        }
-
-        return $buffer;
-    }
-
-    /**
-     * Create a new stream based on the input type.
-     *
-     * Options is an associative array that can contain the following keys:
-     * - metadata: Array of custom metadata.
-     * - size: Size of the stream.
-     *
-     * This method accepts the following `$resource` types:
-     * - `OCA\FullTextSearch_Elasticsearch\Vendor\Psr\Http\Message\StreamInterface`: Returns the value as-is.
-     * - `string`: Creates a stream object that uses the given string as the contents.
-     * - `resource`: Creates a stream object that wraps the given PHP stream resource.
-     * - `Iterator`: If the provided value implements `Iterator`, then a read-only
-     *   stream object will be created that wraps the given iterable. Each time the
-     *   stream is read from, data from the iterator will fill a buffer and will be
-     *   continuously called until the buffer is equal to the requested read size.
-     *   Subsequent read calls will first read from the buffer and then call `next`
-     *   on the underlying iterator until it is exhausted.
-     * - `object` with `__toString()`: If the object has the `__toString()` method,
-     *   the object will be cast to a string and then a stream will be returned that
-     *   uses the string value.
-     * - `NULL`: When `null` is passed, an empty stream object is returned.
-     * - `callable` When a callable is passed, a read-only stream object will be
-     *   created that invokes the given callable. The callable is invoked with the
-     *   number of suggested bytes to read. The callable can return any number of
-     *   bytes, but MUST return `false` when there is no more data to return. The
-     *   stream object that wraps the callable will invoke the callable until the
-     *   number of requested bytes are available. Any additional bytes will be
-     *   buffered and used in subsequent reads.
-     *
-     * @param resource|string|int|float|bool|StreamInterface|callable|\Iterator|null $resource Entity body data
-     * @param array{size?: int, metadata?: array}                                    $options  Additional options
-     *
-     * @throws \InvalidArgumentException if the $resource arg is not valid.
-     */
-    public static function streamFor($resource = '', array $options = []): StreamInterface
-    {
-        if (is_scalar($resource)) {
-            $stream = self::tryFopen('php://temp', 'r+');
-            if ($resource !== '') {
-                fwrite($stream, (string) $resource);
-                fseek($stream, 0);
-            }
-
-            return new Stream($stream, $options);
-        }
-
-        switch (gettype($resource)) {
-            case 'resource':
-                /*
+	/**
+	 * Remove the items given by the keys, case insensitively from the data.
+	 *
+	 * @param (string|int)[] $keys
+	 */
+	public static function caselessRemove(array $keys, array $data): array
+	{
+		$result = [];
+
+		foreach ($keys as &$key) {
+			$key = strtolower((string) $key);
+		}
+
+		foreach ($data as $k => $v) {
+			if (!in_array(strtolower((string) $k), $keys)) {
+				$result[$k] = $v;
+			}
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Copy the contents of a stream into another stream until the given number
+	 * of bytes have been read.
+	 *
+	 * @param StreamInterface $source Stream to read from
+	 * @param StreamInterface $dest   Stream to write to
+	 * @param int             $maxLen Maximum number of bytes to read. Pass -1
+	 *                                to read the entire stream.
+	 *
+	 * @throws \RuntimeException on error.
+	 */
+	public static function copyToStream(StreamInterface $source, StreamInterface $dest, int $maxLen = -1): void
+	{
+		$bufferSize = 8192;
+
+		if ($maxLen === -1) {
+			while (!$source->eof()) {
+				if (!$dest->write($source->read($bufferSize))) {
+					break;
+				}
+			}
+		} else {
+			$remaining = $maxLen;
+			while ($remaining > 0 && !$source->eof()) {
+				$buf = $source->read(min($bufferSize, $remaining));
+				$len = strlen($buf);
+				if (!$len) {
+					break;
+				}
+				$remaining -= $len;
+				$dest->write($buf);
+			}
+		}
+	}
+
+	/**
+	 * Copy the contents of a stream into a string until the given number of
+	 * bytes have been read.
+	 *
+	 * @param StreamInterface $stream Stream to read
+	 * @param int             $maxLen Maximum number of bytes to read. Pass -1
+	 *                                to read the entire stream.
+	 *
+	 * @throws \RuntimeException on error.
+	 */
+	public static function copyToString(StreamInterface $stream, int $maxLen = -1): string
+	{
+		$buffer = '';
+
+		if ($maxLen === -1) {
+			while (!$stream->eof()) {
+				$buf = $stream->read(1048576);
+				if ($buf === '') {
+					break;
+				}
+				$buffer .= $buf;
+			}
+
+			return $buffer;
+		}
+
+		$len = 0;
+		while (!$stream->eof() && $len < $maxLen) {
+			$buf = $stream->read($maxLen - $len);
+			if ($buf === '') {
+				break;
+			}
+			$buffer .= $buf;
+			$len = strlen($buffer);
+		}
+
+		return $buffer;
+	}
+
+	/**
+	 * Calculate a hash of a stream.
+	 *
+	 * This method reads the entire stream to calculate a rolling hash, based
+	 * on PHP's `hash_init` functions.
+	 *
+	 * @param StreamInterface $stream    Stream to calculate the hash for
+	 * @param string          $algo      Hash algorithm (e.g. md5, crc32, etc)
+	 * @param bool            $rawOutput Whether or not to use raw output
+	 *
+	 * @throws \RuntimeException on error.
+	 */
+	public static function hash(StreamInterface $stream, string $algo, bool $rawOutput = false): string
+	{
+		$pos = $stream->tell();
+
+		if ($pos > 0) {
+			$stream->rewind();
+		}
+
+		$ctx = hash_init($algo);
+		while (!$stream->eof()) {
+			hash_update($ctx, $stream->read(1048576));
+		}
+
+		$out = hash_final($ctx, $rawOutput);
+		$stream->seek($pos);
+
+		return $out;
+	}
+
+	/**
+	 * Clone and modify a request with the given changes.
+	 *
+	 * This method is useful for reducing the number of clones needed to mutate
+	 * a message.
+	 *
+	 * The changes can be one of:
+	 * - method: (string) Changes the HTTP method.
+	 * - set_headers: (array) Sets the given headers.
+	 * - remove_headers: (array) Remove the given headers.
+	 * - body: (mixed) Sets the given body.
+	 * - uri: (UriInterface) Set the URI.
+	 * - query: (string) Set the query string value of the URI.
+	 * - version: (string) Set the protocol version.
+	 *
+	 * @param RequestInterface $request Request to clone and modify.
+	 * @param array            $changes Changes to apply.
+	 */
+	public static function modifyRequest(RequestInterface $request, array $changes): RequestInterface
+	{
+		if (!$changes) {
+			return $request;
+		}
+
+		$headers = $request->getHeaders();
+
+		if (!isset($changes['uri'])) {
+			$uri = $request->getUri();
+		} else {
+			// Remove the host header if one is on the URI
+			if ($host = $changes['uri']->getHost()) {
+				$changes['set_headers']['Host'] = $host;
+
+				if ($port = $changes['uri']->getPort()) {
+					$standardPorts = ['http' => 80, 'https' => 443];
+					$scheme = $changes['uri']->getScheme();
+					if (isset($standardPorts[$scheme]) && $port != $standardPorts[$scheme]) {
+						$changes['set_headers']['Host'] .= ':'.$port;
+					}
+				}
+			}
+			$uri = $changes['uri'];
+		}
+
+		if (!empty($changes['remove_headers'])) {
+			$headers = self::caselessRemove($changes['remove_headers'], $headers);
+		}
+
+		if (!empty($changes['set_headers'])) {
+			$headers = self::caselessRemove(array_keys($changes['set_headers']), $headers);
+			$headers = $changes['set_headers'] + $headers;
+		}
+
+		if (isset($changes['query'])) {
+			$uri = $uri->withQuery($changes['query']);
+		}
+
+		if ($request instanceof ServerRequestInterface) {
+			$new = (new ServerRequest(
+				$changes['method'] ?? $request->getMethod(),
+				$uri,
+				$headers,
+				$changes['body'] ?? $request->getBody(),
+				$changes['version'] ?? $request->getProtocolVersion(),
+				$request->getServerParams()
+			))
+			->withParsedBody($request->getParsedBody())
+			->withQueryParams($request->getQueryParams())
+			->withCookieParams($request->getCookieParams())
+			->withUploadedFiles($request->getUploadedFiles());
+
+			foreach ($request->getAttributes() as $key => $value) {
+				$new = $new->withAttribute($key, $value);
+			}
+
+			return $new;
+		}
+
+		return new Request(
+			$changes['method'] ?? $request->getMethod(),
+			$uri,
+			$headers,
+			$changes['body'] ?? $request->getBody(),
+			$changes['version'] ?? $request->getProtocolVersion()
+		);
+	}
+
+	/**
+	 * Read a line from the stream up to the maximum allowed buffer length.
+	 *
+	 * @param StreamInterface $stream    Stream to read from
+	 * @param int|null        $maxLength Maximum buffer length
+	 */
+	public static function readLine(StreamInterface $stream, int $maxLength = null): string
+	{
+		$buffer = '';
+		$size = 0;
+
+		while (!$stream->eof()) {
+			if ('' === ($byte = $stream->read(1))) {
+				return $buffer;
+			}
+			$buffer .= $byte;
+			// Break when a new line is found or the max length - 1 is reached
+			if ($byte === "\n" || ++$size === $maxLength - 1) {
+				break;
+			}
+		}
+
+		return $buffer;
+	}
+
+	/**
+	 * Create a new stream based on the input type.
+	 *
+	 * Options is an associative array that can contain the following keys:
+	 * - metadata: Array of custom metadata.
+	 * - size: Size of the stream.
+	 *
+	 * This method accepts the following `$resource` types:
+	 * - `OCA\FullTextSearch_Elasticsearch\Vendor\Psr\Http\Message\StreamInterface`: Returns the value as-is.
+	 * - `string`: Creates a stream object that uses the given string as the contents.
+	 * - `resource`: Creates a stream object that wraps the given PHP stream resource.
+	 * - `Iterator`: If the provided value implements `Iterator`, then a read-only
+	 *   stream object will be created that wraps the given iterable. Each time the
+	 *   stream is read from, data from the iterator will fill a buffer and will be
+	 *   continuously called until the buffer is equal to the requested read size.
+	 *   Subsequent read calls will first read from the buffer and then call `next`
+	 *   on the underlying iterator until it is exhausted.
+	 * - `object` with `__toString()`: If the object has the `__toString()` method,
+	 *   the object will be cast to a string and then a stream will be returned that
+	 *   uses the string value.
+	 * - `NULL`: When `null` is passed, an empty stream object is returned.
+	 * - `callable` When a callable is passed, a read-only stream object will be
+	 *   created that invokes the given callable. The callable is invoked with the
+	 *   number of suggested bytes to read. The callable can return any number of
+	 *   bytes, but MUST return `false` when there is no more data to return. The
+	 *   stream object that wraps the callable will invoke the callable until the
+	 *   number of requested bytes are available. Any additional bytes will be
+	 *   buffered and used in subsequent reads.
+	 *
+	 * @param resource|string|int|float|bool|StreamInterface|callable|\Iterator|null $resource Entity body data
+	 * @param array{size?: int, metadata?: array}                                    $options  Additional options
+	 *
+	 * @throws \InvalidArgumentException if the $resource arg is not valid.
+	 */
+	public static function streamFor($resource = '', array $options = []): StreamInterface
+	{
+		if (is_scalar($resource)) {
+			$stream = self::tryFopen('php://temp', 'r+');
+			if ($resource !== '') {
+				fwrite($stream, (string) $resource);
+				fseek($stream, 0);
+			}
+
+			return new Stream($stream, $options);
+		}
+
+		switch (gettype($resource)) {
+			case 'resource':
+				/*
                  * The 'php://input' is a special stream with quirks and inconsistencies.
                  * We avoid using that stream by reading it into php://temp
                  */
 
-                /** @var resource $resource */
-                if ((\stream_get_meta_data($resource)['uri'] ?? '') === 'php://input') {
-                    $stream = self::tryFopen('php://temp', 'w+');
-                    stream_copy_to_stream($resource, $stream);
-                    fseek($stream, 0);
-                    $resource = $stream;
-                }
-
-                return new Stream($resource, $options);
-            case 'object':
-                /** @var object $resource */
-                if ($resource instanceof StreamInterface) {
-                    return $resource;
-                } elseif ($resource instanceof \Iterator) {
-                    return new PumpStream(function () use ($resource) {
-                        if (!$resource->valid()) {
-                            return false;
-                        }
-                        $result = $resource->current();
-                        $resource->next();
-
-                        return $result;
-                    }, $options);
-                } elseif (method_exists($resource, '__toString')) {
-                    return self::streamFor((string) $resource, $options);
-                }
-                break;
-            case 'NULL':
-                return new Stream(self::tryFopen('php://temp', 'r+'), $options);
-        }
-
-        if (is_callable($resource)) {
-            return new PumpStream($resource, $options);
-        }
-
-        throw new \InvalidArgumentException('Invalid resource type: '.gettype($resource));
-    }
-
-    /**
-     * Safely opens a PHP stream resource using a filename.
-     *
-     * When fopen fails, PHP normally raises a warning. This function adds an
-     * error handler that checks for errors and throws an exception instead.
-     *
-     * @param string $filename File to open
-     * @param string $mode     Mode used to open the file
-     *
-     * @return resource
-     *
-     * @throws \RuntimeException if the file cannot be opened
-     */
-    public static function tryFopen(string $filename, string $mode)
-    {
-        $ex = null;
-        set_error_handler(static function (int $errno, string $errstr) use ($filename, $mode, &$ex): bool {
-            $ex = new \RuntimeException(sprintf(
-                'Unable to open "%s" using mode "%s": %s',
-                $filename,
-                $mode,
-                $errstr
-            ));
-
-            return true;
-        });
-
-        try {
-            /** @var resource $handle */
-            $handle = fopen($filename, $mode);
-        } catch (\Throwable $e) {
-            $ex = new \RuntimeException(sprintf(
-                'Unable to open "%s" using mode "%s": %s',
-                $filename,
-                $mode,
-                $e->getMessage()
-            ), 0, $e);
-        }
-
-        restore_error_handler();
-
-        if ($ex) {
-            /** @var $ex \RuntimeException */
-            throw $ex;
-        }
-
-        return $handle;
-    }
-
-    /**
-     * Safely gets the contents of a given stream.
-     *
-     * When stream_get_contents fails, PHP normally raises a warning. This
-     * function adds an error handler that checks for errors and throws an
-     * exception instead.
-     *
-     * @param resource $stream
-     *
-     * @throws \RuntimeException if the stream cannot be read
-     */
-    public static function tryGetContents($stream): string
-    {
-        $ex = null;
-        set_error_handler(static function (int $errno, string $errstr) use (&$ex): bool {
-            $ex = new \RuntimeException(sprintf(
-                'Unable to read stream contents: %s',
-                $errstr
-            ));
-
-            return true;
-        });
-
-        try {
-            /** @var string|false $contents */
-            $contents = stream_get_contents($stream);
-
-            if ($contents === false) {
-                $ex = new \RuntimeException('Unable to read stream contents');
-            }
-        } catch (\Throwable $e) {
-            $ex = new \RuntimeException(sprintf(
-                'Unable to read stream contents: %s',
-                $e->getMessage()
-            ), 0, $e);
-        }
-
-        restore_error_handler();
-
-        if ($ex) {
-            /** @var $ex \RuntimeException */
-            throw $ex;
-        }
-
-        return $contents;
-    }
-
-    /**
-     * Returns a UriInterface for the given value.
-     *
-     * This function accepts a string or UriInterface and returns a
-     * UriInterface for the given value. If the value is already a
-     * UriInterface, it is returned as-is.
-     *
-     * @param string|UriInterface $uri
-     *
-     * @throws \InvalidArgumentException
-     */
-    public static function uriFor($uri): UriInterface
-    {
-        if ($uri instanceof UriInterface) {
-            return $uri;
-        }
-
-        if (is_string($uri)) {
-            return new Uri($uri);
-        }
-
-        throw new \InvalidArgumentException('URI must be a string or UriInterface');
-    }
+				/** @var resource $resource */
+				if ((\stream_get_meta_data($resource)['uri'] ?? '') === 'php://input') {
+					$stream = self::tryFopen('php://temp', 'w+');
+					stream_copy_to_stream($resource, $stream);
+					fseek($stream, 0);
+					$resource = $stream;
+				}
+
+				return new Stream($resource, $options);
+			case 'object':
+				/** @var object $resource */
+				if ($resource instanceof StreamInterface) {
+					return $resource;
+				} elseif ($resource instanceof \Iterator) {
+					return new PumpStream(function () use ($resource) {
+						if (!$resource->valid()) {
+							return false;
+						}
+						$result = $resource->current();
+						$resource->next();
+
+						return $result;
+					}, $options);
+				} elseif (method_exists($resource, '__toString')) {
+					return self::streamFor((string) $resource, $options);
+				}
+				break;
+			case 'NULL':
+				return new Stream(self::tryFopen('php://temp', 'r+'), $options);
+		}
+
+		if (is_callable($resource)) {
+			return new PumpStream($resource, $options);
+		}
+
+		throw new \InvalidArgumentException('Invalid resource type: '.gettype($resource));
+	}
+
+	/**
+	 * Safely opens a PHP stream resource using a filename.
+	 *
+	 * When fopen fails, PHP normally raises a warning. This function adds an
+	 * error handler that checks for errors and throws an exception instead.
+	 *
+	 * @param string $filename File to open
+	 * @param string $mode     Mode used to open the file
+	 *
+	 * @return resource
+	 *
+	 * @throws \RuntimeException if the file cannot be opened
+	 */
+	public static function tryFopen(string $filename, string $mode)
+	{
+		$ex = null;
+		set_error_handler(static function (int $errno, string $errstr) use ($filename, $mode, &$ex): bool {
+			$ex = new \RuntimeException(sprintf(
+				'Unable to open "%s" using mode "%s": %s',
+				$filename,
+				$mode,
+				$errstr
+			));
+
+			return true;
+		});
+
+		try {
+			/** @var resource $handle */
+			$handle = fopen($filename, $mode);
+		} catch (\Throwable $e) {
+			$ex = new \RuntimeException(sprintf(
+				'Unable to open "%s" using mode "%s": %s',
+				$filename,
+				$mode,
+				$e->getMessage()
+			), 0, $e);
+		}
+
+		restore_error_handler();
+
+		if ($ex) {
+			/** @var $ex \RuntimeException */
+			throw $ex;
+		}
+
+		return $handle;
+	}
+
+	/**
+	 * Safely gets the contents of a given stream.
+	 *
+	 * When stream_get_contents fails, PHP normally raises a warning. This
+	 * function adds an error handler that checks for errors and throws an
+	 * exception instead.
+	 *
+	 * @param resource $stream
+	 *
+	 * @throws \RuntimeException if the stream cannot be read
+	 */
+	public static function tryGetContents($stream): string
+	{
+		$ex = null;
+		set_error_handler(static function (int $errno, string $errstr) use (&$ex): bool {
+			$ex = new \RuntimeException(sprintf(
+				'Unable to read stream contents: %s',
+				$errstr
+			));
+
+			return true;
+		});
+
+		try {
+			/** @var string|false $contents */
+			$contents = stream_get_contents($stream);
+
+			if ($contents === false) {
+				$ex = new \RuntimeException('Unable to read stream contents');
+			}
+		} catch (\Throwable $e) {
+			$ex = new \RuntimeException(sprintf(
+				'Unable to read stream contents: %s',
+				$e->getMessage()
+			), 0, $e);
+		}
+
+		restore_error_handler();
+
+		if ($ex) {
+			/** @var $ex \RuntimeException */
+			throw $ex;
+		}
+
+		return $contents;
+	}
+
+	/**
+	 * Returns a UriInterface for the given value.
+	 *
+	 * This function accepts a string or UriInterface and returns a
+	 * UriInterface for the given value. If the value is already a
+	 * UriInterface, it is returned as-is.
+	 *
+	 * @param string|UriInterface $uri
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public static function uriFor($uri): UriInterface
+	{
+		if ($uri instanceof UriInterface) {
+			return $uri;
+		}
+
+		if (is_string($uri)) {
+			return new Uri($uri);
+		}
+
+		throw new \InvalidArgumentException('URI must be a string or UriInterface');
+	}
 }

Spacing +7 added lines, -7 removed lines

@@ -21,11 +21,11 @@ 
         $result = [];
 
         foreach ($keys as &$key) {
-            $key = strtolower((string) $key);
+            $key = strtolower((string)$key);
         }
 
         foreach ($data as $k => $v) {
-            if (!in_array(strtolower((string) $k), $keys)) {
+            if (!in_array(strtolower((string)$k), $keys)) {
                 $result[$k] = $v;
             }
         }
@@ -289,7 +289,7 @@ 
         if (is_scalar($resource)) {
             $stream = self::tryFopen('php://temp', 'r+');
             if ($resource !== '') {
-                fwrite($stream, (string) $resource);
+                fwrite($stream, (string)$resource);
                 fseek($stream, 0);
             }
 
@@ -317,7 +317,7 @@ 
                 if ($resource instanceof StreamInterface) {
                     return $resource;
                 } elseif ($resource instanceof \Iterator) {
-                    return new PumpStream(function () use ($resource) {
+                    return new PumpStream(function() use ($resource) {
                         if (!$resource->valid()) {
                             return false;
                         }
@@ -327,7 +327,7 @@ 
                         return $result;
                     }, $options);
                 } elseif (method_exists($resource, '__toString')) {
-                    return self::streamFor((string) $resource, $options);
+                    return self::streamFor((string)$resource, $options);
                 }
                 break;
             case 'NULL':
@@ -357,7 +357,7 @@ 
     public static function tryFopen(string $filename, string $mode)
     {
         $ex = null;
-        set_error_handler(static function (int $errno, string $errstr) use ($filename, $mode, &$ex): bool {
+        set_error_handler(static function(int $errno, string $errstr) use ($filename, $mode, &$ex): bool {
             $ex = new \RuntimeException(sprintf(
                 'Unable to open "%s" using mode "%s": %s',
                 $filename,
@@ -404,7 +404,7 @@ 
     public static function tryGetContents($stream): string
     {
         $ex = null;
-        set_error_handler(static function (int $errno, string $errstr) use (&$ex): bool {
+        set_error_handler(static function(int $errno, string $errstr) use (&$ex): bool {
             $ex = new \RuntimeException(sprintf(
                 'Unable to read stream contents: %s',
                 $errstr

Braces +1 added lines, -2 removed lines

@@ -9,8 +9,7 @@
 use OCA\FullTextSearch_Elasticsearch\Vendor\Psr\Http\Message\StreamInterface;
 use OCA\FullTextSearch_Elasticsearch\Vendor\Psr\Http\Message\UriInterface;
 
-final class Utils
-{
+final class Utils {
     /**
      * Remove the items given by the keys, case insensitively from the data.
      *