ServerRequest::withQueryParams() - Code Metrics - Inspection of "Add new config options: {{what}} and {{where}}" - deployphp/deployer - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 5cefd1...492078 )

by Anton

created 2024-10-22 06:54 UTC

ServerRequest::withQueryParams() A

↳ Parent: ServerRequest

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	3
nc	1
nop	1
dl	0
loc	5
c	1
b	0
f	0
cc	1
rs	10

<?php

namespace React\Http\Message;

use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Message\UriInterface;
use React\Http\Io\BufferedBody;
use React\Http\Io\HttpBodyStream;
use React\Stream\ReadableStreamInterface;
use RingCentral\Psr7\Request;

/**
 * Respresents an incoming server request message.
 *
 * This class implements the
 * [PSR-7 `ServerRequestInterface`](https://www.php-fig.org/psr/psr-7/#321-psrhttpmessageserverrequestinterface)
 * which extends the
 * [PSR-7 `RequestInterface`](https://www.php-fig.org/psr/psr-7/#32-psrhttpmessagerequestinterface)
 * which in turn extends the
 * [PSR-7 `MessageInterface`](https://www.php-fig.org/psr/psr-7/#31-psrhttpmessagemessageinterface).
 *
 * This is mostly used internally to represent each incoming request message.
 * Likewise, you can also use this class in test cases to test how your web
 * application reacts to certain HTTP requests.
 *
 * > Internally, this implementation builds on top of an existing outgoing
 *   request message and only adds required server methods. This base class is
 *   considered an implementation detail that may change in the future.
 *
 * @see ServerRequestInterface
 */
final class ServerRequest extends Request implements ServerRequestInterface
{
    private $attributes = array();

    private $serverParams;
    private $fileParams = array();
    private $cookies = array();
    private $queryParams = array();
    private $parsedBody;

    /**
     * @param string                                         $method       HTTP method for the request.
     * @param string|UriInterface                            $url          URL for the request.
     * @param array<string,string|string[]>                  $headers      Headers for the message.
     * @param string|ReadableStreamInterface|StreamInterface $body         Message body.
     * @param string                                         $version      HTTP protocol version.
     * @param array<string,string>                           $serverParams server-side parameters
     * @throws \InvalidArgumentException for an invalid URL or body
     */
    public function __construct(
        $method,
        $url,
        array $headers = array(),
        $body = '',
        $version = '1.1',
        $serverParams = array()
    ) {
        $stream = null;
        if (\is_string($body)) {
            $body = new BufferedBody($body);
        } elseif ($body instanceof ReadableStreamInterface && !$body instanceof StreamInterface) {
            $stream = $body;
            $body = null;
        } elseif (!$body instanceof StreamInterface) {

            throw new \InvalidArgumentException('Invalid server request body given');
        }

        $this->serverParams = $serverParams;
        parent::__construct($method, $url, $headers, $body, $version);

        if ($stream !== null) {
            $size = (int) $this->getHeaderLine('Content-Length');
            if (\strtolower($this->getHeaderLine('Transfer-Encoding')) === 'chunked') {
                $size = null;
            }
            $this->stream = new HttpBodyStream($stream, $size);
        }

        $query = $this->getUri()->getQuery();
        if ($query !== '') {
            \parse_str($query, $this->queryParams);
        }

        // Multiple cookie headers are not allowed according
        // to https://tools.ietf.org/html/rfc6265#section-5.4
        $cookieHeaders = $this->getHeader("Cookie");

        if (count($cookieHeaders) === 1) {
            $this->cookies = $this->parseCookie($cookieHeaders[0]);
        }
    }

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

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

    public function withCookieParams(array $cookies)
    {
        $new = clone $this;
        $new->cookies = $cookies;
        return $new;
    }

    public function getQueryParams()
    {
        return $this->queryParams;
    }

    public function withQueryParams(array $query)
    {
        $new = clone $this;
        $new->queryParams = $query;
        return $new;
    }

    public function getUploadedFiles()
    {
        return $this->fileParams;
    }

    public function withUploadedFiles(array $uploadedFiles)
    {
        $new = clone $this;
        $new->fileParams = $uploadedFiles;
        return $new;
    }

    public function getParsedBody()
    {
        return $this->parsedBody;
    }

    public function withParsedBody($data)
    {
        $new = clone $this;
        $new->parsedBody = $data;
        return $new;
    }

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

    public function getAttribute($name, $default = null)
    {
        if (!\array_key_exists($name, $this->attributes)) {
            return $default;
        }
        return $this->attributes[$name];
    }

    public function withAttribute($name, $value)
    {
        $new = clone $this;
        $new->attributes[$name] = $value;
        return $new;
    }

    public function withoutAttribute($name)
    {
        $new = clone $this;
        unset($new->attributes[$name]);
        return $new;
    }

    /**
     * @param string $cookie
     * @return array
     */
    private function parseCookie($cookie)
    {
        $cookieArray = \explode(';', $cookie);
        $result = array();

        foreach ($cookieArray as $pair) {
            $pair = \trim($pair);
            $nameValuePair = \explode('=', $pair, 2);

            if (\count($nameValuePair) === 2) {
                $key = \urldecode($nameValuePair[0]);
                $value = \urldecode($nameValuePair[1]);
                $result[$key] = $value;
            }
        }

        return $result;
    }
}


1			<?php
2
3			namespace React\Http\Message;
4
5			use Psr\Http\Message\ServerRequestInterface;
6			use Psr\Http\Message\StreamInterface;
7			use Psr\Http\Message\UriInterface;
8			use React\Http\Io\BufferedBody;
9			use React\Http\Io\HttpBodyStream;
10			use React\Stream\ReadableStreamInterface;
11			use RingCentral\Psr7\Request;
12
13			/**
14			* Respresents an incoming server request message.
15			*
16			* This class implements the
17			* [PSR-7 `ServerRequestInterface`](https://www.php-fig.org/psr/psr-7/#321-psrhttpmessageserverrequestinterface)
18			* which extends the
19			* [PSR-7 `RequestInterface`](https://www.php-fig.org/psr/psr-7/#32-psrhttpmessagerequestinterface)
20			* which in turn extends the
21			* [PSR-7 `MessageInterface`](https://www.php-fig.org/psr/psr-7/#31-psrhttpmessagemessageinterface).
22			*
23			* This is mostly used internally to represent each incoming request message.
24			* Likewise, you can also use this class in test cases to test how your web
25			* application reacts to certain HTTP requests.
26			*
27			* > Internally, this implementation builds on top of an existing outgoing
28			* request message and only adds required server methods. This base class is
29			* considered an implementation detail that may change in the future.
30			*
31			* @see ServerRequestInterface
32			*/
33			final class ServerRequest extends Request implements ServerRequestInterface
34			{
35			private $attributes = array();
36
37			private $serverParams;
38			private $fileParams = array();
39			private $cookies = array();
40			private $queryParams = array();
41			private $parsedBody;
42
43			/**
44			* @param string $method HTTP method for the request.
45			* @param string\|UriInterface $url URL for the request.
46			* @param array<string,string\|string[]> $headers Headers for the message.
47			* @param string\|ReadableStreamInterface\|StreamInterface $body Message body.
48			* @param string $version HTTP protocol version.
49			* @param array<string,string> $serverParams server-side parameters
50			* @throws \InvalidArgumentException for an invalid URL or body
51			*/
52			public function __construct(
53			$method,
54			$url,
55			array $headers = array(),
56			$body = '',
57			$version = '1.1',
58			$serverParams = array()
59			) {
60			$stream = null;
61			if (\is_string($body)) {
62			$body = new BufferedBody($body);
63			} elseif ($body instanceof ReadableStreamInterface && !$body instanceof StreamInterface) {
64			$stream = $body;
65			$body = null;
66			} elseif (!$body instanceof StreamInterface) {
			0 ignored issues – show introduced 2024-10-12 21:52 UTC by Report Bug Copy Issue Report `$body` is always a sub-type of `Psr\Http\Message\StreamInterface`. Loading history...
67			throw new \InvalidArgumentException('Invalid server request body given');
68			}
69
70			$this->serverParams = $serverParams;
71			parent::__construct($method, $url, $headers, $body, $version);
72
73			if ($stream !== null) {
74			$size = (int) $this->getHeaderLine('Content-Length');
75			if (\strtolower($this->getHeaderLine('Transfer-Encoding')) === 'chunked') {
76			$size = null;
77			}
78			$this->stream = new HttpBodyStream($stream, $size);
79			}
80
81			$query = $this->getUri()->getQuery();
82			if ($query !== '') {
83			\parse_str($query, $this->queryParams);
84			}
85
86			// Multiple cookie headers are not allowed according
87			// to https://tools.ietf.org/html/rfc6265#section-5.4
88			$cookieHeaders = $this->getHeader("Cookie");
89
90			if (count($cookieHeaders) === 1) {
91			$this->cookies = $this->parseCookie($cookieHeaders[0]);
92			}
93			}
94
95			public function getServerParams()
96			{
97			return $this->serverParams;
98			}
99
100			public function getCookieParams()
101			{
102			return $this->cookies;
103			}
104
105			public function withCookieParams(array $cookies)
106			{
107			$new = clone $this;
108			$new->cookies = $cookies;
109			return $new;
110			}
111
112			public function getQueryParams()
113			{
114			return $this->queryParams;
115			}
116
117			public function withQueryParams(array $query)
118			{
119			$new = clone $this;
120			$new->queryParams = $query;
121			return $new;
122			}
123
124			public function getUploadedFiles()
125			{
126			return $this->fileParams;
127			}
128
129			public function withUploadedFiles(array $uploadedFiles)
130			{
131			$new = clone $this;
132			$new->fileParams = $uploadedFiles;
133			return $new;
134			}
135
136			public function getParsedBody()
137			{
138			return $this->parsedBody;
139			}
140
141			public function withParsedBody($data)
142			{
143			$new = clone $this;
144			$new->parsedBody = $data;
145			return $new;
146			}
147
148			public function getAttributes()
149			{
150			return $this->attributes;
151			}
152
153			public function getAttribute($name, $default = null)
154			{
155			if (!\array_key_exists($name, $this->attributes)) {
156			return $default;
157			}
158			return $this->attributes[$name];
159			}
160
161			public function withAttribute($name, $value)
162			{
163			$new = clone $this;
164			$new->attributes[$name] = $value;
165			return $new;
166			}
167
168			public function withoutAttribute($name)
169			{
170			$new = clone $this;
171			unset($new->attributes[$name]);
172			return $new;
173			}
174
175			/**
176			* @param string $cookie
177			* @return array
178			*/
179			private function parseCookie($cookie)
180			{
181			$cookieArray = \explode(';', $cookie);
182			$result = array();
183
184			foreach ($cookieArray as $pair) {
185			$pair = \trim($pair);
186			$nameValuePair = \explode('=', $pair, 2);
187
188			if (\count($nameValuePair) === 2) {
189			$key = \urldecode($nameValuePair[0]);
190			$value = \urldecode($nameValuePair[1]);
191			$result[$key] = $value;
192			}
193			}
194
195			return $result;
196			}
197			}
198

deployphp / deployer

GitHub Access Token became invalid

Push — master ( 5cefd1...492078 )

ServerRequest::withQueryParams() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like