ServerRequestFactory::getUploadedFilesArray() - Code Metrics - Inspection of "Raise packages version:`yiisoft/log` to `^2.0`, `y..." - yiisoft/yii-runner-http - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( e68ccc...280aab )

by Rustam

created 2022-06-17 15:12 UTC

ServerRequestFactory::getUploadedFilesArray() A

↳ Parent: ServerRequestFactory

Complexity

Conditions	2
Paths	2

Size

Total Lines	18
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	2
eloc	11
c	1
b	0
f	1
nc	2
nop	1
dl	0
loc	18
ccs	12
cts	12
cp	1
crap	2
rs	9.9

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Runner\Http;

use InvalidArgumentException;
use Psr\Http\Message\ServerRequestFactoryInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\StreamFactoryInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Message\UploadedFileFactoryInterface;
use Psr\Http\Message\UriFactoryInterface;
use Psr\Http\Message\UriInterface;
use RuntimeException;

use function array_key_exists;
use function explode;
use function fopen;
use function function_exists;
use function getallheaders;
use function is_array;
use function is_resource;
use function is_string;
use function preg_match;
use function str_replace;
use function strncmp;
use function strtolower;
use function substr;
use function ucwords;

/**
 * `ServerRequestFactory` creates an instance of a server request.
 */
final class ServerRequestFactory
{
    private ServerRequestFactoryInterface $serverRequestFactory;
    private UriFactoryInterface $uriFactory;
    private UploadedFileFactoryInterface $uploadedFileFactory;
    private StreamFactoryInterface $streamFactory;

    public function __construct(
        ServerRequestFactoryInterface $serverRequestFactory,
        UriFactoryInterface $uriFactory,
        UploadedFileFactoryInterface $uploadedFileFactory,
        StreamFactoryInterface $streamFactory
    ) {
        $this->serverRequestFactory = $serverRequestFactory;
        $this->uriFactory = $uriFactory;
        $this->uploadedFileFactory = $uploadedFileFactory;
        $this->streamFactory = $streamFactory;
    }

    /**
     * Creates an instance of a server request from PHP superglobals.
     *
     * @return ServerRequestInterface The server request instance.
     */
    public function createFromGlobals(): ServerRequestInterface
    {
        /** @psalm-var array<string, string> $_SERVER */
        return $this->createFromParameters(
            $_SERVER,
            $this->getHeadersFromGlobals(),
            $_COOKIE,
            $_GET,
            $_POST,
            $_FILES,
            fopen('php://input', 'rb') ?: null
        );
    }

    /**
     * Creates an instance of a server request from custom parameters.
     *
     * @param array $server
     * @param array $headers
     * @param array $cookies
     * @param array $get
     * @param array $post
     * @param array $files
     * @param resource|StreamInterface|string|null $body
     *
     * @psalm-param array<string, string> $server
     * @psalm-param array<string, string|string[]> $headers
     * @psalm-param mixed $body
     *
     * @return ServerRequestInterface The server request instance.
     */
    public function createFromParameters(
        array $server,
        array $headers = [],
        array $cookies = [],
        array $get = [],
        array $post = [],
        array $files = [],
        mixed $body = null
    ): ServerRequestInterface {
        $method = $server['REQUEST_METHOD'] ?? null;

        if ($method === null) {
            throw new RuntimeException('Unable to determine HTTP request method.');
        }

        $uri = $this->getUri($server);
        $request = $this->serverRequestFactory->createServerRequest($method, $uri, $server);

        foreach ($headers as $name => $value) {
            if ($name === 'Host' && $request->hasHeader('Host')) {
                continue;
            }

            $request = $request->withAddedHeader($name, $value);
        }

        $protocol = '1.1';
        if (array_key_exists('SERVER_PROTOCOL', $server) && $server['SERVER_PROTOCOL'] !== '') {
            $protocol = str_replace('HTTP/', '', $server['SERVER_PROTOCOL']);
        }

        $request = $request
            ->withProtocolVersion($protocol)
            ->withQueryParams($get)
            ->withParsedBody($post)
            ->withCookieParams($cookies)
            ->withUploadedFiles($this->getUploadedFilesArray($files))
        ;

        if ($body === null) {
            return $request;
        }

        if ($body instanceof StreamInterface) {
            return $request->withBody($body);
        }

        if (is_string($body)) {
            return $request->withBody($this->streamFactory->createStream($body));
        }

        if (is_resource($body)) {
            return $request->withBody($this->streamFactory->createStreamFromResource($body));
        }

        throw new InvalidArgumentException(
            'Body parameter for "ServerRequestFactory::createFromParameters()"'
            . 'must be instance of StreamInterface, resource or null.',
        );
    }

    /**
     * @psalm-param array<string, string> $server
     */
    private function getUri(array $server): UriInterface
    {
        $uri = $this->uriFactory->createUri();

        if (array_key_exists('HTTPS', $server) && $server['HTTPS'] !== '' && $server['HTTPS'] !== 'off') {
            $uri = $uri->withScheme('https');
        } else {
            $uri = $uri->withScheme('http');
        }

        $uri = isset($server['SERVER_PORT'])
            ? $uri->withPort((int)$server['SERVER_PORT'])
            : $uri->withPort($uri->getScheme() === 'https' ? 443 : 80);

        if (isset($server['HTTP_HOST'])) {
            $uri = preg_match('/^(.+):(\d+)$/', $server['HTTP_HOST'], $matches) === 1
                ? $uri
                    ->withHost($matches[1])
                    ->withPort((int) $matches[2])
                : $uri->withHost($server['HTTP_HOST'])
            ;
        } elseif (isset($server['SERVER_NAME'])) {
            $uri = $uri->withHost($server['SERVER_NAME']);
        }

        if (isset($server['REQUEST_URI'])) {
            $uri = $uri->withPath(explode('?', $server['REQUEST_URI'])[0]);
        }

        if (isset($server['QUERY_STRING'])) {
            $uri = $uri->withQuery($server['QUERY_STRING']);
        }

        return $uri;
    }

    /**
     * @psalm-return array<string, string>
     */
    private function getHeadersFromGlobals(): array
    {
        if (function_exists('getallheaders') && ($headers = getallheaders()) !== false) {
            /** @psalm-var array<string, string> $headers */
            return $headers;

        }

        $headers = [];

        /**
         * @var string $name
         * @var string $value
         */
        foreach ($_SERVER as $name => $value) {
            if (strncmp($name, 'REDIRECT_', 9) === 0) {
                $name = substr($name, 9);

                if (array_key_exists($name, $_SERVER)) {
                    continue;
                }
            }

            if (strncmp($name, 'HTTP_', 5) === 0) {
                $headers[$this->normalizeHeaderName(substr($name, 5))] = $value;
                continue;
            }

            if (strncmp($name, 'CONTENT_', 8) === 0) {
                $headers[$this->normalizeHeaderName($name)] = $value;
            }
        }

        return $headers;
    }

    private function normalizeHeaderName(string $name): string
    {
        return str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', $name))));
    }

    private function getUploadedFilesArray(array $filesArray): array
    {
        $files = [];

        /** @var array $info */
        foreach ($filesArray as $class => $info) {
            $files[$class] = [];
            $this->populateUploadedFileRecursive(
                $files[$class],
                $info['name'],
                $info['tmp_name'],
                $info['type'],
                $info['size'],
                $info['error'],
            );
        }

        return $files;
    }

    /**
     * Populates uploaded files array from $_FILE data structure recursively.
     *
     * @param array $files Uploaded files array to be populated.
     * @param mixed $names File names provided by PHP.
     * @param mixed $tempNames Temporary file names provided by PHP.
     * @param mixed $types File types provided by PHP.
     * @param mixed $sizes File sizes provided by PHP.
     * @param mixed $errors Uploading issues provided by PHP.
     *
     * @psalm-suppress MixedArgument, ReferenceConstraintViolation
     */
    private function populateUploadedFileRecursive(
        array &$files,
        mixed $names,
        mixed $tempNames,
        mixed $types,
        mixed $sizes,
        mixed $errors
    ): void {
        if (is_array($names)) {
            /** @var array|string $name */
            foreach ($names as $i => $name) {
                $files[$i] = [];
                /** @psalm-suppress MixedArrayAccess */
                $this->populateUploadedFileRecursive(
                    $files[$i],
                    $name,
                    $tempNames[$i],
                    $types[$i],
                    $sizes[$i],
                    $errors[$i],
                );
            }

            return;
        }

        try {
            $stream = $this->streamFactory->createStreamFromFile($tempNames);
        } catch (RuntimeException $e) {
            $stream = $this->streamFactory->createStream();
        }

        $files = $this->uploadedFileFactory->createUploadedFile(
            $stream,
            (int) $sizes,
            (int) $errors,
            $names,
            $types
        );
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Yii\Runner\Http;
6
7		use InvalidArgumentException;
8		use Psr\Http\Message\ServerRequestFactoryInterface;
9		use Psr\Http\Message\ServerRequestInterface;
10		use Psr\Http\Message\StreamFactoryInterface;
11		use Psr\Http\Message\StreamInterface;
12		use Psr\Http\Message\UploadedFileFactoryInterface;
13		use Psr\Http\Message\UriFactoryInterface;
14		use Psr\Http\Message\UriInterface;
15		use RuntimeException;
16
17		use function array_key_exists;
18		use function explode;
19		use function fopen;
20		use function function_exists;
21		use function getallheaders;
22		use function is_array;
23		use function is_resource;
24		use function is_string;
25		use function preg_match;
26		use function str_replace;
27		use function strncmp;
28		use function strtolower;
29		use function substr;
30		use function ucwords;
31
32		/**
33		* `ServerRequestFactory` creates an instance of a server request.
34		*/
35		final class ServerRequestFactory
36		{
37		private ServerRequestFactoryInterface $serverRequestFactory;
38		private UriFactoryInterface $uriFactory;
39		private UploadedFileFactoryInterface $uploadedFileFactory;
40		private StreamFactoryInterface $streamFactory;
41
42	50	public function __construct(
43		ServerRequestFactoryInterface $serverRequestFactory,
44		UriFactoryInterface $uriFactory,
45		UploadedFileFactoryInterface $uploadedFileFactory,
46		StreamFactoryInterface $streamFactory
47		) {
48	50	$this->serverRequestFactory = $serverRequestFactory;
49	50	$this->uriFactory = $uriFactory;
50	50	$this->uploadedFileFactory = $uploadedFileFactory;
51	50	$this->streamFactory = $streamFactory;
52		}
53
54		/**
55		* Creates an instance of a server request from PHP superglobals.
56		*
57		* @return ServerRequestInterface The server request instance.
58		*/
59	22	public function createFromGlobals(): ServerRequestInterface
60		{
61		/** @psalm-var array<string, string> $_SERVER */
62	22	return $this->createFromParameters(
63		$_SERVER,
64	22	$this->getHeadersFromGlobals(),
65		$_COOKIE,
66		$_GET,
67		$_POST,
68		$_FILES,
69	22	fopen('php://input', 'rb') ?: null
70		);
71		}
72
73		/**
74		* Creates an instance of a server request from custom parameters.
75		*
76		* @param array $server
77		* @param array $headers
78		* @param array $cookies
79		* @param array $get
80		* @param array $post
81		* @param array $files
82		* @param resource\|StreamInterface\|string\|null $body
83		*
84		* @psalm-param array<string, string> $server
85		* @psalm-param array<string, string\|string[]> $headers
86		* @psalm-param mixed $body
87		*
88		* @return ServerRequestInterface The server request instance.
89		*/
90	50	public function createFromParameters(
91		array $server,
92		array $headers = [],
93		array $cookies = [],
94		array $get = [],
95		array $post = [],
96		array $files = [],
97		mixed $body = null
98		): ServerRequestInterface {
99	50	$method = $server['REQUEST_METHOD'] ?? null;
100
101	50	if ($method === null) {
102	1	throw new RuntimeException('Unable to determine HTTP request method.');
103		}
104
105	49	$uri = $this->getUri($server);
106	49	$request = $this->serverRequestFactory->createServerRequest($method, $uri, $server);
107
108	49	foreach ($headers as $name => $value) {
109	13	if ($name === 'Host' && $request->hasHeader('Host')) {
110	13	continue;
111		}
112
113	1	$request = $request->withAddedHeader($name, $value);
114		}
115
116	49	$protocol = '1.1';
117	49	if (array_key_exists('SERVER_PROTOCOL', $server) && $server['SERVER_PROTOCOL'] !== '') {
118	2	$protocol = str_replace('HTTP/', '', $server['SERVER_PROTOCOL']);
119		}
120
121	49	$request = $request
122	49	->withProtocolVersion($protocol)
123	49	->withQueryParams($get)
124	49	->withParsedBody($post)
125	49	->withCookieParams($cookies)
126	49	->withUploadedFiles($this->getUploadedFilesArray($files))
127		;
128
129	49	if ($body === null) {
130	17	return $request;
131		}
132
133	32	if ($body instanceof StreamInterface) {
134	1	return $request->withBody($body);
135		}
136
137	31	if (is_string($body)) {
138	1	return $request->withBody($this->streamFactory->createStream($body));
139		}
140
141	30	if (is_resource($body)) {
142	23	return $request->withBody($this->streamFactory->createStreamFromResource($body));
143		}
144
145	7	throw new InvalidArgumentException(
146		'Body parameter for "ServerRequestFactory::createFromParameters()"'
147		. 'must be instance of StreamInterface, resource or null.',
148		);
149		}
150
151		/**
152		* @psalm-param array<string, string> $server
153		*/
154	49	private function getUri(array $server): UriInterface
155		{
156	49	$uri = $this->uriFactory->createUri();
157
158	49	if (array_key_exists('HTTPS', $server) && $server['HTTPS'] !== '' && $server['HTTPS'] !== 'off') {
159	4	$uri = $uri->withScheme('https');
160		} else {
161	45	$uri = $uri->withScheme('http');
162		}
163
164	49	$uri = isset($server['SERVER_PORT'])
165	2	? $uri->withPort((int)$server['SERVER_PORT'])
166	47	: $uri->withPort($uri->getScheme() === 'https' ? 443 : 80);
167
168	49	if (isset($server['HTTP_HOST'])) {
169	20	$uri = preg_match('/^(.+):(\d+)$/', $server['HTTP_HOST'], $matches) === 1
170		? $uri
171	6	->withHost($matches[1])
172	6	->withPort((int) $matches[2])
173	14	: $uri->withHost($server['HTTP_HOST'])
174		;
175	29	} elseif (isset($server['SERVER_NAME'])) {
176	2	$uri = $uri->withHost($server['SERVER_NAME']);
177		}
178
179	49	if (isset($server['REQUEST_URI'])) {
180	2	$uri = $uri->withPath(explode('?', $server['REQUEST_URI'])[0]);
181		}
182
183	49	if (isset($server['QUERY_STRING'])) {
184	2	$uri = $uri->withQuery($server['QUERY_STRING']);
185		}
186
187	49	return $uri;
188		}
189
190		/**
191		* @psalm-return array<string, string>
192		*/
193	22	private function getHeadersFromGlobals(): array
194		{
195	22	if (function_exists('getallheaders') && ($headers = getallheaders()) !== false) {
196		/** @psalm-var array<string, string> $headers */
197		return $headers;
		0 ignored issues – show Bug Best Practice introduced 2021-11-10 23:06 UTC by Report Bug Copy Issue Report The expression `return $headers` could return the type `true` which is incompatible with the type-hinted return `array`. Consider adding an additional type-check to rule them out. Loading history...
198		}
199
200	22	$headers = [];
201
202		/**
203		* @var string $name
204		* @var string $value
205		*/
206	22	foreach ($_SERVER as $name => $value) {
207	22	if (strncmp($name, 'REDIRECT_', 9) === 0) {
208	1	$name = substr($name, 9);
209
210	1	if (array_key_exists($name, $_SERVER)) {
211	1	continue;
212		}
213		}
214
215	22	if (strncmp($name, 'HTTP_', 5) === 0) {
216	13	$headers[$this->normalizeHeaderName(substr($name, 5))] = $value;
217	13	continue;
218		}
219
220	22	if (strncmp($name, 'CONTENT_', 8) === 0) {
221	1	$headers[$this->normalizeHeaderName($name)] = $value;
222		}
223		}
224
225	22	return $headers;
226		}
227
228	13	private function normalizeHeaderName(string $name): string
229		{
230	13	return str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', $name))));
231		}
232
233	49	private function getUploadedFilesArray(array $filesArray): array
234		{
235	49	$files = [];
236
237		/** @var array $info */
238	49	foreach ($filesArray as $class => $info) {
239	5	$files[$class] = [];
240	5	$this->populateUploadedFileRecursive(
241	5	$files[$class],
242	5	$info['name'],
243	5	$info['tmp_name'],
244	5	$info['type'],
245	5	$info['size'],
246	5	$info['error'],
247		);
248		}
249
250	49	return $files;
251		}
252
253		/**
254		* Populates uploaded files array from $_FILE data structure recursively.
255		*
256		* @param array $files Uploaded files array to be populated.
257		* @param mixed $names File names provided by PHP.
258		* @param mixed $tempNames Temporary file names provided by PHP.
259		* @param mixed $types File types provided by PHP.
260		* @param mixed $sizes File sizes provided by PHP.
261		* @param mixed $errors Uploading issues provided by PHP.
262		*
263		* @psalm-suppress MixedArgument, ReferenceConstraintViolation
264		*/
265	5	private function populateUploadedFileRecursive(
266		array &$files,
267		mixed $names,
268		mixed $tempNames,
269		mixed $types,
270		mixed $sizes,
271		mixed $errors
272		): void {
273	5	if (is_array($names)) {
274		/** @var array\|string $name */
275	5	foreach ($names as $i => $name) {
276	5	$files[$i] = [];
277		/** @psalm-suppress MixedArrayAccess */
278	5	$this->populateUploadedFileRecursive(
279	5	$files[$i],
280		$name,
281	5	$tempNames[$i],
282	5	$types[$i],
283	5	$sizes[$i],
284	5	$errors[$i],
285		);
286		}
287
288	5	return;
289		}
290
291		try {
292	5	$stream = $this->streamFactory->createStreamFromFile($tempNames);
293	5	} catch (RuntimeException $e) {
294	5	$stream = $this->streamFactory->createStream();
295		}
296
297	5	$files = $this->uploadedFileFactory->createUploadedFile(
298		$stream,
299	5	(int) $sizes,
300	5	(int) $errors,
301		$names,
302		$types
303		);
304		}
305		}
306

yiisoft / yii-runner-http

Push — master ( e68ccc...280aab )

ServerRequestFactory::getUploadedFilesArray() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like