Request::set() - Code Metrics - Inspection of "Rename Request::attribute to ::get, add ::set" - coniadev/chuck - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( ed64d2...c44892 )

by Thomas

created 2023-01-22 13:51 UTC

Request::set() A

↳ Parent: Request

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
eloc	2
c	0
b	0
f	0
dl	0
loc	5
ccs	3
cts	3
cp	1
rs	10
cc	1
nc	1
nop	2
crap	1

<?php

declare(strict_types=1);

namespace Conia\Chuck;

use Conia\Chuck\Exception\OutOfBoundsException;
use Conia\Chuck\Exception\RuntimeException;
use Conia\Chuck\Http\WrapsMessage;
use Conia\Chuck\Http\WrapsRequest;
use Psr\Http\Message\ServerRequestInterface as PsrServerRequest;
use Psr\Http\Message\StreamInterface as PsrStream;
use Psr\Http\Message\UploadedFileInterface as PsrUploadedFile;
use Psr\Http\Message\UriInterface as PsrUri;
use Throwable;

class Request
{
    use WrapsMessage;
    use WrapsRequest;

    public function __construct(protected PsrServerRequest $psr)
    {
    }

    public function psr(): PsrServerRequest
    {
        return $this->psr;
    }

    public function setPsr(PsrServerRequest $psr): static
    {
        $this->psr = $psr;

        return $this;
    }

    public function params(): array
    {
        return $this->psr->getQueryParams();
    }

    public function param(string $key, mixed $default = null): mixed
    {
        $params = $this->psr->getQueryParams();
        $error = 'Query string variable not found';

        return $this->returnOrFail($params, $key, $default, $error, func_num_args());
    }

    public function form(): ?array
    {
        $body = $this->psr->getParsedBody();
        assert(is_null($body) || is_array($body));

        return $body;
    }

    public function field(string $key, mixed $default = null): mixed
    {
        $body = $this->psr->getParsedBody();
        assert(is_null($body) || is_array($body));
        $error = 'Form field not found';

        return $this->returnOrFail($body, $key, $default, $error, func_num_args());
    }

    public function cookies(): array
    {
        return $this->psr->getCookieParams();
    }

    public function cookie(string $key, mixed $default = null): mixed
    {
        $params = $this->psr->getCookieParams();
        $error = 'Cookie not found';

        return $this->returnOrFail($params, $key, $default, $error, func_num_args());
    }

    public function serverParams(): array
    {
        return $this->psr->getServerParams();
    }

    public function server(string $key, mixed $default = null): mixed
    {
        $params = $this->psr->getServerParams();
        $error = 'Server parameter not found';

        return $this->returnOrFail($params, $key, $default, $error, func_num_args());
    }

    public function header(string $name): string
    {
        return $this->psr->getHeaderLine($name);
    }

    public function accept(): array
    {
        return explode(',', $this->getHeaderLine('Accept'));
    }

    public function attributes(): array
    {
        return $this->psr->getAttributes();
    }

    public function set(string $attribute, mixed $value): static
    {
        $this->psr = $this->psr->withAttribute($attribute, $value);

        return $this;
    }

    public function get(string $key, mixed $default = null): mixed
    {
        $params = $this->psr->getAttributes();
        $error = 'Request attribute not found';

        return $this->returnOrFail($params, $key, $default, $error, func_num_args());
    }

    public function uri(): PsrUri
    {
        return $this->psr->getUri();
    }

    public function origin(): string
    {
        $uri = $this->psr->getUri();
        $scheme = $uri->getScheme();
        $origin = $scheme ? $scheme . ':' : '';
        $authority = $uri->getAuthority();
        $origin .= $authority ? '//' . $authority : '';

        return $origin;
    }

    public function method(): string
    {
        return strtoupper($this->psr->getMethod());
    }

    public function isMethod(string $method): bool
    {
        return strtoupper($method) === $this->method();
    }

    public function body(): PsrStream
    {
        return $this->psr->getBody();
    }

    public function json(
        int $flags = JSON_OBJECT_AS_ARRAY,
    ): mixed {
        $body = (string)$this->psr->getBody();

        return json_decode(
            $body,
            true,
            512, // PHP default value
            $flags,
        );
    }

    /**
     * Returns always a list of uploaded files, even if there is
     * only one file.
     *
     * Psalm does not support multi file uploads yet and complains
     * about type issues. We need to suppres some of the errors.
     *
     * @no-named-arguments
     *
     * @psalm-param list<string>|string ...$keys
     *
     * @throws OutOfBoundsException RuntimeException
     */
    public function files(array|string ...$keys): array
    {
        $files = $this->psr->getUploadedFiles();
        $keys = $this->validateKeys($keys);

        if (count($keys) === 0) {
            return $files;
        }

        try {
            foreach ($keys as $key) {
                /**
                 * @psalm-suppress MixedAssignment, MixedArrayAccess
                 *
                 * Psalm does not support recursive types like:
                 *     T = array<string, string|T>
                 */
                $files = $files[$key];
            }
        } catch (Throwable) {
            throw new OutOfBoundsException('Invalid files key ' . $this->formatKeys($keys));
        }

        if ($files instanceof PsrUploadedFile) {
            return [$files];
        }

        assert(is_array($files));

        return $files;
    }

    /**
     * Returns always a list of uploaded files, even if there is
     * only one file.
     *
     * Psalm does not support multi file uploads yet and complains
     * about type issues. We need to suppres some of the errors.
     *
     * @no-named-arguments
     *
     * @psalm-param list<non-empty-string>|string ...$keys
     *
     * @return PsrUploadedFile
     *
     * @throws OutOfBoundsException RuntimeException
     */
    public function file(array|string ...$keys): PsrUploadedFile|array
    {
        $keys = $this->validateKeys($keys);

        if (count($keys) === 0) {
            throw new RuntimeException('No file key given');
        }

        $files = $this->psr->getUploadedFiles();
        $i = 0;

        foreach ($keys as $key) {
            if (isset($files[$key])) {
                /** @var array|PsrUploadedFile */
                $files = $files[$key];
                $i++;

                if ($files instanceof PsrUploadedFile) {
                    if ($i < count($keys)) {
                        throw new OutOfBoundsException(
                            'Invalid file key (too deep) ' . $this->formatKeys($keys)
                        );
                    }

                    return $files;
                }
            } else {
                throw new OutOfBoundsException('Invalid file key ' . $this->formatKeys($keys));
            }
        }

        throw new RuntimeException('Multiple files available at key ' . $this->formatKeys($keys));
    }

    private function returnOrFail(
        array|null $array,
        string $key,
        mixed $default,
        string $error,
        int $numArgs
    ): mixed {
        try {
            if ((is_null($array) || !isset($array[$key])) && $numArgs > 1) {
                return $default;
            }

            assert(!is_null($array));

            return $array[$key];
        } catch (Throwable) {
            throw new OutOfBoundsException("{$error}: '{$key}'");
        }
    }

    /** @psalm-param non-empty-list<string> $keys */
    private function formatKeys(array $keys): string
    {
        return implode('', array_map(
            fn ($key) => "['" . $key . "']",
            $keys
        ));
    }

    /**
     * @psalm-param list<list<string>|string> $keys
     *
     * @psalm-return list<string>
     */
    private function validateKeys(array $keys): array
    {
        if (isset($keys[0]) && is_array($keys[0])) {
            if (count($keys) > 1) {
                throw new RuntimeException('Either provide a single array or plain string arguments');
            }
            $keys = $keys[0];
        }

        /** @psalm-var list<string> */
        return $keys;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Conia\Chuck;
6
7		use Conia\Chuck\Exception\OutOfBoundsException;
8		use Conia\Chuck\Exception\RuntimeException;
9		use Conia\Chuck\Http\WrapsMessage;
10		use Conia\Chuck\Http\WrapsRequest;
11		use Psr\Http\Message\ServerRequestInterface as PsrServerRequest;
12		use Psr\Http\Message\StreamInterface as PsrStream;
13		use Psr\Http\Message\UploadedFileInterface as PsrUploadedFile;
14		use Psr\Http\Message\UriInterface as PsrUri;
15		use Throwable;
16
17		class Request
18		{
19		use WrapsMessage;
20		use WrapsRequest;
21
22	182	public function __construct(protected PsrServerRequest $psr)
23		{
24	182	}
25
26	2	public function psr(): PsrServerRequest
27		{
28	2	return $this->psr;
29		}
30
31	1	public function setPsr(PsrServerRequest $psr): static
32		{
33	1	$this->psr = $psr;
34
35	1	return $this;
36		}
37
38	1	public function params(): array
39		{
40	1	return $this->psr->getQueryParams();
41		}
42
43	3	public function param(string $key, mixed $default = null): mixed
44		{
45	3	$params = $this->psr->getQueryParams();
46	3	$error = 'Query string variable not found';
47
48	3	return $this->returnOrFail($params, $key, $default, $error, func_num_args());
49		}
50
51	1	public function form(): ?array
52		{
53	1	$body = $this->psr->getParsedBody();
54	1	assert(is_null($body) \|\| is_array($body));
55
56	1	return $body;
57		}
58
59	4	public function field(string $key, mixed $default = null): mixed
60		{
61	4	$body = $this->psr->getParsedBody();
62	4	assert(is_null($body) \|\| is_array($body));
63	4	$error = 'Form field not found';
64
65	4	return $this->returnOrFail($body, $key, $default, $error, func_num_args());
66		}
67
68	1	public function cookies(): array
69		{
70	1	return $this->psr->getCookieParams();
71		}
72
73	3	public function cookie(string $key, mixed $default = null): mixed
74		{
75	3	$params = $this->psr->getCookieParams();
76	3	$error = 'Cookie not found';
77
78	3	return $this->returnOrFail($params, $key, $default, $error, func_num_args());
79		}
80
81	1	public function serverParams(): array
82		{
83	1	return $this->psr->getServerParams();
84		}
85
86	3	public function server(string $key, mixed $default = null): mixed
87		{
88	3	$params = $this->psr->getServerParams();
89	3	$error = 'Server parameter not found';
90
91	3	return $this->returnOrFail($params, $key, $default, $error, func_num_args());
92		}
93
94	1	public function header(string $name): string
95		{
96	1	return $this->psr->getHeaderLine($name);
97		}
98
99	9	public function accept(): array
100		{
101	9	return explode(',', $this->getHeaderLine('Accept'));
102		}
103
104	1	public function attributes(): array
105		{
106	1	return $this->psr->getAttributes();
107		}
108
109	1	public function set(string $attribute, mixed $value): static
110		{
111	1	$this->psr = $this->psr->withAttribute($attribute, $value);
112
113	1	return $this;
114		}
115
116	3	public function get(string $key, mixed $default = null): mixed
117		{
118	3	$params = $this->psr->getAttributes();
119	3	$error = 'Request attribute not found';
120
121	3	return $this->returnOrFail($params, $key, $default, $error, func_num_args());
122		}
123
124	62	public function uri(): PsrUri
125		{
126	62	return $this->psr->getUri();
127		}
128
129	1	public function origin(): string
130		{
131	1	$uri = $this->psr->getUri();
132	1	$scheme = $uri->getScheme();
133	1	$origin = $scheme ? $scheme . ':' : '';
134	1	$authority = $uri->getAuthority();
135	1	$origin .= $authority ? '//' . $authority : '';
136
137	1	return $origin;
138		}
139
140	62	public function method(): string
141		{
142	62	return strtoupper($this->psr->getMethod());
143		}
144
145	1	public function isMethod(string $method): bool
146		{
147	1	return strtoupper($method) === $this->method();
148		}
149
150	1	public function body(): PsrStream
151		{
152	1	return $this->psr->getBody();
153		}
154
155	2	public function json(
156		int $flags = JSON_OBJECT_AS_ARRAY,
157		): mixed {
158	2	$body = (string)$this->psr->getBody();
159
160	2	return json_decode(
161	2	$body,
162	2	true,
163	2	512, // PHP default value
164	2	$flags,
165	2	);
166		}
167
168		/**
169		* Returns always a list of uploaded files, even if there is
170		* only one file.
171		*
172		* Psalm does not support multi file uploads yet and complains
173		* about type issues. We need to suppres some of the errors.
174		*
175		* @no-named-arguments
176		*
177		* @psalm-param list<string>\|string ...$keys
178		*
179		* @throws OutOfBoundsException RuntimeException
180		*/
181	8	public function files(array\|string ...$keys): array
182		{
183	8	$files = $this->psr->getUploadedFiles();
184	8	$keys = $this->validateKeys($keys);
185
186	7	if (count($keys) === 0) {
187	1	return $files;
188		}
189
190		try {
191	6	foreach ($keys as $key) {
192		/**
193		* @psalm-suppress MixedAssignment, MixedArrayAccess
194		*
195		* Psalm does not support recursive types like:
196		* T = array<string, string\|T>
197		*/
198	6	$files = $files[$key];
199		}
200	2	} catch (Throwable) {
201	2	throw new OutOfBoundsException('Invalid files key ' . $this->formatKeys($keys));
202		}
203
204	4	if ($files instanceof PsrUploadedFile) {
205	1	return [$files];
206		}
207
208	3	assert(is_array($files));
209
210	3	return $files;
211		}
212
213		/**
214		* Returns always a list of uploaded files, even if there is
215		* only one file.
216		*
217		* Psalm does not support multi file uploads yet and complains
218		* about type issues. We need to suppres some of the errors.
219		*
220		* @no-named-arguments
221		*
222		* @psalm-param list<non-empty-string>\|string ...$keys
223		*
224		* @return PsrUploadedFile
225		*
226		* @throws OutOfBoundsException RuntimeException
227		*/
228	7	public function file(array\|string ...$keys): PsrUploadedFile\|array
229		{
230	7	$keys = $this->validateKeys($keys);
231
232	7	if (count($keys) === 0) {
233	1	throw new RuntimeException('No file key given');
234		}
235
236	6	$files = $this->psr->getUploadedFiles();
237	6	$i = 0;
238
239	6	foreach ($keys as $key) {
240	6	if (isset($files[$key])) {
241		/** @var array\|PsrUploadedFile */
242	4	$files = $files[$key];
243	4	$i++;
244
245	4	if ($files instanceof PsrUploadedFile) {
246	3	if ($i < count($keys)) {
247	1	throw new OutOfBoundsException(
248	1	'Invalid file key (too deep) ' . $this->formatKeys($keys)
249	1	);
250		}
251
252	4	return $files;
253		}
254		} else {
255	2	throw new OutOfBoundsException('Invalid file key ' . $this->formatKeys($keys));
256		}
257		}
258
259	1	throw new RuntimeException('Multiple files available at key ' . $this->formatKeys($keys));
260		}
261
262	16	private function returnOrFail(
263		array\|null $array,
264		string $key,
265		mixed $default,
266		string $error,
267		int $numArgs
268		): mixed {
269		try {
270	16	if ((is_null($array) \|\| !isset($array[$key])) && $numArgs > 1) {
271	6	return $default;
272		}
273
274	10	assert(!is_null($array));
275
276	10	return $array[$key];
277	5	} catch (Throwable) {
278	5	throw new OutOfBoundsException("{$error}: '{$key}'");
279		}
280		}
281
282		/** @psalm-param non-empty-list<string> $keys */
283	6	private function formatKeys(array $keys): string
284		{
285	6	return implode('', array_map(
286	6	fn ($key) => "['" . $key . "']",
287	6	$keys
288	6	));
289		}
290
291		/**
292		* @psalm-param list<list<string>\|string> $keys
293		*
294		* @psalm-return list<string>
295		*/
296	15	private function validateKeys(array $keys): array
297		{
298	15	if (isset($keys[0]) && is_array($keys[0])) {
299	2	if (count($keys) > 1) {
300	1	throw new RuntimeException('Either provide a single array or plain string arguments');
301		}
302	1	$keys = $keys[0];
303		}
304
305		/** @psalm-var list<string> */
306	14	return $keys;
307		}
308		}
309

coniadev / chuck

Push — main ( ed64d2...c44892 )

Request::set() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like