ServerRequest::getCookieParams() - Code Metrics - Inspection of "add validation of input files to withUploadedFiles..." - kambo-1st/HttpMessage - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f6575e...fc504f )

by Bohuslav

created 2016-06-26 08:35 UTC

ServerRequest::getCookieParams() A

↳ Parent: ServerRequest

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php
namespace Kambo\HttpMessage;

// \Spl
use InvalidArgumentException;

// \Psr
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\UriInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Message\UploadedFileInterface;

// \HttpMessage
use Kambo\HttpMessage\Uri;
use Kambo\HttpMessage\Message;
use Kambo\HttpMessage\UploadedFile;
use Kambo\HttpMessage\Headers;
use Kambo\HttpMessage\Parser\Parser;
use Kambo\HttpMessage\RequestTrait;

/**
 * Representation of an incoming, server-side HTTP request.
 *
 * Per the HTTP specification, this interface includes properties for
 * each of the following:
 *
 * - Protocol version
 * - HTTP method
 * - URI
 * - Headers
 * - Message body
 *
 * Additionally, it encapsulates all data as it has arrived to the
 * application from the CGI and/or PHP environment, including:
 *
 * - The values represented in $_SERVER.
 * - Any cookies provided (generally via $_COOKIE)
 * - Query string arguments (generally via $_GET, or as parsed via parse_str())
 * - Upload files, if any (as represented by $_FILES)
 * - Deserialized body parameters (generally from $_POST)
 *
 * $_SERVER values are treated as immutable, as they represent application
 * state at the time of request; as such, no methods are provided to allow
 * modification of those values. The other values provide such methods, as they
 * can be restored from $_SERVER or the request body, and may need treatment
 * during the application (e.g., body parameters may be deserialized based on
 * content type).
 *
 * Additionally, this interface recognizes the utility of introspecting a
 * request to derive and match additional parameters (e.g., via URI path
 * matching, decrypting cookie values, deserializing non-form-encoded body
 * content, matching authorization headers to users, etc). These parameters
 * are stored in an "attributes" property.
 *
 * Requests are considered immutable; all methods that change state retain
 * the internal state of the current message and return an instance that
 * contains the changed state.
 *
 * @package Kambo\HttpMessage
 * @author  Bohuslav Simek <[email protected]>
 * @license MIT
 */
class ServerRequest extends Message implements ServerRequestInterface
{
    use RequestTrait;

    /**
     * Server parameters - related to the incoming request environment, 
     * they are typically derived from PHP's $_SERVER superglobal.
     *
     * @var array
     */
    private $serverVariables;

    /**
     * Deserialized query string arguments, if any.
     *
     * @var array
     */
    private $queryParams = null;

    /**
     * Cookies sent by the client to the server.
     *
     * @var array
     */
    private $cookies;

    /**
     * Contain attributes derived from the request.
     *
     * @var array
     */
    private $attributes = [];

    /**
     * Uploaded files of incoming request, if any.
     *
     * @var array
     */
    private $uploadedFiles = null;

    /**
     * Parsed incoming request body - this value is filled 
     * when method getParsedBody or withParsedBody is called.
     *
     * @var array|object|null
     */
    private $parsedBody = null;

    /**
     * Create new HTTP request.
     *
     * Adds a host header when none was provided and a host is defined in uri.
     * 
     * @param UriInterface     $uri             The request URI object
     * @param array            $cookies         The request cookies collection
     * @param string           $requestMethod   The request method
     * @param array            $uploadFiles     The request uploadedFiles collection
     * @param Headers          $headers         The request headers collection
     * @param StreamInterface  $body            The request body object
     * @param array            $serverVariables The server environment variables
     * @param string           $protocol        The request version of the protocol
     * @param array            $attributes      The request attributs
     * 
     */
    public function __construct(
        Uri $uri,
        array $cookies,
        $requestMethod,
        array $uploadFiles,
        Headers $headers,
        StreamInterface $body,
        array $serverVariables,
        $protocol,
        array $attributes = []
    ) {
        parent::__construct($headers, $body, $protocol);
        $this->validateMethod($requestMethod);
        $this->uri             = $uri;
        $this->cookies         = $cookies;
        $this->requestMethod   = $requestMethod;
        $this->uploadedFiles   = $uploadFiles;
        $this->attributes      = $attributes;
        $this->serverVariables = $serverVariables;
    }

    /**
     * Retrieve server parameters.
     *
     * Retrieves data related to the incoming request environment,
     * typically derived from PHP's $_SERVER superglobal. The data IS NOT
     * REQUIRED to originate from $_SERVER.
     *
     * @return array
     */
    public function getServerParams()
    {
        return $this->serverVariables;
    }

    /**
     * Retrieve cookies.
     *
     * Retrieves cookies sent by the client to the server.
     *
     * The data are compatible with the structure of the $_COOKIE
     * superglobal.
     *
     * @return array
     */
    public function getCookieParams()
    {
        return $this->cookies;
    }

    /**
     * Return an instance with the specified cookies.
     *
     * The data IS NOT REQUIRED to come from the $_COOKIE superglobal, but MUST
     * be compatible with the structure of $_COOKIE. Typically, this data will
     * be injected at instantiation.
     *
     * This method not update the related Cookie header of the request
     * instance, nor related values in the server params.
     *
     * This method retain the immutability of the message, and return an instance 
     * that has the updated cookie values.
     *
     * @param array $cookies Array of key/value pairs representing cookies.
     *
     * @return self for fluent interface
     */
    public function withCookieParams(array $cookies)
    {
        $clone          = clone $this;
        $clone->cookies = $cookies;

        return $clone;
    }

    /**
     * Retrieve query string arguments.
     *
     * Retrieves the deserialized query string arguments, if any.
     *
     * Note: the query params might not be in sync with the URI or server
     * params. If you need to ensure you are only getting the original
     * values, you may need to parse the query string from `getUri()->getQuery()`
     * or from the `QUERY_STRING` server param.
     *
     * @return array
     */
    public function getQueryParams()
    {
        if ($this->queryParams === null) {
            parse_str($this->uri->getQuery(), $this->queryParams);
        }

        return $this->queryParams;
    }

    /**
     * Return an instance with the specified query string arguments.
     *
     * These values remain immutable over the course of the incoming
     * request.
     *
     * Setting query string arguments not change the URI stored by the
     * request, nor the values in the server params.
     *
     * This method retain the immutability of the message, and return an instance 
     * that has the updated query string arguments.
     *
     * @param array $query Array of query string arguments, typically from $_GET.
     *
     * @return self for fluent interface
     */
    public function withQueryParams(array $query)
    {
        $clone              = clone $this;
        $clone->queryParams = $query;

        return $clone;
    }

    /**
     * Retrieve normalized file upload data.
     *
     * This method returns upload metadata in a normalized tree, with each leaf
     * an instance of Psr\Http\Message\UploadedFileInterface.
     *
     * These values can be prepared from $_FILES or the message body during
     * instantiation, or can be injected via withUploadedFiles().
     *
     * @return array An array tree of UploadedFileInterface instances; an empty
     *               array is returned if no data is present.
     */
    public function getUploadedFiles()
    {
        return $this->uploadedFiles;
    }

    /**
     * Create a new instance with the specified uploaded files.
     *
     * This method retain the immutability of the message, and return an instance 
     * that has the updated body parameters.
     *
     * @param array An array tree of UploadedFileInterface instances.
     *
     * @return self for fluent interface
     *
     * @throws \InvalidArgumentException if an invalid structure is provided.
     */
    public function withUploadedFiles(array $uploadedFiles)
    {
        $this->validateUploadedFiles($uploadedFiles);
        $clone                = clone $this;
        $clone->uploadedFiles = $uploadedFiles;

        return $clone;
    }

    /**
     * Retrieve any parameters provided in the request body.
     *
     * If the request Content-Type is either application/x-www-form-urlencoded
     * or multipart/form-data, and the request method is POST, this method
     * return the contents of $_POST.
     *
     * Otherwise, this method may return any results of deserializing
     * the request body content; as parsing returns structured content, the
     * potential types are arrays or objects. A null value indicates
     * the absence of body content.
     *
     * @return null|array|object The deserialized body parameters, if any.
     *                           These will typically be an array or object.
     */
    public function getParsedBody()
    {
        if ($this->body !== null && $this->parsedBody === null) {
            $parser = new Parser($this->getContentType());
            $this->parsedBody = $parser->parse($this->body);
        }

        return $this->parsedBody;
    }

    /**
     * Return an instance with the specified body parameters.
     *
     * If the request Content-Type is either application/x-www-form-urlencoded
     * or multipart/form-data, and the request method is POST, use this method
     * ONLY to inject the contents of $_POST.
     *
     * The data IS NOT REQUIRED to come from $_POST, but MUST be the results of
     * deserializing the request body content. Deserialization/parsing returns
     * structured data, and, as such, this method ONLY accepts arrays or objects,
     * or a null value if nothing was available to parse.
     *
     * As an example, if content negotiation determines that the request data
     * is a JSON payload, this method could be used to create a request
     * instance with the deserialized parameters.
     *
     * This method retain the immutability of the message, and return an 
     * instance that has the updated body parameters.
     *     
     * @param null|array|object $data The deserialized body data. This will
     *                                typically be in an array or object.
     *
     * @return self for fluent interface
     *
     * @throws \InvalidArgumentException if an unsupported argument type is provided.    
     */
    public function withParsedBody($data)
    {
        if (!is_null($data) && !is_object($data) && !is_array($data)) {
            throw new InvalidArgumentException('Value must be an array, an object, or null');
        }

        $clone             = clone $this;
        $clone->parsedBody = $data;

        return $clone;
    }

    /**
     * Retrieve attributes derived from the request.
     *
     * The request "attributes" may be used to allow injection of any
     * parameters derived from the request: e.g., the results of path
     * match operations; the results of decrypting cookies; the results of
     * deserializing non-form-encoded message bodies; etc. Attributes
     * will be application and request specific, and is mutable.
     *
     * @return array Attributes derived from the request.
     */
    public function getAttributes()
    {
        return $this->attributes;
    }

    /**
     * Retrieve a single derived request attribute.
     *
     * Retrieves a single derived request attribute as described in
     * getAttributes(). If the attribute has not been previously set, returns
     * the default value as provided.
     *
     * This method obviates the need for a hasAttribute() method, as it allows
     * specifying a default value to return if the attribute is not found.
     *
     * @see getAttributes()
     *
     * @param string $name    The attribute name.
     * @param mixed  $default Default value to return if the attribute does not exist.
     *
     * @return mixed
     */
    public function getAttribute($name, $default = null)
    {
        $attributeValue = $default;
        if (isset($this->attributes[$name])) {
            $attributeValue = $this->attributes[$name];
        }

        return $attributeValue;
    }

    /**
     * Return an instance with the specified derived request attribute.
     *
     * This method allows setting a single derived request attribute as
     * described in getAttributes().
     *
     * This method retains the state of the current instance, and return
     * an instance that has the updated attribute.
     *
     * @see getAttributes()
     *
     * @param string $name  The attribute name.
     * @param mixed  $value The value of the attribute.
     *
     * @return self for fluent interface
     */
    public function withAttribute($name, $value)
    {
        $clone                    = clone $this;
        $clone->attributes[$name] = $value;

        return $clone;
    }

    /**
     * Return an instance that removes the specified derived request attribute.
     *
     * This method allows removing a single derived request attribute as
     * described in getAttributes().
     *
     * This method retains the state of the current instance, and return
     * an instance that removes the attribute.
     *
     * @see getAttributes()
     *
     * @param string $name The attribute name.
     *
     * @return self for fluent interface
     */
    public function withoutAttribute($name)
    {
        $clone = clone $this;

        if (isset($clone->attributes[$name])) {
            unset($clone->attributes[$name]);
        }

        return $clone;
    }

    // ------------ PRIVATE METHODS

    /**
     * Validate request method
     *
     * @param string $method request method
     *
     * @return self for fluent interface
     *
     * @throws \InvalidArgumentException if an unsupported method is provided.     
     */
    private function validateMethod($method)
    {
        $valid = [
            'GET'    => true,
            'POST'   => true,
            'DELETE' => true,
            'PUT'    => true,
            'PATCH'  => true
        ];

        if (!isset($valid[$method])) {
            throw new InvalidArgumentException(
                'Invalid method version. Must be one of: GET, POST, DELTE, PUT or PATCH'
            );
        }
    }

    /**
     * Get request content type.
     *
     * @return string|null The request content type, if known
     */
    private function getContentType()
    {
        $result = null;
        if ($this->hasHeader('Content-Type')) {
            $result = $this->getHeader('Content-Type')[0];
        }

        return $result;
    }

    /**
     * Validate the structure in an uploaded files array.
     *
     * @param array $uploadedFiles
     *
     * @throws InvalidArgumentException if any entry is not an UploadedFileInterface instance.
     */
    private function validateUploadedFiles(array $uploadedFiles)
    {
        foreach ($uploadedFiles as $file) {
            if (is_array($file)) {
                $this->validateUploadedFiles($file);
            } elseif (! $file instanceof UploadedFileInterface) {
                throw new InvalidArgumentException('Invalid entry in uploaded files structure');
            }
        }
    }
}


1		<?php
2		namespace Kambo\HttpMessage;
3
4		// \Spl
5		use InvalidArgumentException;
6
7		// \Psr
8		use Psr\Http\Message\ServerRequestInterface;
9		use Psr\Http\Message\UriInterface;
10		use Psr\Http\Message\StreamInterface;
11		use Psr\Http\Message\UploadedFileInterface;
12
13		// \HttpMessage
14		use Kambo\HttpMessage\Uri;
15		use Kambo\HttpMessage\Message;
16		use Kambo\HttpMessage\UploadedFile;
17		use Kambo\HttpMessage\Headers;
18		use Kambo\HttpMessage\Parser\Parser;
19		use Kambo\HttpMessage\RequestTrait;
20
21		/**
22		* Representation of an incoming, server-side HTTP request.
23		*
24		* Per the HTTP specification, this interface includes properties for
25		* each of the following:
26		*
27		* - Protocol version
28		* - HTTP method
29		* - URI
30		* - Headers
31		* - Message body
32		*
33		* Additionally, it encapsulates all data as it has arrived to the
34		* application from the CGI and/or PHP environment, including:
35		*
36		* - The values represented in $_SERVER.
37		* - Any cookies provided (generally via $_COOKIE)
38		* - Query string arguments (generally via $_GET, or as parsed via parse_str())
39		* - Upload files, if any (as represented by $_FILES)
40		* - Deserialized body parameters (generally from $_POST)
41		*
42		* $_SERVER values are treated as immutable, as they represent application
43		* state at the time of request; as such, no methods are provided to allow
44		* modification of those values. The other values provide such methods, as they
45		* can be restored from $_SERVER or the request body, and may need treatment
46		* during the application (e.g., body parameters may be deserialized based on
47		* content type).
48		*
49		* Additionally, this interface recognizes the utility of introspecting a
50		* request to derive and match additional parameters (e.g., via URI path
51		* matching, decrypting cookie values, deserializing non-form-encoded body
52		* content, matching authorization headers to users, etc). These parameters
53		* are stored in an "attributes" property.
54		*
55		* Requests are considered immutable; all methods that change state retain
56		* the internal state of the current message and return an instance that
57		* contains the changed state.
58		*
59		* @package Kambo\HttpMessage
60		* @author Bohuslav Simek <[email protected]>
61		* @license MIT
62		*/
63		class ServerRequest extends Message implements ServerRequestInterface
64		{
65		use RequestTrait;
66
67		/**
68		* Server parameters - related to the incoming request environment,
69		* they are typically derived from PHP's $_SERVER superglobal.
70		*
71		* @var array
72		*/
73		private $serverVariables;
74
75		/**
76		* Deserialized query string arguments, if any.
77		*
78		* @var array
79		*/
80		private $queryParams = null;
81
82		/**
83		* Cookies sent by the client to the server.
84		*
85		* @var array
86		*/
87		private $cookies;
88
89		/**
90		* Contain attributes derived from the request.
91		*
92		* @var array
93		*/
94		private $attributes = [];
95
96		/**
97		* Uploaded files of incoming request, if any.
98		*
99		* @var array
100		*/
101		private $uploadedFiles = null;
102
103		/**
104		* Parsed incoming request body - this value is filled
105		* when method getParsedBody or withParsedBody is called.
106		*
107		* @var array\|object\|null
108		*/
109		private $parsedBody = null;
110
111		/**
112		* Create new HTTP request.
113		*
114		* Adds a host header when none was provided and a host is defined in uri.
115		*
116		* @param UriInterface $uri The request URI object
117		* @param array $cookies The request cookies collection
118		* @param string $requestMethod The request method
119		* @param array $uploadFiles The request uploadedFiles collection
120		* @param Headers $headers The request headers collection
121		* @param StreamInterface $body The request body object
122		* @param array $serverVariables The server environment variables
123		* @param string $protocol The request version of the protocol
124		* @param array $attributes The request attributs
125		*
126		*/
127	27	public function __construct(
128		Uri $uri,
129		array $cookies,
130		$requestMethod,
131		array $uploadFiles,
132		Headers $headers,
133		StreamInterface $body,
134		array $serverVariables,
135		$protocol,
136		array $attributes = []
137		) {
138	27	parent::__construct($headers, $body, $protocol);
139	27	$this->validateMethod($requestMethod);
140	27	$this->uri = $uri;
141	27	$this->cookies = $cookies;
142	27	$this->requestMethod = $requestMethod;
143	27	$this->uploadedFiles = $uploadFiles;
144	27	$this->attributes = $attributes;
145	27	$this->serverVariables = $serverVariables;
146	27	}
147
148		/**
149		* Retrieve server parameters.
150		*
151		* Retrieves data related to the incoming request environment,
152		* typically derived from PHP's $_SERVER superglobal. The data IS NOT
153		* REQUIRED to originate from $_SERVER.
154		*
155		* @return array
156		*/
157	1	public function getServerParams()
158		{
159	1	return $this->serverVariables;
160		}
161
162		/**
163		* Retrieve cookies.
164		*
165		* Retrieves cookies sent by the client to the server.
166		*
167		* The data are compatible with the structure of the $_COOKIE
168		* superglobal.
169		*
170		* @return array
171		*/
172	2	public function getCookieParams()
173		{
174	2	return $this->cookies;
175		}
176
177		/**
178		* Return an instance with the specified cookies.
179		*
180		* The data IS NOT REQUIRED to come from the $_COOKIE superglobal, but MUST
181		* be compatible with the structure of $_COOKIE. Typically, this data will
182		* be injected at instantiation.
183		*
184		* This method not update the related Cookie header of the request
185		* instance, nor related values in the server params.
186		*
187		* This method retain the immutability of the message, and return an instance
188		* that has the updated cookie values.
189		*
190		* @param array $cookies Array of key/value pairs representing cookies.
191		*
192		* @return self for fluent interface
193		*/
194	1	public function withCookieParams(array $cookies)
195		{
196	1	$clone = clone $this;
197	1	$clone->cookies = $cookies;
198
199	1	return $clone;
200		}
201
202		/**
203		* Retrieve query string arguments.
204		*
205		* Retrieves the deserialized query string arguments, if any.
206		*
207		* Note: the query params might not be in sync with the URI or server
208		* params. If you need to ensure you are only getting the original
209		* values, you may need to parse the query string from `getUri()->getQuery()`
210		* or from the `QUERY_STRING` server param.
211		*
212		* @return array
213		*/
214	2	public function getQueryParams()
215		{
216	2	if ($this->queryParams === null) {
217	2	parse_str($this->uri->getQuery(), $this->queryParams);
218	2	}
219
220	2	return $this->queryParams;
221		}
222
223		/**
224		* Return an instance with the specified query string arguments.
225		*
226		* These values remain immutable over the course of the incoming
227		* request.
228		*
229		* Setting query string arguments not change the URI stored by the
230		* request, nor the values in the server params.
231		*
232		* This method retain the immutability of the message, and return an instance
233		* that has the updated query string arguments.
234		*
235		* @param array $query Array of query string arguments, typically from $_GET.
236		*
237		* @return self for fluent interface
238		*/
239	1	public function withQueryParams(array $query)
240		{
241	1	$clone = clone $this;
242	1	$clone->queryParams = $query;
243
244	1	return $clone;
245		}
246
247		/**
248		* Retrieve normalized file upload data.
249		*
250		* This method returns upload metadata in a normalized tree, with each leaf
251		* an instance of Psr\Http\Message\UploadedFileInterface.
252		*
253		* These values can be prepared from $_FILES or the message body during
254		* instantiation, or can be injected via withUploadedFiles().
255		*
256		* @return array An array tree of UploadedFileInterface instances; an empty
257		* array is returned if no data is present.
258		*/
259	2	public function getUploadedFiles()
260		{
261	2	return $this->uploadedFiles;
262		}
263
264		/**
265		* Create a new instance with the specified uploaded files.
266		*
267		* This method retain the immutability of the message, and return an instance
268		* that has the updated body parameters.
269		*
270		* @param array An array tree of UploadedFileInterface instances.
271		*
272		* @return self for fluent interface
273		*
274		* @throws \InvalidArgumentException if an invalid structure is provided.
275		*/
276	2	public function withUploadedFiles(array $uploadedFiles)
277		{
278	2	$this->validateUploadedFiles($uploadedFiles);
279	1	$clone = clone $this;
280	1	$clone->uploadedFiles = $uploadedFiles;
281
282	1	return $clone;
283		}
284
285		/**
286		* Retrieve any parameters provided in the request body.
287		*
288		* If the request Content-Type is either application/x-www-form-urlencoded
289		* or multipart/form-data, and the request method is POST, this method
290		* return the contents of $_POST.
291		*
292		* Otherwise, this method may return any results of deserializing
293		* the request body content; as parsing returns structured content, the
294		* potential types are arrays or objects. A null value indicates
295		* the absence of body content.
296		*
297		* @return null\|array\|object The deserialized body parameters, if any.
298		* These will typically be an array or object.
299		*/
300	5	public function getParsedBody()
301		{
302	5	if ($this->body !== null && $this->parsedBody === null) {
303	5	$parser = new Parser($this->getContentType());
304	5	$this->parsedBody = $parser->parse($this->body);
305	5	}
306
307	5	return $this->parsedBody;
308		}
309
310		/**
311		* Return an instance with the specified body parameters.
312		*
313		* If the request Content-Type is either application/x-www-form-urlencoded
314		* or multipart/form-data, and the request method is POST, use this method
315		* ONLY to inject the contents of $_POST.
316		*
317		* The data IS NOT REQUIRED to come from $_POST, but MUST be the results of
318		* deserializing the request body content. Deserialization/parsing returns
319		* structured data, and, as such, this method ONLY accepts arrays or objects,
320		* or a null value if nothing was available to parse.
321		*
322		* As an example, if content negotiation determines that the request data
323		* is a JSON payload, this method could be used to create a request
324		* instance with the deserialized parameters.
325		*
326		* This method retain the immutability of the message, and return an
327		* instance that has the updated body parameters.
328		*
329		* @param null\|array\|object $data The deserialized body data. This will
330		* typically be in an array or object.
331		*
332		* @return self for fluent interface
333		*
334		* @throws \InvalidArgumentException if an unsupported argument type is provided.
335		*/
336	2	public function withParsedBody($data)
337		{
338	2	if (!is_null($data) && !is_object($data) && !is_array($data)) {
339	1	throw new InvalidArgumentException('Value must be an array, an object, or null');
340		}
341
342	1	$clone = clone $this;
343	1	$clone->parsedBody = $data;
344
345	1	return $clone;
346		}
347
348		/**
349		* Retrieve attributes derived from the request.
350		*
351		* The request "attributes" may be used to allow injection of any
352		* parameters derived from the request: e.g., the results of path
353		* match operations; the results of decrypting cookies; the results of
354		* deserializing non-form-encoded message bodies; etc. Attributes
355		* will be application and request specific, and is mutable.
356		*
357		* @return array Attributes derived from the request.
358		*/
359	1	public function getAttributes()
360		{
361	1	return $this->attributes;
362		}
363
364		/**
365		* Retrieve a single derived request attribute.
366		*
367		* Retrieves a single derived request attribute as described in
368		* getAttributes(). If the attribute has not been previously set, returns
369		* the default value as provided.
370		*
371		* This method obviates the need for a hasAttribute() method, as it allows
372		* specifying a default value to return if the attribute is not found.
373		*
374		* @see getAttributes()
375		*
376		* @param string $name The attribute name.
377		* @param mixed $default Default value to return if the attribute does not exist.
378		*
379		* @return mixed
380		*/
381	4	public function getAttribute($name, $default = null)
382		{
383	4	$attributeValue = $default;
384	4	if (isset($this->attributes[$name])) {
385	3	$attributeValue = $this->attributes[$name];
386	3	}
387
388	4	return $attributeValue;
389		}
390
391		/**
392		* Return an instance with the specified derived request attribute.
393		*
394		* This method allows setting a single derived request attribute as
395		* described in getAttributes().
396		*
397		* This method retains the state of the current instance, and return
398		* an instance that has the updated attribute.
399		*
400		* @see getAttributes()
401		*
402		* @param string $name The attribute name.
403		* @param mixed $value The value of the attribute.
404		*
405		* @return self for fluent interface
406		*/
407	4	public function withAttribute($name, $value)
408		{
409	4	$clone = clone $this;
410	4	$clone->attributes[$name] = $value;
411
412	4	return $clone;
413		}
414
415		/**
416		* Return an instance that removes the specified derived request attribute.
417		*
418		* This method allows removing a single derived request attribute as
419		* described in getAttributes().
420		*
421		* This method retains the state of the current instance, and return
422		* an instance that removes the attribute.
423		*
424		* @see getAttributes()
425		*
426		* @param string $name The attribute name.
427		*
428		* @return self for fluent interface
429		*/
430	1	public function withoutAttribute($name)
431		{
432	1	$clone = clone $this;
433
434	1	if (isset($clone->attributes[$name])) {
435	1	unset($clone->attributes[$name]);
436	1	}
437
438	1	return $clone;
439		}
440
441		// ------------ PRIVATE METHODS
442
443		/**
444		* Validate request method
445		*
446		* @param string $method request method
447		*
448		* @return self for fluent interface
449		*
450		* @throws \InvalidArgumentException if an unsupported method is provided.
451		*/
452	27	private function validateMethod($method)
453		{
454		$valid = [
455	27	'GET' => true,
456	27	'POST' => true,
457	27	'DELETE' => true,
458	27	'PUT' => true,
459		'PATCH' => true
460	27	];
461
462	27	if (!isset($valid[$method])) {
463	1	throw new InvalidArgumentException(
464		'Invalid method version. Must be one of: GET, POST, DELTE, PUT or PATCH'
465	1	);
466		}
467	27	}
468
469		/**
470		* Get request content type.
471		*
472		* @return string\|null The request content type, if known
473		*/
474	5	private function getContentType()
475		{
476	5	$result = null;
477	5	if ($this->hasHeader('Content-Type')) {
478	4	$result = $this->getHeader('Content-Type')[0];
479	4	}
480
481	5	return $result;
482		}
483
484		/**
485		* Validate the structure in an uploaded files array.
486		*
487		* @param array $uploadedFiles
488		*
489		* @throws InvalidArgumentException if any entry is not an UploadedFileInterface instance.
490		*/
491	2	private function validateUploadedFiles(array $uploadedFiles)
492		{
493	2	foreach ($uploadedFiles as $file) {
494	2	if (is_array($file)) {
495	1	$this->validateUploadedFiles($file);
496	2	} elseif (! $file instanceof UploadedFileInterface) {
497	1	throw new InvalidArgumentException('Invalid entry in uploaded files structure');
498		}
499	1	}
500	1	}
501		}
502

kambo-1st / HttpMessage

Push — master ( f6575e...fc504f )

ServerRequest::getCookieParams() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like