sunrise-php / http-message

src/Stream/PhpTempStream.php

Indentation +10 added lines, -10 removed lines

@@ -28,14 +28,14 @@
 final class PhpTempStream extends Stream
 {
 
-    /**
-     * Constructor of the class
-     *
-     * @param string $mode
-     * @param int<0, max> $maxmemory
-     */
-    public function __construct(string $mode = 'r+b', int $maxmemory = 2097152)
-    {
-        parent::__construct(fopen(sprintf('php://temp/maxmemory:%d', $maxmemory), $mode));
-    }
+	/**
+	 * Constructor of the class
+	 *
+	 * @param string $mode
+	 * @param int<0, max> $maxmemory
+	 */
+	public function __construct(string $mode = 'r+b', int $maxmemory = 2097152)
+	{
+		parent::__construct(fopen(sprintf('php://temp/maxmemory:%d', $maxmemory), $mode));
+	}
 }

src/Stream/TempFileStream.php

Indentation +26 added lines, -26 removed lines

@@ -32,30 +32,30 @@
 final class TempFileStream extends Stream
 {
 
-    /**
-     * Constructor of the class
-     *
-     * @param string $prefix
-     *
-     * @throws RuntimeException
-     */
-    public function __construct(string $prefix = '')
-    {
-        $dirname = sys_get_temp_dir();
-        if (!is_writable($dirname)) {
-            throw new RuntimeException('Temporary files directory is not writable');
-        }
-
-        $filename = tempnam($dirname, $prefix);
-        if ($filename === false) {
-            throw new RuntimeException('Temporary file name cannot be generated');
-        }
-
-        $resource = fopen($filename, 'w+b');
-        if (!is_resource($resource)) {
-            throw new RuntimeException('Temporary file cannot be created or opened');
-        }
-
-        parent::__construct($resource);
-    }
+	/**
+	 * Constructor of the class
+	 *
+	 * @param string $prefix
+	 *
+	 * @throws RuntimeException
+	 */
+	public function __construct(string $prefix = '')
+	{
+		$dirname = sys_get_temp_dir();
+		if (!is_writable($dirname)) {
+			throw new RuntimeException('Temporary files directory is not writable');
+		}
+
+		$filename = tempnam($dirname, $prefix);
+		if ($filename === false) {
+			throw new RuntimeException('Temporary file name cannot be generated');
+		}
+
+		$resource = fopen($filename, 'w+b');
+		if (!is_resource($resource)) {
+			throw new RuntimeException('Temporary file cannot be created or opened');
+		}
+
+		parent::__construct($resource);
+	}
 }

src/Response/HtmlResponse.php

Indentation +40 added lines, -40 removed lines

@@ -32,51 +32,51 @@
 final class HtmlResponse extends Response
 {
 
-    /**
-     * Constructor of the class
-     *
-     * @param int $statusCode
-     * @param mixed $html
-     *
-     * @throws InvalidArgumentException
-     */
-    public function __construct(int $statusCode, $html)
-    {
-        parent::__construct($statusCode);
+	/**
+	 * Constructor of the class
+	 *
+	 * @param int $statusCode
+	 * @param mixed $html
+	 *
+	 * @throws InvalidArgumentException
+	 */
+	public function __construct(int $statusCode, $html)
+	{
+		parent::__construct($statusCode);
 
-        $this->setBody($this->createBody($html));
+		$this->setBody($this->createBody($html));
 
-        $this->setHeader('Content-Type', 'text/html; charset=utf-8');
-    }
+		$this->setHeader('Content-Type', 'text/html; charset=utf-8');
+	}
 
-    /**
-     * Creates the response body from the given HTML data
-     *
-     * @param mixed $html
-     *
-     * @return StreamInterface
-     *
-     * @throws InvalidArgumentException
-     */
-    private function createBody($html): StreamInterface
-    {
-        if ($html instanceof StreamInterface) {
-            return $html;
-        }
+	/**
+	 * Creates the response body from the given HTML data
+	 *
+	 * @param mixed $html
+	 *
+	 * @return StreamInterface
+	 *
+	 * @throws InvalidArgumentException
+	 */
+	private function createBody($html): StreamInterface
+	{
+		if ($html instanceof StreamInterface) {
+			return $html;
+		}
 
-        if (is_object($html) && method_exists($html, '__toString')) {
-            /** @var string */
-            $html = $html->__toString();
-        }
+		if (is_object($html) && method_exists($html, '__toString')) {
+			/** @var string */
+			$html = $html->__toString();
+		}
 
-        if (!is_string($html)) {
-            throw new InvalidArgumentException('Unable to create HTML response due to unexpected HTML data');
-        }
+		if (!is_string($html)) {
+			throw new InvalidArgumentException('Unable to create HTML response due to unexpected HTML data');
+		}
 
-        $stream = new PhpTempStream('r+b');
-        $stream->write($html);
-        $stream->rewind();
+		$stream = new PhpTempStream('r+b');
+		$stream->write($html);
+		$stream->rewind();
 
-        return $stream;
-    }
+		return $stream;
+	}
 }

src/UploadedFile.php

Indentation +225 added lines, -225 removed lines

@@ -49,229 +49,229 @@
 class UploadedFile implements UploadedFileInterface
 {
 
-    /**
-     * List of upload errors
-     *
-     * @link https://www.php.net/manual/en/features.file-upload.errors.php
-     *
-     * @var array<int, string>
-     */
-    public const UPLOAD_ERRORS = [
-        UPLOAD_ERR_OK         => 'No error',
-        UPLOAD_ERR_INI_SIZE   => 'Uploaded file exceeds the upload_max_filesize directive in the php.ini',
-        UPLOAD_ERR_FORM_SIZE  => 'Uploaded file exceeds the MAX_FILE_SIZE directive in the HTML form',
-        UPLOAD_ERR_PARTIAL    => 'Uploaded file was only partially uploaded',
-        UPLOAD_ERR_NO_FILE    => 'No file was uploaded',
-        UPLOAD_ERR_NO_TMP_DIR => 'Missing temporary directory',
-        UPLOAD_ERR_CANT_WRITE => 'Failed to write file to disk',
-        UPLOAD_ERR_EXTENSION  => 'File upload was stopped by a PHP extension',
-    ];
-
-    /**
-     * The file stream
-     *
-     * @var StreamInterface|null
-     */
-    private ?StreamInterface $stream = null;
-
-    /**
-     * The file size
-     *
-     * @var int|null
-     */
-    private ?int $size;
-
-    /**
-     * The file's error code
-     *
-     * @var int
-     */
-    private int $errorCode;
-
-    /**
-     * The file's error message
-     *
-     * @var string
-     */
-    private string $errorMessage;
-
-    /**
-     * The client's file name
-     *
-     * @var string|null
-     */
-    private ?string $clientFilename;
-
-    /**
-     * The client's file media type
-     *
-     * @var string|null
-     */
-    private ?string $clientMediaType;
-
-    /**
-     * Constructor of the class
-     *
-     * @param StreamInterface|null $stream
-     * @param int|null $size
-     * @param int $error
-     * @param string|null $clientFilename
-     * @param string|null $clientMediaType
-     */
-    public function __construct(
-        ?StreamInterface $stream,
-        ?int $size = null,
-        int $error = UPLOAD_ERR_OK,
-        ?string $clientFilename = null,
-        ?string $clientMediaType = null
-    ) {
-        if (UPLOAD_ERR_OK === $error) {
-            $this->stream = $stream;
-        }
-
-        $this->size = $size;
-        $this->errorCode = $error;
-        $this->errorMessage = self::UPLOAD_ERRORS[$error] ?? 'Unknown error';
-        $this->clientFilename = $clientFilename;
-        $this->clientMediaType = $clientMediaType;
-    }
-
-    /**
-     * Gets the file stream
-     *
-     * @return StreamInterface
-     *
-     * @throws RuntimeException
-     *         - If the file has no a stream due to an error;
-     *         - If the file was already moved.
-     */
-    public function getStream(): StreamInterface
-    {
-        if (UPLOAD_ERR_OK <> $this->errorCode) {
-            throw new RuntimeException(sprintf(
-                'Uploaded file has no a stream due to the error #%d (%s)',
-                $this->errorCode,
-                $this->errorMessage
-            ));
-        }
-
-        if (!isset($this->stream)) {
-            throw new RuntimeException(
-                'Uploaded file has no a stream because it was already moved'
-            );
-        }
-
-        return $this->stream;
-    }
-
-    /**
-     * Moves the file to the given path
-     *
-     * @param string $targetPath
-     *
-     * @return void
-     *
-     * @throws RuntimeException
-     *         - If the file has no a stream due to an error;
-     *         - If the file was already moved;
-     *         - If the file cannot be read;
-     *         - If the target path cannot be used.
-     */
-    public function moveTo($targetPath): void
-    {
-        if (UPLOAD_ERR_OK <> $this->errorCode) {
-            throw new RuntimeException(sprintf(
-                'Uploaded file cannot be moved due to the error #%d (%s)',
-                $this->errorCode,
-                $this->errorMessage
-            ));
-        }
-
-        if (!isset($this->stream)) {
-            throw new RuntimeException(
-                'Uploaded file cannot be moved because it was already moved'
-            );
-        }
-
-        if (!$this->stream->isReadable()) {
-            throw new RuntimeException(
-                'Uploaded file cannot be moved because it is not readable'
-            );
-        }
-
-        $targetDir = dirname($targetPath);
-        if (!is_dir($targetDir) || !is_writable($targetDir)) {
-            throw new RuntimeException(sprintf(
-                'Uploaded file cannot be moved because the directory "%s" is not writable',
-                $targetDir
-            ));
-        }
-
-        $targetStream = new FileStream($targetPath, 'wb');
-
-        if ($this->stream->isSeekable()) {
-            $this->stream->rewind();
-        }
-
-        while (!$this->stream->eof()) {
-            $targetStream->write(
-                $this->stream->read(4096)
-            );
-        }
-
-        $targetStream->close();
-
-        /** @var string|null */
-        $sourcePath = $this->stream->getMetadata('uri');
-
-        $this->stream->close();
-        $this->stream = null;
-
-        if (isset($sourcePath) && is_file($sourcePath)) {
-            $sourceDir = dirname($sourcePath);
-            if (is_writable($sourceDir)) {
-                unlink($sourcePath);
-            }
-        }
-    }
-
-    /**
-     * Gets the file size
-     *
-     * @return int|null
-     */
-    public function getSize(): ?int
-    {
-        return $this->size;
-    }
-
-    /**
-     * Gets the file's error code
-     *
-     * @return int
-     */
-    public function getError(): int
-    {
-        return $this->errorCode;
-    }
-
-    /**
-     * Gets the client's file name
-     *
-     * @return string|null
-     */
-    public function getClientFilename(): ?string
-    {
-        return $this->clientFilename;
-    }
-
-    /**
-     * Gets the client's file media type
-     *
-     * @return string|null
-     */
-    public function getClientMediaType(): ?string
-    {
-        return $this->clientMediaType;
-    }
+	/**
+	 * List of upload errors
+	 *
+	 * @link https://www.php.net/manual/en/features.file-upload.errors.php
+	 *
+	 * @var array<int, string>
+	 */
+	public const UPLOAD_ERRORS = [
+		UPLOAD_ERR_OK         => 'No error',
+		UPLOAD_ERR_INI_SIZE   => 'Uploaded file exceeds the upload_max_filesize directive in the php.ini',
+		UPLOAD_ERR_FORM_SIZE  => 'Uploaded file exceeds the MAX_FILE_SIZE directive in the HTML form',
+		UPLOAD_ERR_PARTIAL    => 'Uploaded file was only partially uploaded',
+		UPLOAD_ERR_NO_FILE    => 'No file was uploaded',
+		UPLOAD_ERR_NO_TMP_DIR => 'Missing temporary directory',
+		UPLOAD_ERR_CANT_WRITE => 'Failed to write file to disk',
+		UPLOAD_ERR_EXTENSION  => 'File upload was stopped by a PHP extension',
+	];
+
+	/**
+	 * The file stream
+	 *
+	 * @var StreamInterface|null
+	 */
+	private ?StreamInterface $stream = null;
+
+	/**
+	 * The file size
+	 *
+	 * @var int|null
+	 */
+	private ?int $size;
+
+	/**
+	 * The file's error code
+	 *
+	 * @var int
+	 */
+	private int $errorCode;
+
+	/**
+	 * The file's error message
+	 *
+	 * @var string
+	 */
+	private string $errorMessage;
+
+	/**
+	 * The client's file name
+	 *
+	 * @var string|null
+	 */
+	private ?string $clientFilename;
+
+	/**
+	 * The client's file media type
+	 *
+	 * @var string|null
+	 */
+	private ?string $clientMediaType;
+
+	/**
+	 * Constructor of the class
+	 *
+	 * @param StreamInterface|null $stream
+	 * @param int|null $size
+	 * @param int $error
+	 * @param string|null $clientFilename
+	 * @param string|null $clientMediaType
+	 */
+	public function __construct(
+		?StreamInterface $stream,
+		?int $size = null,
+		int $error = UPLOAD_ERR_OK,
+		?string $clientFilename = null,
+		?string $clientMediaType = null
+	) {
+		if (UPLOAD_ERR_OK === $error) {
+			$this->stream = $stream;
+		}
+
+		$this->size = $size;
+		$this->errorCode = $error;
+		$this->errorMessage = self::UPLOAD_ERRORS[$error] ?? 'Unknown error';
+		$this->clientFilename = $clientFilename;
+		$this->clientMediaType = $clientMediaType;
+	}
+
+	/**
+	 * Gets the file stream
+	 *
+	 * @return StreamInterface
+	 *
+	 * @throws RuntimeException
+	 *         - If the file has no a stream due to an error;
+	 *         - If the file was already moved.
+	 */
+	public function getStream(): StreamInterface
+	{
+		if (UPLOAD_ERR_OK <> $this->errorCode) {
+			throw new RuntimeException(sprintf(
+				'Uploaded file has no a stream due to the error #%d (%s)',
+				$this->errorCode,
+				$this->errorMessage
+			));
+		}
+
+		if (!isset($this->stream)) {
+			throw new RuntimeException(
+				'Uploaded file has no a stream because it was already moved'
+			);
+		}
+
+		return $this->stream;
+	}
+
+	/**
+	 * Moves the file to the given path
+	 *
+	 * @param string $targetPath
+	 *
+	 * @return void
+	 *
+	 * @throws RuntimeException
+	 *         - If the file has no a stream due to an error;
+	 *         - If the file was already moved;
+	 *         - If the file cannot be read;
+	 *         - If the target path cannot be used.
+	 */
+	public function moveTo($targetPath): void
+	{
+		if (UPLOAD_ERR_OK <> $this->errorCode) {
+			throw new RuntimeException(sprintf(
+				'Uploaded file cannot be moved due to the error #%d (%s)',
+				$this->errorCode,
+				$this->errorMessage
+			));
+		}
+
+		if (!isset($this->stream)) {
+			throw new RuntimeException(
+				'Uploaded file cannot be moved because it was already moved'
+			);
+		}
+
+		if (!$this->stream->isReadable()) {
+			throw new RuntimeException(
+				'Uploaded file cannot be moved because it is not readable'
+			);
+		}
+
+		$targetDir = dirname($targetPath);
+		if (!is_dir($targetDir) || !is_writable($targetDir)) {
+			throw new RuntimeException(sprintf(
+				'Uploaded file cannot be moved because the directory "%s" is not writable',
+				$targetDir
+			));
+		}
+
+		$targetStream = new FileStream($targetPath, 'wb');
+
+		if ($this->stream->isSeekable()) {
+			$this->stream->rewind();
+		}
+
+		while (!$this->stream->eof()) {
+			$targetStream->write(
+				$this->stream->read(4096)
+			);
+		}
+
+		$targetStream->close();
+
+		/** @var string|null */
+		$sourcePath = $this->stream->getMetadata('uri');
+
+		$this->stream->close();
+		$this->stream = null;
+
+		if (isset($sourcePath) && is_file($sourcePath)) {
+			$sourceDir = dirname($sourcePath);
+			if (is_writable($sourceDir)) {
+				unlink($sourcePath);
+			}
+		}
+	}
+
+	/**
+	 * Gets the file size
+	 *
+	 * @return int|null
+	 */
+	public function getSize(): ?int
+	{
+		return $this->size;
+	}
+
+	/**
+	 * Gets the file's error code
+	 *
+	 * @return int
+	 */
+	public function getError(): int
+	{
+		return $this->errorCode;
+	}
+
+	/**
+	 * Gets the client's file name
+	 *
+	 * @return string|null
+	 */
+	public function getClientFilename(): ?string
+	{
+		return $this->clientFilename;
+	}
+
+	/**
+	 * Gets the client's file media type
+	 *
+	 * @return string|null
+	 */
+	public function getClientMediaType(): ?string
+	{
+		return $this->clientMediaType;
+	}
 }

src/Request.php

Indentation +281 added lines, -281 removed lines

@@ -36,285 +36,285 @@
 class Request extends Message implements RequestInterface, RequestMethodInterface
 {
 
-    /**
-     * Regular Expression used for a request target validation
-     *
-     * @var string
-     */
-    public const RFC7230_REQUEST_TARGET_REGEX = '/^[\x21-\x7E\x80-\xFF]+$/';
-
-    /**
-     * The request method (aka verb)
-     *
-     * @var string
-     */
-    private string $method = self::METHOD_GET;
-
-    /**
-     * The request URI
-     *
-     * @var UriInterface
-     */
-    private UriInterface $uri;
-
-    /**
-     * The request target
-     *
-     * @var string|null
-     */
-    private ?string $requestTarget = null;
-
-    /**
-     * Constructor of the class
-     *
-     * @param string|null $method
-     * @param mixed $uri
-     * @param array<string, string|string[]>|null $headers
-     * @param StreamInterface|null $body
-     *
-     * @throws InvalidArgumentException
-     *         If one of the arguments isn't valid.
-     */
-    public function __construct(
-        ?string $method = null,
-        $uri = null,
-        ?array $headers = null,
-        ?StreamInterface $body = null
-    ) {
-        if (isset($method)) {
-            $this->setMethod($method);
-        }
-
-        $this->setUri($uri ?? '/');
-
-        if (isset($headers)) {
-            $this->setHeaders($headers);
-        }
-
-        if (isset($body)) {
-            $this->setBody($body);
-        }
-    }
-
-    /**
-     * Gets the request method
-     *
-     * @return string
-     */
-    public function getMethod(): string
-    {
-        return $this->method;
-    }
-
-    /**
-     * Creates a new instance of the request with the given method
-     *
-     * @param string $method
-     *
-     * @return static
-     *
-     * @throws InvalidArgumentException
-     *         If the method isn't valid.
-     */
-    public function withMethod($method): RequestInterface
-    {
-        $clone = clone $this;
-        $clone->setMethod($method);
-
-        return $clone;
-    }
-
-    /**
-     * Gets the request URI
-     *
-     * @return UriInterface
-     */
-    public function getUri(): UriInterface
-    {
-        return $this->uri;
-    }
-
-    /**
-     * Creates a new instance of the request with the given URI
-     *
-     * @param UriInterface $uri
-     * @param bool $preserveHost
-     *
-     * @return static
-     */
-    public function withUri(UriInterface $uri, $preserveHost = false): RequestInterface
-    {
-        $clone = clone $this;
-        $clone->setUri($uri, $preserveHost);
-
-        return $clone;
-    }
-
-    /**
-     * Gets the request target
-     *
-     * @return string
-     */
-    public function getRequestTarget(): string
-    {
-        if (isset($this->requestTarget)) {
-            return $this->requestTarget;
-        }
-
-        $requestTarget = $this->uri->getPath();
-
-        // https://tools.ietf.org/html/rfc7230#section-5.3.1
-        // https://tools.ietf.org/html/rfc7230#section-2.7
-        //
-        // origin-form = absolute-path [ "?" query ]
-        // absolute-path = 1*( "/" segment )
-        if (strncmp($requestTarget, '/', 1) !== 0) {
-            return '/';
-        }
-
-        $queryString = $this->uri->getQuery();
-        if ($queryString !== '') {
-            $requestTarget .= '?' . $queryString;
-        }
-
-        return $requestTarget;
-    }
-
-    /**
-     * Creates a new instance of the request with the given request target
-     *
-     * @param mixed $requestTarget
-     *
-     * @return static
-     *
-     * @throws InvalidArgumentException
-     *         If the request target isn't valid.
-     */
-    public function withRequestTarget($requestTarget): RequestInterface
-    {
-        $clone = clone $this;
-        $clone->setRequestTarget($requestTarget);
-
-        return $clone;
-    }
-
-    /**
-     * Sets the given method to the request
-     *
-     * @param string $method
-     *
-     * @return void
-     *
-     * @throws InvalidArgumentException
-     *         If the method isn't valid.
-     */
-    final protected function setMethod($method): void
-    {
-        $this->validateMethod($method);
-
-        $this->method = $method;
-    }
-
-    /**
-     * Sets the given URI to the request
-     *
-     * @param mixed $uri
-     * @param bool $preserveHost
-     *
-     * @return void
-     *
-     * @throws InvalidArgumentException
-     *         If the URI isn't valid.
-     */
-    final protected function setUri($uri, $preserveHost = false): void
-    {
-        $this->uri = Uri::create($uri);
-
-        if ($preserveHost && $this->hasHeader('Host')) {
-            return;
-        }
-
-        $host = $this->uri->getHost();
-        if ($host === '') {
-            return;
-        }
-
-        $port = $this->uri->getPort();
-        if (isset($port)) {
-            $host .= ':' . $port;
-        }
-
-        $this->setHeader('Host', $host, true);
-    }
-
-    /**
-     * Sets the given request target to the request
-     *
-     * @param mixed $requestTarget
-     *
-     * @return void
-     *
-     * @throws InvalidArgumentException
-     *         If the request target isn't valid.
-     */
-    final protected function setRequestTarget($requestTarget): void
-    {
-        $this->validateRequestTarget($requestTarget);
-
-        /** @var string $requestTarget */
-
-        $this->requestTarget = $requestTarget;
-    }
-
-    /**
-     * Validates the given method
-     *
-     * @link https://tools.ietf.org/html/rfc7230#section-3.1.1
-     *
-     * @param mixed $method
-     *
-     * @return void
-     *
-     * @throws InvalidArgumentException
-     *         If the method isn't valid.
-     */
-    private function validateMethod($method): void
-    {
-        if ('' === $method) {
-            throw new InvalidArgumentException('HTTP method cannot be an empty');
-        }
-
-        if (!is_string($method)) {
-            throw new InvalidArgumentException('HTTP method must be a string');
-        }
-
-        if (!preg_match(HeaderInterface::RFC7230_TOKEN_REGEX, $method)) {
-            throw new InvalidArgumentException('Invalid HTTP method');
-        }
-    }
-
-    /**
-     * Validates the given request target
-     *
-     * @param mixed $requestTarget
-     *
-     * @return void
-     *
-     * @throws InvalidArgumentException
-     *         If the request target isn't valid.
-     */
-    private function validateRequestTarget($requestTarget): void
-    {
-        if ('' === $requestTarget) {
-            throw new InvalidArgumentException('HTTP request target cannot be an empty');
-        }
-
-        if (!is_string($requestTarget)) {
-            throw new InvalidArgumentException('HTTP request target must be a string');
-        }
-
-        if (!preg_match(self::RFC7230_REQUEST_TARGET_REGEX, $requestTarget)) {
-            throw new InvalidArgumentException('Invalid HTTP request target');
-        }
-    }
+	/**
+	 * Regular Expression used for a request target validation
+	 *
+	 * @var string
+	 */
+	public const RFC7230_REQUEST_TARGET_REGEX = '/^[\x21-\x7E\x80-\xFF]+$/';
+
+	/**
+	 * The request method (aka verb)
+	 *
+	 * @var string
+	 */
+	private string $method = self::METHOD_GET;
+
+	/**
+	 * The request URI
+	 *
+	 * @var UriInterface
+	 */
+	private UriInterface $uri;
+
+	/**
+	 * The request target
+	 *
+	 * @var string|null
+	 */
+	private ?string $requestTarget = null;
+
+	/**
+	 * Constructor of the class
+	 *
+	 * @param string|null $method
+	 * @param mixed $uri
+	 * @param array<string, string|string[]>|null $headers
+	 * @param StreamInterface|null $body
+	 *
+	 * @throws InvalidArgumentException
+	 *         If one of the arguments isn't valid.
+	 */
+	public function __construct(
+		?string $method = null,
+		$uri = null,
+		?array $headers = null,
+		?StreamInterface $body = null
+	) {
+		if (isset($method)) {
+			$this->setMethod($method);
+		}
+
+		$this->setUri($uri ?? '/');
+
+		if (isset($headers)) {
+			$this->setHeaders($headers);
+		}
+
+		if (isset($body)) {
+			$this->setBody($body);
+		}
+	}
+
+	/**
+	 * Gets the request method
+	 *
+	 * @return string
+	 */
+	public function getMethod(): string
+	{
+		return $this->method;
+	}
+
+	/**
+	 * Creates a new instance of the request with the given method
+	 *
+	 * @param string $method
+	 *
+	 * @return static
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the method isn't valid.
+	 */
+	public function withMethod($method): RequestInterface
+	{
+		$clone = clone $this;
+		$clone->setMethod($method);
+
+		return $clone;
+	}
+
+	/**
+	 * Gets the request URI
+	 *
+	 * @return UriInterface
+	 */
+	public function getUri(): UriInterface
+	{
+		return $this->uri;
+	}
+
+	/**
+	 * Creates a new instance of the request with the given URI
+	 *
+	 * @param UriInterface $uri
+	 * @param bool $preserveHost
+	 *
+	 * @return static
+	 */
+	public function withUri(UriInterface $uri, $preserveHost = false): RequestInterface
+	{
+		$clone = clone $this;
+		$clone->setUri($uri, $preserveHost);
+
+		return $clone;
+	}
+
+	/**
+	 * Gets the request target
+	 *
+	 * @return string
+	 */
+	public function getRequestTarget(): string
+	{
+		if (isset($this->requestTarget)) {
+			return $this->requestTarget;
+		}
+
+		$requestTarget = $this->uri->getPath();
+
+		// https://tools.ietf.org/html/rfc7230#section-5.3.1
+		// https://tools.ietf.org/html/rfc7230#section-2.7
+		//
+		// origin-form = absolute-path [ "?" query ]
+		// absolute-path = 1*( "/" segment )
+		if (strncmp($requestTarget, '/', 1) !== 0) {
+			return '/';
+		}
+
+		$queryString = $this->uri->getQuery();
+		if ($queryString !== '') {
+			$requestTarget .= '?' . $queryString;
+		}
+
+		return $requestTarget;
+	}
+
+	/**
+	 * Creates a new instance of the request with the given request target
+	 *
+	 * @param mixed $requestTarget
+	 *
+	 * @return static
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the request target isn't valid.
+	 */
+	public function withRequestTarget($requestTarget): RequestInterface
+	{
+		$clone = clone $this;
+		$clone->setRequestTarget($requestTarget);
+
+		return $clone;
+	}
+
+	/**
+	 * Sets the given method to the request
+	 *
+	 * @param string $method
+	 *
+	 * @return void
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the method isn't valid.
+	 */
+	final protected function setMethod($method): void
+	{
+		$this->validateMethod($method);
+
+		$this->method = $method;
+	}
+
+	/**
+	 * Sets the given URI to the request
+	 *
+	 * @param mixed $uri
+	 * @param bool $preserveHost
+	 *
+	 * @return void
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the URI isn't valid.
+	 */
+	final protected function setUri($uri, $preserveHost = false): void
+	{
+		$this->uri = Uri::create($uri);
+
+		if ($preserveHost && $this->hasHeader('Host')) {
+			return;
+		}
+
+		$host = $this->uri->getHost();
+		if ($host === '') {
+			return;
+		}
+
+		$port = $this->uri->getPort();
+		if (isset($port)) {
+			$host .= ':' . $port;
+		}
+
+		$this->setHeader('Host', $host, true);
+	}
+
+	/**
+	 * Sets the given request target to the request
+	 *
+	 * @param mixed $requestTarget
+	 *
+	 * @return void
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the request target isn't valid.
+	 */
+	final protected function setRequestTarget($requestTarget): void
+	{
+		$this->validateRequestTarget($requestTarget);
+
+		/** @var string $requestTarget */
+
+		$this->requestTarget = $requestTarget;
+	}
+
+	/**
+	 * Validates the given method
+	 *
+	 * @link https://tools.ietf.org/html/rfc7230#section-3.1.1
+	 *
+	 * @param mixed $method
+	 *
+	 * @return void
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the method isn't valid.
+	 */
+	private function validateMethod($method): void
+	{
+		if ('' === $method) {
+			throw new InvalidArgumentException('HTTP method cannot be an empty');
+		}
+
+		if (!is_string($method)) {
+			throw new InvalidArgumentException('HTTP method must be a string');
+		}
+
+		if (!preg_match(HeaderInterface::RFC7230_TOKEN_REGEX, $method)) {
+			throw new InvalidArgumentException('Invalid HTTP method');
+		}
+	}
+
+	/**
+	 * Validates the given request target
+	 *
+	 * @param mixed $requestTarget
+	 *
+	 * @return void
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the request target isn't valid.
+	 */
+	private function validateRequestTarget($requestTarget): void
+	{
+		if ('' === $requestTarget) {
+			throw new InvalidArgumentException('HTTP request target cannot be an empty');
+		}
+
+		if (!is_string($requestTarget)) {
+			throw new InvalidArgumentException('HTTP request target must be a string');
+		}
+
+		if (!preg_match(self::RFC7230_REQUEST_TARGET_REGEX, $requestTarget)) {
+			throw new InvalidArgumentException('Invalid HTTP request target');
+		}
+	}
 }

src/Message.php

Indentation +389 added lines, -389 removed lines

@@ -39,393 +39,393 @@
 abstract class Message implements MessageInterface
 {
 
-    /**
-     * Supported HTTP versions
-     *
-     * @var list<string>
-     */
-    public const SUPPORTED_HTTP_VERSIONS = ['1.0', '1.1', '2.0', '2'];
-
-    /**
-     * Default HTTP version
-     *
-     * @var string
-     */
-    public const DEFAULT_HTTP_VERSION = '1.1';
-
-    /**
-     * The message HTTP version
-     *
-     * @var string
-     */
-    private string $protocolVersion = self::DEFAULT_HTTP_VERSION;
-
-    /**
-     * The message headers
-     *
-     * @var array<string, list<string>>
-     */
-    private array $headers = [];
-
-    /**
-     * Original header names (see $headers)
-     *
-     * @var array<string, string>
-     */
-    private array $headerNames = [];
-
-    /**
-     * The message body
-     *
-     * @var StreamInterface|null
-     */
-    private ?StreamInterface $body = null;
-
-    /**
-     * Gets the message HTTP version
-     *
-     * @return string
-     */
-    public function getProtocolVersion(): string
-    {
-        return $this->protocolVersion;
-    }
-
-    /**
-     * Creates a new instance of the message with the given HTTP version
-     *
-     * @param string $version
-     *
-     * @return static
-     *
-     * @throws InvalidArgumentException
-     *         If the HTTP version isn't valid.
-     */
-    public function withProtocolVersion($version): MessageInterface
-    {
-        $clone = clone $this;
-        $clone->setProtocolVersion($version);
-
-        return $clone;
-    }
-
-    /**
-     * Gets the message headers
-     *
-     * @return array<string, list<string>>
-     */
-    public function getHeaders(): array
-    {
-        return $this->headers;
-    }
-
-    /**
-     * Checks if a header exists in the message by the given name
-     *
-     * @param string $name
-     *
-     * @return bool
-     */
-    public function hasHeader($name): bool
-    {
-        $key = strtolower($name);
-
-        return isset($this->headerNames[$key]);
-    }
-
-    /**
-     * Gets a header value from the message by the given name
-     *
-     * @param string $name
-     *
-     * @return list<string>
-     */
-    public function getHeader($name): array
-    {
-        $key = strtolower($name);
-
-        if (empty($this->headerNames[$key])) {
-            return [];
-        }
-
-        return $this->headers[$this->headerNames[$key]];
-    }
-
-    /**
-     * Gets a header value as a string from the message by the given name
-     *
-     * @param string $name
-     *
-     * @return string
-     */
-    public function getHeaderLine($name): string
-    {
-        $value = $this->getHeader($name);
-        if ([] === $value) {
-            return '';
-        }
-
-        return implode(',', $value);
-    }
-
-    /**
-     * Creates a new instance of the message with the given header overwriting the old header
-     *
-     * @param string $name
-     * @param string|string[] $value
-     *
-     * @return static
-     *
-     * @throws InvalidArgumentException
-     *         If the header isn't valid.
-     */
-    public function withHeader($name, $value): MessageInterface
-    {
-        $clone = clone $this;
-        $clone->setHeader($name, $value, true);
-
-        return $clone;
-    }
-
-    /**
-     * Creates a new instance of the message with the given header NOT overwriting the old header
-     *
-     * @param string $name
-     * @param string|string[] $value
-     *
-     * @return static
-     *
-     * @throws InvalidArgumentException
-     *         If the header isn't valid.
-     */
-    public function withAddedHeader($name, $value): MessageInterface
-    {
-        $clone = clone $this;
-        $clone->setHeader($name, $value, false);
-
-        return $clone;
-    }
-
-    /**
-     * Creates a new instance of the message without a header by the given name
-     *
-     * @param string $name
-     *
-     * @return static
-     */
-    public function withoutHeader($name): MessageInterface
-    {
-        $clone = clone $this;
-        $clone->deleteHeader($name);
-
-        return $clone;
-    }
-
-    /**
-     * Gets the message body
-     *
-     * @return StreamInterface
-     */
-    public function getBody(): StreamInterface
-    {
-        return $this->body ??= new PhpTempStream();
-    }
-
-    /**
-     * Creates a new instance of the message with the given body
-     *
-     * @param StreamInterface $body
-     *
-     * @return static
-     */
-    public function withBody(StreamInterface $body): MessageInterface
-    {
-        $clone = clone $this;
-        $clone->setBody($body);
-
-        return $clone;
-    }
-
-    /**
-     * Sets the given HTTP version to the message
-     *
-     * @param string $protocolVersion
-     *
-     * @return void
-     *
-     * @throws InvalidArgumentException
-     *         If the HTTP version isn't valid.
-     */
-    final protected function setProtocolVersion($protocolVersion): void
-    {
-        $this->validateProtocolVersion($protocolVersion);
-
-        $this->protocolVersion = $protocolVersion;
-    }
-
-    /**
-     * Sets a new header to the message with the given name and value(s)
-     *
-     * @param string $name
-     * @param string|string[] $value
-     * @param bool $replace
-     *
-     * @return void
-     *
-     * @throws InvalidArgumentException
-     *         If the header isn't valid.
-     */
-    final protected function setHeader($name, $value, bool $replace = true): void
-    {
-        if (!is_array($value)) {
-            $value = [$value];
-        }
-
-        $this->validateHeaderName($name);
-        $this->validateHeaderValue($name, $value);
-
-        if ($replace) {
-            $this->deleteHeader($name);
-        }
-
-        $key = strtolower($name);
-
-        $this->headerNames[$key] ??= $name;
-        $this->headers[$this->headerNames[$key]] ??= [];
-
-        foreach ($value as $item) {
-            $this->headers[$this->headerNames[$key]][] = $item;
-        }
-    }
-
-    /**
-     * Sets the given headers to the message
-     *
-     * @param array<string, string|string[]> $headers
-     *
-     * @return void
-     *
-     * @throws InvalidArgumentException
-     *         If one of the headers isn't valid.
-     */
-    final protected function setHeaders(array $headers): void
-    {
-        foreach ($headers as $name => $value) {
-            $this->setHeader($name, $value, false);
-        }
-    }
-
-    /**
-     * Deletes a header from the message by the given name
-     *
-     * @param string $name
-     *
-     * @return void
-     */
-    final protected function deleteHeader($name): void
-    {
-        $key = strtolower($name);
-
-        if (isset($this->headerNames[$key])) {
-            unset($this->headers[$this->headerNames[$key]]);
-            unset($this->headerNames[$key]);
-        }
-    }
-
-    /**
-     * Sets the given body to the message
-     *
-     * @param StreamInterface $body
-     *
-     * @return void
-     */
-    final protected function setBody(StreamInterface $body): void
-    {
-        $this->body = $body;
-    }
-
-    /**
-     * Validates the given HTTP version
-     *
-     * @param mixed $protocolVersion
-     *
-     * @return void
-     *
-     * @throws InvalidArgumentException
-     *         If the HTTP version isn't valid.
-     */
-    private function validateProtocolVersion($protocolVersion): void
-    {
-        if (!in_array($protocolVersion, self::SUPPORTED_HTTP_VERSIONS, true)) {
-            throw new InvalidArgumentException('Invalid or unsupported HTTP version');
-        }
-    }
-
-    /**
-     * Validates the given header name
-     *
-     * @param mixed $name
-     *
-     * @return void
-     *
-     * @throws InvalidArgumentException
-     *         If the header name isn't valid.
-     */
-    private function validateHeaderName($name): void
-    {
-        if ($name === '') {
-            throw new InvalidArgumentException('HTTP header name cannot be an empty');
-        }
-
-        if (!is_string($name)) {
-            throw new InvalidArgumentException('HTTP header name must be a string');
-        }
-
-        if (!preg_match(HeaderInterface::RFC7230_TOKEN_REGEX, $name)) {
-            throw new InvalidArgumentException('HTTP header name is invalid');
-        }
-    }
-
-    /**
-     * Validates the given header value
-     *
-     * @param string $name
-     * @param array $value
-     *
-     * @return void
-     *
-     * @throws InvalidArgumentException
-     *         If the header value isn't valid.
-     */
-    private function validateHeaderValue(string $name, array $value): void
-    {
-        if ([] === $value) {
-            throw new InvalidArgumentException(sprintf(
-                'The "%s" HTTP header value cannot be an empty array',
-                $name,
-            ));
-        }
-
-        foreach ($value as $key => $item) {
-            if ('' === $item) {
-                continue;
-            }
-
-            if (!is_string($item)) {
-                throw new InvalidArgumentException(sprintf(
-                    'The "%s[%s]" HTTP header value must be a string',
-                    $name,
-                    $key
-                ));
-            }
-
-            if (!preg_match(HeaderInterface::RFC7230_FIELD_VALUE_REGEX, $item)) {
-                throw new InvalidArgumentException(sprintf(
-                    'The "%s[%s]" HTTP header value is invalid',
-                    $name,
-                    $key
-                ));
-            }
-        }
-    }
+	/**
+	 * Supported HTTP versions
+	 *
+	 * @var list<string>
+	 */
+	public const SUPPORTED_HTTP_VERSIONS = ['1.0', '1.1', '2.0', '2'];
+
+	/**
+	 * Default HTTP version
+	 *
+	 * @var string
+	 */
+	public const DEFAULT_HTTP_VERSION = '1.1';
+
+	/**
+	 * The message HTTP version
+	 *
+	 * @var string
+	 */
+	private string $protocolVersion = self::DEFAULT_HTTP_VERSION;
+
+	/**
+	 * The message headers
+	 *
+	 * @var array<string, list<string>>
+	 */
+	private array $headers = [];
+
+	/**
+	 * Original header names (see $headers)
+	 *
+	 * @var array<string, string>
+	 */
+	private array $headerNames = [];
+
+	/**
+	 * The message body
+	 *
+	 * @var StreamInterface|null
+	 */
+	private ?StreamInterface $body = null;
+
+	/**
+	 * Gets the message HTTP version
+	 *
+	 * @return string
+	 */
+	public function getProtocolVersion(): string
+	{
+		return $this->protocolVersion;
+	}
+
+	/**
+	 * Creates a new instance of the message with the given HTTP version
+	 *
+	 * @param string $version
+	 *
+	 * @return static
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the HTTP version isn't valid.
+	 */
+	public function withProtocolVersion($version): MessageInterface
+	{
+		$clone = clone $this;
+		$clone->setProtocolVersion($version);
+
+		return $clone;
+	}
+
+	/**
+	 * Gets the message headers
+	 *
+	 * @return array<string, list<string>>
+	 */
+	public function getHeaders(): array
+	{
+		return $this->headers;
+	}
+
+	/**
+	 * Checks if a header exists in the message by the given name
+	 *
+	 * @param string $name
+	 *
+	 * @return bool
+	 */
+	public function hasHeader($name): bool
+	{
+		$key = strtolower($name);
+
+		return isset($this->headerNames[$key]);
+	}
+
+	/**
+	 * Gets a header value from the message by the given name
+	 *
+	 * @param string $name
+	 *
+	 * @return list<string>
+	 */
+	public function getHeader($name): array
+	{
+		$key = strtolower($name);
+
+		if (empty($this->headerNames[$key])) {
+			return [];
+		}
+
+		return $this->headers[$this->headerNames[$key]];
+	}
+
+	/**
+	 * Gets a header value as a string from the message by the given name
+	 *
+	 * @param string $name
+	 *
+	 * @return string
+	 */
+	public function getHeaderLine($name): string
+	{
+		$value = $this->getHeader($name);
+		if ([] === $value) {
+			return '';
+		}
+
+		return implode(',', $value);
+	}
+
+	/**
+	 * Creates a new instance of the message with the given header overwriting the old header
+	 *
+	 * @param string $name
+	 * @param string|string[] $value
+	 *
+	 * @return static
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the header isn't valid.
+	 */
+	public function withHeader($name, $value): MessageInterface
+	{
+		$clone = clone $this;
+		$clone->setHeader($name, $value, true);
+
+		return $clone;
+	}
+
+	/**
+	 * Creates a new instance of the message with the given header NOT overwriting the old header
+	 *
+	 * @param string $name
+	 * @param string|string[] $value
+	 *
+	 * @return static
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the header isn't valid.
+	 */
+	public function withAddedHeader($name, $value): MessageInterface
+	{
+		$clone = clone $this;
+		$clone->setHeader($name, $value, false);
+
+		return $clone;
+	}
+
+	/**
+	 * Creates a new instance of the message without a header by the given name
+	 *
+	 * @param string $name
+	 *
+	 * @return static
+	 */
+	public function withoutHeader($name): MessageInterface
+	{
+		$clone = clone $this;
+		$clone->deleteHeader($name);
+
+		return $clone;
+	}
+
+	/**
+	 * Gets the message body
+	 *
+	 * @return StreamInterface
+	 */
+	public function getBody(): StreamInterface
+	{
+		return $this->body ??= new PhpTempStream();
+	}
+
+	/**
+	 * Creates a new instance of the message with the given body
+	 *
+	 * @param StreamInterface $body
+	 *
+	 * @return static
+	 */
+	public function withBody(StreamInterface $body): MessageInterface
+	{
+		$clone = clone $this;
+		$clone->setBody($body);
+
+		return $clone;
+	}
+
+	/**
+	 * Sets the given HTTP version to the message
+	 *
+	 * @param string $protocolVersion
+	 *
+	 * @return void
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the HTTP version isn't valid.
+	 */
+	final protected function setProtocolVersion($protocolVersion): void
+	{
+		$this->validateProtocolVersion($protocolVersion);
+
+		$this->protocolVersion = $protocolVersion;
+	}
+
+	/**
+	 * Sets a new header to the message with the given name and value(s)
+	 *
+	 * @param string $name
+	 * @param string|string[] $value
+	 * @param bool $replace
+	 *
+	 * @return void
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the header isn't valid.
+	 */
+	final protected function setHeader($name, $value, bool $replace = true): void
+	{
+		if (!is_array($value)) {
+			$value = [$value];
+		}
+
+		$this->validateHeaderName($name);
+		$this->validateHeaderValue($name, $value);
+
+		if ($replace) {
+			$this->deleteHeader($name);
+		}
+
+		$key = strtolower($name);
+
+		$this->headerNames[$key] ??= $name;
+		$this->headers[$this->headerNames[$key]] ??= [];
+
+		foreach ($value as $item) {
+			$this->headers[$this->headerNames[$key]][] = $item;
+		}
+	}
+
+	/**
+	 * Sets the given headers to the message
+	 *
+	 * @param array<string, string|string[]> $headers
+	 *
+	 * @return void
+	 *
+	 * @throws InvalidArgumentException
+	 *         If one of the headers isn't valid.
+	 */
+	final protected function setHeaders(array $headers): void
+	{
+		foreach ($headers as $name => $value) {
+			$this->setHeader($name, $value, false);
+		}
+	}
+
+	/**
+	 * Deletes a header from the message by the given name
+	 *
+	 * @param string $name
+	 *
+	 * @return void
+	 */
+	final protected function deleteHeader($name): void
+	{
+		$key = strtolower($name);
+
+		if (isset($this->headerNames[$key])) {
+			unset($this->headers[$this->headerNames[$key]]);
+			unset($this->headerNames[$key]);
+		}
+	}
+
+	/**
+	 * Sets the given body to the message
+	 *
+	 * @param StreamInterface $body
+	 *
+	 * @return void
+	 */
+	final protected function setBody(StreamInterface $body): void
+	{
+		$this->body = $body;
+	}
+
+	/**
+	 * Validates the given HTTP version
+	 *
+	 * @param mixed $protocolVersion
+	 *
+	 * @return void
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the HTTP version isn't valid.
+	 */
+	private function validateProtocolVersion($protocolVersion): void
+	{
+		if (!in_array($protocolVersion, self::SUPPORTED_HTTP_VERSIONS, true)) {
+			throw new InvalidArgumentException('Invalid or unsupported HTTP version');
+		}
+	}
+
+	/**
+	 * Validates the given header name
+	 *
+	 * @param mixed $name
+	 *
+	 * @return void
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the header name isn't valid.
+	 */
+	private function validateHeaderName($name): void
+	{
+		if ($name === '') {
+			throw new InvalidArgumentException('HTTP header name cannot be an empty');
+		}
+
+		if (!is_string($name)) {
+			throw new InvalidArgumentException('HTTP header name must be a string');
+		}
+
+		if (!preg_match(HeaderInterface::RFC7230_TOKEN_REGEX, $name)) {
+			throw new InvalidArgumentException('HTTP header name is invalid');
+		}
+	}
+
+	/**
+	 * Validates the given header value
+	 *
+	 * @param string $name
+	 * @param array $value
+	 *
+	 * @return void
+	 *
+	 * @throws InvalidArgumentException
+	 *         If the header value isn't valid.
+	 */
+	private function validateHeaderValue(string $name, array $value): void
+	{
+		if ([] === $value) {
+			throw new InvalidArgumentException(sprintf(
+				'The "%s" HTTP header value cannot be an empty array',
+				$name,
+			));
+		}
+
+		foreach ($value as $key => $item) {
+			if ('' === $item) {
+				continue;
+			}
+
+			if (!is_string($item)) {
+				throw new InvalidArgumentException(sprintf(
+					'The "%s[%s]" HTTP header value must be a string',
+					$name,
+					$key
+				));
+			}
+
+			if (!preg_match(HeaderInterface::RFC7230_FIELD_VALUE_REGEX, $item)) {
+				throw new InvalidArgumentException(sprintf(
+					'The "%s[%s]" HTTP header value is invalid',
+					$name,
+					$key
+				));
+			}
+		}
+	}
 }

functions/server_request_files.php

Indentation +46 added lines, -46 removed lines

@@ -43,56 +43,56 @@
  */
 function server_request_files(?array $files = null): array
 {
-    $files ??= $_FILES;
+	$files ??= $_FILES;
 
-    $walker = function (
-        $path,
-        $size,
-        $error,
-        $name,
-        $type
-    ) use (&$walker) {
-        if (!is_array($path)) {
-            // It makes no sense to create a stream if the file has not been successfully uploaded.
-            $stream = UPLOAD_ERR_OK <> $error ? null : new FileStream($path, 'rb');
+	$walker = function (
+		$path,
+		$size,
+		$error,
+		$name,
+		$type
+	) use (&$walker) {
+		if (!is_array($path)) {
+			// It makes no sense to create a stream if the file has not been successfully uploaded.
+			$stream = UPLOAD_ERR_OK <> $error ? null : new FileStream($path, 'rb');
 
-            return new UploadedFile(
-                $stream,
-                $size,
-                $error,
-                $name,
-                $type
-            );
-        }
+			return new UploadedFile(
+				$stream,
+				$size,
+				$error,
+				$name,
+				$type
+			);
+		}
 
-        $result = [];
-        foreach ($path as $key => $_) {
-            if (UPLOAD_ERR_NO_FILE <> $error[$key]) {
-                $result[$key] = $walker(
-                    $path[$key],
-                    $size[$key],
-                    $error[$key],
-                    $name[$key],
-                    $type[$key]
-                );
-            }
-        }
+		$result = [];
+		foreach ($path as $key => $_) {
+			if (UPLOAD_ERR_NO_FILE <> $error[$key]) {
+				$result[$key] = $walker(
+					$path[$key],
+					$size[$key],
+					$error[$key],
+					$name[$key],
+					$type[$key]
+				);
+			}
+		}
 
-        return $result;
-    };
+		return $result;
+	};
 
-    $result = [];
-    foreach ($files as $key => $file) {
-        if (UPLOAD_ERR_NO_FILE <> $file['error']) {
-            $result[$key] = $walker(
-                $file['tmp_name'],
-                $file['size'],
-                $file['error'],
-                $file['name'],
-                $file['type']
-            );
-        }
-    }
+	$result = [];
+	foreach ($files as $key => $file) {
+		if (UPLOAD_ERR_NO_FILE <> $file['error']) {
+			$result[$key] = $walker(
+				$file['tmp_name'],
+				$file['size'],
+				$file['error'],
+				$file['name'],
+				$file['type']
+			);
+		}
+	}
 
-    return $result;
+	return $result;
 }

Spacing +1 added lines, -1 removed lines

@@ -45,7 +45,7 @@
 {
     $files ??= $_FILES;
 
-    $walker = function (
+    $walker = function(
         $path,
         $size,
         $error,