Response::getProtocolVersion() - Code Metrics - Inspection of "Merge pull request #450 from AntonShevchuk/master" - bluzphp/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d292ba...467d47 )

by Anton

created 2017-11-08 13:52 UTC

Response::getProtocolVersion() A

↳ Parent: Response

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

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

<?php
/**
 * Bluz Framework Component
 *
 * @copyright Bluz PHP Team
 * @link      https://github.com/bluzphp/framework
 */

declare(strict_types=1);

namespace Bluz\Response;

use Bluz\Application\Exception\NotAcceptableException;
use Bluz\Cli\CliResponse;
use Bluz\Common\Options;
use Bluz\Controller\Controller;
use Bluz\Http\StatusCode;
use Bluz\Layout\Layout;
use Bluz\Proxy\Messages;
use Zend\Diactoros\Response\EmptyResponse;
use Zend\Diactoros\Response\HtmlResponse;
use Zend\Diactoros\Response\JsonResponse;
use Zend\Diactoros\Response\RedirectResponse;
use Zend\Diactoros\Response\SapiEmitter;

/**
 * Response Container
 *
 * @package  Bluz\Response
 * @author   Anton Shevchuk
 * @link     https://github.com/bluzphp/framework/wiki/Response
 */
class Response
{
    use Options;

    /**
     * @var string HTTP protocol version
     */
    protected $protocol = '1.1';

    /**
     * @var integer response code equal to HTTP status codes
     */
    protected $code = StatusCode::OK;

    /**
     * @var string|null HTTP Phrase
     */
    protected $phrase;

    /**
     * @var array list of headers
     */
    protected $headers = [];

    /**
     * @var array list of cookies
     */
    protected $cookies = [];

    /**
     * @var Controller
     */
    protected $body;

    /**
     * @var string CLI|HTML|JSON|FILE
     */
    protected $type = 'HTML';

    /**
     * send
     *
     * @throws NotAcceptableException
     * @throws \InvalidArgumentException
     */
    public function send()
    {
        $body = $this->getBody();

        $this->sendCookies();

        switch (true) {
            case 'CLI' === $this->type:
                // no CLI response
                return;
            case is_null($body):
            case StatusCode::NO_CONTENT === $this->getStatusCode():
                $response = new EmptyResponse($this->getStatusCode(), $this->getHeaders());
                break;
            case StatusCode::MOVED_PERMANENTLY === $this->getStatusCode():
            case StatusCode::FOUND === $this->getStatusCode():
                $response = new RedirectResponse(
                    $this->getHeader('Location'),
                    $this->getStatusCode(),
                    $this->getHeaders()
                );
                break;
            case 'JSON' === $this->type:
                // JSON response
                // setup messages
                if (Messages::count()) {
                    $this->setHeader('Bluz-Notify', json_encode(Messages::popAll()));
                }

                // encode body data to JSON
                $response = new JsonResponse(
                    $body,
                    $this->getStatusCode(),
                    $this->getHeaders()
                );
                break;
            case 'FILE' === $this->type:
                // File attachment
                $response = new AttachmentResponse(
                    $this->body->getData()->get('FILE'),
                    $this->getStatusCode(),
                    $this->getHeaders()
                );
                break;
            case 'HTML' === $this->type:
            default:
                // HTML response
                $response = new HtmlResponse(
                    (string)$body,
                    $this->getStatusCode(),
                    $this->getHeaders()
                );
                break;
        }

        $emitter = new SapiEmitter();
        $emitter->emit($response);
    }

    /**
     * Get response type
     *
     * @return string
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * Set Response Type, one of JSON, HTML or CLI
     *
     * @param $type
     */
    public function setType($type)
    {
        // switch statement by content type
        switch ($type) {
            case 'JSON':
                $this->setHeader('Content-Type', 'application/json');
                break;
            case 'CLI':
            case 'FILE':
            case 'HTML':
            default:
                break;
        }

        $this->type = $type;
    }


    /**
     * Gets the HTTP protocol version as a string
     *
     * The string MUST contain only the HTTP version number (e.g., "1.1", "1.0").
     *
     * @return string HTTP protocol version.
     */
    public function getProtocolVersion()
    {
        return $this->protocol;
    }

    /**
     * Gets the response Status-Code
     *
     * The Status-Code is a 3-digit integer result code of the server's attempt
     * to understand and satisfy the request.
     *
     * @return integer status code.
     */
    public function getStatusCode()
    {
        return $this->code;
    }

    /**
     * Sets the status code of this response
     *
     * @param  integer $code the 3-digit integer result code to set.
     *
     * @return void
     */
    public function setStatusCode($code)
    {
        $this->code = (int)$code;
    }

    /**
     * Gets the response Reason-Phrase, a short textual description of the Status-Code
     *
     * Because a Reason-Phrase is not a required element in response
     * Status-Line, the Reason-Phrase value MAY be null. Implementations MAY
     * choose to return the default RFC 2616 recommended reason phrase for the
     * response's Status-Code.
     *
     * @return string|null reason phrase, or null if unknown.
     */
    public function getReasonPhrase()
    {
        return $this->phrase;
    }

    /**
     * Sets the Reason-Phrase of the response
     *
     * If no Reason-Phrase is specified, implementations MAY choose to default
     * to the RFC 2616 recommended reason phrase for the response's Status-Code.
     *
     * @param string $phrase the Reason-Phrase to set.
     */
    public function setReasonPhrase($phrase)
    {
        $this->phrase = $phrase;
    }

    /**
     * Retrieve a header by the given case-insensitive name as a string
     *
     * This method returns all of the header values of the given
     * case-insensitive header name as a string concatenated together using
     * a comma.
     *
     * @param  string $header case-insensitive header name.
     *
     * @return string
     */
    public function getHeader($header)
    {
        if ($this->hasHeader($header)) {
            return implode(', ', $this->headers[$header]);
        }
        return '';
    }

    /**
     * Retrieves a header by the given case-insensitive name as an array of strings
     *
     * @param  string $header Case-insensitive header name.
     *
     * @return string[]
     */
    public function getHeaderAsArray($header)
    {
        if ($this->hasHeader($header)) {
            return $this->headers[$header];
        }
        return [];
    }

    /**
     * Checks if a header exists by the given case-insensitive name
     *
     * @param  string $header case-insensitive header name.
     *
     * @return bool returns true if any header names match the given header
     *              name using a case-insensitive string comparison. Returns false if
     *              no matching header name is found in the message.
     */
    public function hasHeader($header)
    {
        return isset($this->headers[$header]);
    }

    /**
     * Sets a header, replacing any existing values of any headers with the
     * same case-insensitive name
     *
     * The header name is case-insensitive. The header values MUST be a string
     * or an array of strings.
     *
     * @param  string          $header header name
     * @param  string|string[] $value  header value(s)
     *
     * @return void
     */
    public function setHeader($header, $value)
    {
        $this->headers[$header] = (array)$value;
    }

    /**
     * Appends a header value for the specified header
     *
     * Existing values for the specified header will be maintained. The new
     * value will be appended to the existing list.
     *
     * @param  string $header header name to add
     * @param  string $value  value of the header
     *
     * @return void
     */
    public function addHeader($header, $value)
    {
        if ($this->hasHeader($header)) {
            $this->headers[$header][] = $value;
        } else {
            $this->setHeader($header, $value);
        }
    }

    /**
     * Remove a specific header by case-insensitive name.
     *
     * @param  string $header HTTP header to remove
     *
     * @return void
     */
    public function removeHeader($header)
    {
        unset($this->headers[$header]);
    }

    /**
     * Gets all message headers
     *
     * The keys represent the header name as it will be sent over the wire, and
     * each value is an array of strings associated with the header.
     *
     *     // Represent the headers as a string
     *     foreach ($message->getHeaders() as $name => $values) {
     *         echo $name . ": " . implode(", ", $values);
     *     }
     *
     * @return array returns an associative array of the message's headers.
     */
    public function getHeaders()
    {
        return $this->headers;
    }

    /**
     * Sets headers, replacing any headers that have already been set on the message
     *
     * The array keys MUST be a string. The array values must be either a
     * string or an array of strings.
     *
     * @param  array $headers Headers to set.
     *
     * @return void
     */
    public function setHeaders(array $headers)
    {
        $this->headers = $headers;
    }

    /**
     * Merges in an associative array of headers.
     *
     * Each array key MUST be a string representing the case-insensitive name
     * of a header. Each value MUST be either a string or an array of strings.
     * For each value, the value is appended to any existing header of the same
     * name, or, if a header does not already exist by the given name, then the
     * header is added.
     *
     * @param  array $headers Associative array of headers to add to the message
     *
     * @return void
     */
    public function addHeaders(array $headers)
    {
        $this->headers = array_merge_recursive($this->headers, $headers);
    }

    /**
     * Remove all headers
     *
     * @return void
     */
    public function removeHeaders()
    {
        $this->headers = [];
    }

    /**
     * Set response body
     *
     * @param  mixed $body
     *
     * @return void
     */
    public function setBody($body)
    {
        $this->body = $body;
    }

    /**
     * Get response body
     *
     * @return Controller|Layout
     */
    public function getBody()
    {
        return $this->body;
    }

    /**
     * Clear response body
     *
     * @return void
     */
    public function clearBody()
    {
        $this->body = null;
    }

    /**
     * Set Cookie
     *
     * @param  string               $name
     * @param  string               $value
     * @param  int|string|\DateTime $expire
     * @param  string               $path
     * @param  string               $domain
     * @param  bool                 $secure
     * @param  bool                 $httpOnly
     *
     * @return void
     * @throws \InvalidArgumentException
     */
    public function setCookie(
        $name,
        $value = '',
        $expire = 0,
        $path = '/',
        $domain = '',
        $secure = false,
        $httpOnly = false
    ) {
        // from PHP source code
        if (preg_match("/[=,; \t\r\n\013\014]/", $name)) {
            throw new \InvalidArgumentException('The cookie name contains invalid characters.');
        }

        if (empty($name)) {
            throw new \InvalidArgumentException('The cookie name cannot be empty.');
        }

        // convert expiration time to a Unix timestamp
        if ($expire instanceof \DateTime) {
            $expire = $expire->format('U');
        } elseif (!is_numeric($expire)) {
            $expire = strtotime($expire);
            if (false === $expire || -1 === $expire) {
                throw new \InvalidArgumentException('The cookie expiration time is not valid.');
            }
        }

        $this->cookies[$name] = [
            'name' => $name,
            'value' => $value,
            'expire' => $expire,
            'path' => $path,
            'domain' => $domain,
            'secure' => (bool)$secure,
            'httpOnly' => (bool)$httpOnly
        ];
    }

    /**
     * Get Cookie by name
     *
     * @param  string $name
     *
     * @return array|null
     */
    public function getCookie($name)
    {
        return $this->cookies[$name] ?? null;
    }

    /**
     * Process Cookies to Header
     *
     *   Set-Cookie: <name>=<value>[; <name>=<value>]...
     *   [; expires=<date>][; domain=<domain_name>]
     *   [; path=<some_path>][; secure][; httponly]
     *
     * @return void
     */
    protected function sendCookies()
    {
        foreach ($this->cookies as $cookie) {
            setcookie(...array_values($cookie));
        }
    }
}


1		<?php
2		/**
3		* Bluz Framework Component
4		*
5		* @copyright Bluz PHP Team
6		* @link https://github.com/bluzphp/framework
7		*/
8
9		declare(strict_types=1);
10
11		namespace Bluz\Response;
12
13		use Bluz\Application\Exception\NotAcceptableException;
14		use Bluz\Cli\CliResponse;
15		use Bluz\Common\Options;
16		use Bluz\Controller\Controller;
17		use Bluz\Http\StatusCode;
18		use Bluz\Layout\Layout;
19		use Bluz\Proxy\Messages;
20		use Zend\Diactoros\Response\EmptyResponse;
21		use Zend\Diactoros\Response\HtmlResponse;
22		use Zend\Diactoros\Response\JsonResponse;
23		use Zend\Diactoros\Response\RedirectResponse;
24		use Zend\Diactoros\Response\SapiEmitter;
25
26		/**
27		* Response Container
28		*
29		* @package Bluz\Response
30		* @author Anton Shevchuk
31		* @link https://github.com/bluzphp/framework/wiki/Response
32		*/
33		class Response
34		{
35		use Options;
36
37		/**
38		* @var string HTTP protocol version
39		*/
40		protected $protocol = '1.1';
41
42		/**
43		* @var integer response code equal to HTTP status codes
44		*/
45		protected $code = StatusCode::OK;
46
47		/**
48		* @var string\|null HTTP Phrase
49		*/
50		protected $phrase;
51
52		/**
53		* @var array list of headers
54		*/
55		protected $headers = [];
56
57		/**
58		* @var array list of cookies
59		*/
60		protected $cookies = [];
61
62		/**
63		* @var Controller
64		*/
65		protected $body;
66
67		/**
68		* @var string CLI\|HTML\|JSON\|FILE
69		*/
70		protected $type = 'HTML';
71
72		/**
73		* send
74		*
75		* @throws NotAcceptableException
76		* @throws \InvalidArgumentException
77		*/
78	1	public function send()
79		{
80	1	$body = $this->getBody();
81
82	1	$this->sendCookies();
83
84		switch (true) {
85	1	case 'CLI' === $this->type:
86		// no CLI response
87		return;
88	1	case is_null($body):
89	1	case StatusCode::NO_CONTENT === $this->getStatusCode():
90		$response = new EmptyResponse($this->getStatusCode(), $this->getHeaders());
91		break;
92	1	case StatusCode::MOVED_PERMANENTLY === $this->getStatusCode():
93	1	case StatusCode::FOUND === $this->getStatusCode():
94		$response = new RedirectResponse(
95		$this->getHeader('Location'),
96		$this->getStatusCode(),
97		$this->getHeaders()
98		);
99		break;
100	1	case 'JSON' === $this->type:
101		// JSON response
102		// setup messages
103		if (Messages::count()) {
104		$this->setHeader('Bluz-Notify', json_encode(Messages::popAll()));
105		}
106
107		// encode body data to JSON
108		$response = new JsonResponse(
109		$body,
110		$this->getStatusCode(),
111		$this->getHeaders()
112		);
113		break;
114	1	case 'FILE' === $this->type:
115		// File attachment
116		$response = new AttachmentResponse(
117		$this->body->getData()->get('FILE'),
118		$this->getStatusCode(),
119		$this->getHeaders()
120		);
121		break;
122	1	case 'HTML' === $this->type:
123		default:
124		// HTML response
125	1	$response = new HtmlResponse(
126	1	(string)$body,
127	1	$this->getStatusCode(),
128	1	$this->getHeaders()
129		);
130	1	break;
131		}
132
133	1	$emitter = new SapiEmitter();
134	1	$emitter->emit($response);
135	1	}
136
137		/**
138		* Get response type
139		*
140		* @return string
141		*/
142	3	public function getType()
143		{
144	3	return $this->type;
145		}
146
147		/**
148		* Set Response Type, one of JSON, HTML or CLI
149		*
150		* @param $type
151		*/
152	3	public function setType($type)
153		{
154		// switch statement by content type
155		switch ($type) {
156	3	case 'JSON':
157	2	$this->setHeader('Content-Type', 'application/json');
158	2	break;
159	1	case 'CLI':
160	1	case 'FILE':
161		case 'HTML':
162		default:
163	1	break;
164		}
165
166	3	$this->type = $type;
167	3	}
168
169
170		/**
171		* Gets the HTTP protocol version as a string
172		*
173		* The string MUST contain only the HTTP version number (e.g., "1.1", "1.0").
174		*
175		* @return string HTTP protocol version.
176		*/
177	1	public function getProtocolVersion()
178		{
179	1	return $this->protocol;
180		}
181
182		/**
183		* Gets the response Status-Code
184		*
185		* The Status-Code is a 3-digit integer result code of the server's attempt
186		* to understand and satisfy the request.
187		*
188		* @return integer status code.
189		*/
190	5	public function getStatusCode()
191		{
192	5	return $this->code;
193		}
194
195		/**
196		* Sets the status code of this response
197		*
198		* @param integer $code the 3-digit integer result code to set.
199		*
200		* @return void
201		*/
202	5	public function setStatusCode($code)
203		{
204	5	$this->code = (int)$code;
205	5	}
206
207		/**
208		* Gets the response Reason-Phrase, a short textual description of the Status-Code
209		*
210		* Because a Reason-Phrase is not a required element in response
211		* Status-Line, the Reason-Phrase value MAY be null. Implementations MAY
212		* choose to return the default RFC 2616 recommended reason phrase for the
213		* response's Status-Code.
214		*
215		* @return string\|null reason phrase, or null if unknown.
216		*/
217	2	public function getReasonPhrase()
218		{
219	2	return $this->phrase;
220		}
221
222		/**
223		* Sets the Reason-Phrase of the response
224		*
225		* If no Reason-Phrase is specified, implementations MAY choose to default
226		* to the RFC 2616 recommended reason phrase for the response's Status-Code.
227		*
228		* @param string $phrase the Reason-Phrase to set.
229		*/
230	1	public function setReasonPhrase($phrase)
231		{
232	1	$this->phrase = $phrase;
233	1	}
234
235		/**
236		* Retrieve a header by the given case-insensitive name as a string
237		*
238		* This method returns all of the header values of the given
239		* case-insensitive header name as a string concatenated together using
240		* a comma.
241		*
242		* @param string $header case-insensitive header name.
243		*
244		* @return string
245		*/
246	15	public function getHeader($header)
247		{
248	15	if ($this->hasHeader($header)) {
249	13	return implode(', ', $this->headers[$header]);
250		}
251	6	return '';
252		}
253
254		/**
255		* Retrieves a header by the given case-insensitive name as an array of strings
256		*
257		* @param string $header Case-insensitive header name.
258		*
259		* @return string[]
260		*/
261	1	public function getHeaderAsArray($header)
262		{
263	1	if ($this->hasHeader($header)) {
264	1	return $this->headers[$header];
265		}
266	1	return [];
267		}
268
269		/**
270		* Checks if a header exists by the given case-insensitive name
271		*
272		* @param string $header case-insensitive header name.
273		*
274		* @return bool returns true if any header names match the given header
275		* name using a case-insensitive string comparison. Returns false if
276		* no matching header name is found in the message.
277		*/
278	14	public function hasHeader($header)
279		{
280	14	return isset($this->headers[$header]);
281		}
282
283		/**
284		* Sets a header, replacing any existing values of any headers with the
285		* same case-insensitive name
286		*
287		* The header name is case-insensitive. The header values MUST be a string
288		* or an array of strings.
289		*
290		* @param string $header header name
291		* @param string\|string[] $value header value(s)
292		*
293		* @return void
294		*/
295	15	public function setHeader($header, $value)
296		{
297	15	$this->headers[$header] = (array)$value;
298	15	}
299
300		/**
301		* Appends a header value for the specified header
302		*
303		* Existing values for the specified header will be maintained. The new
304		* value will be appended to the existing list.
305		*
306		* @param string $header header name to add
307		* @param string $value value of the header
308		*
309		* @return void
310		*/
311	1	public function addHeader($header, $value)
312		{
313	1	if ($this->hasHeader($header)) {
314	1	$this->headers[$header][] = $value;
315		} else {
316	1	$this->setHeader($header, $value);
317		}
318	1	}
319
320		/**
321		* Remove a specific header by case-insensitive name.
322		*
323		* @param string $header HTTP header to remove
324		*
325		* @return void
326		*/
327	1	public function removeHeader($header)
328		{
329	1	unset($this->headers[$header]);
330	1	}
331
332		/**
333		* Gets all message headers
334		*
335		* The keys represent the header name as it will be sent over the wire, and
336		* each value is an array of strings associated with the header.
337		*
338		* // Represent the headers as a string
339		* foreach ($message->getHeaders() as $name => $values) {
340		* echo $name . ": " . implode(", ", $values);
341		* }
342		*
343		* @return array returns an associative array of the message's headers.
344		*/
345	2	public function getHeaders()
346		{
347	2	return $this->headers;
348		}
349
350		/**
351		* Sets headers, replacing any headers that have already been set on the message
352		*
353		* The array keys MUST be a string. The array values must be either a
354		* string or an array of strings.
355		*
356		* @param array $headers Headers to set.
357		*
358		* @return void
359		*/
360	1	public function setHeaders(array $headers)
361		{
362	1	$this->headers = $headers;
363	1	}
364
365		/**
366		* Merges in an associative array of headers.
367		*
368		* Each array key MUST be a string representing the case-insensitive name
369		* of a header. Each value MUST be either a string or an array of strings.
370		* For each value, the value is appended to any existing header of the same
371		* name, or, if a header does not already exist by the given name, then the
372		* header is added.
373		*
374		* @param array $headers Associative array of headers to add to the message
375		*
376		* @return void
377		*/
378	1	public function addHeaders(array $headers)
379		{
380	1	$this->headers = array_merge_recursive($this->headers, $headers);
381	1	}
382
383		/**
384		* Remove all headers
385		*
386		* @return void
387		*/
388	6	public function removeHeaders()
389		{
390	6	$this->headers = [];
391	6	}
392
393		/**
394		* Set response body
395		*
396		* @param mixed $body
397		*
398		* @return void
399		*/
400	9	public function setBody($body)
401		{
402	9	$this->body = $body;
403	9	}
404
405		/**
406		* Get response body
407		*
408		* @return Controller\|Layout
409		*/
410	3	public function getBody()
411		{
412	3	return $this->body;
413		}
414
415		/**
416		* Clear response body
417		*
418		* @return void
419		*/
420	5	public function clearBody()
421		{
422	5	$this->body = null;
423	5	}
424
425		/**
426		* Set Cookie
427		*
428		* @param string $name
429		* @param string $value
430		* @param int\|string\|\DateTime $expire
431		* @param string $path
432		* @param string $domain
433		* @param bool $secure
434		* @param bool $httpOnly
435		*
436		* @return void
437		* @throws \InvalidArgumentException
438		*/
439	5	public function setCookie(
440		$name,
441		$value = '',
442		$expire = 0,
443		$path = '/',
444		$domain = '',
445		$secure = false,
446		$httpOnly = false
447		) {
448		// from PHP source code
449	5	if (preg_match("/[=,; \t\r\n\013\014]/", $name)) {
450	1	throw new \InvalidArgumentException('The cookie name contains invalid characters.');
451		}
452
453	4	if (empty($name)) {
454	1	throw new \InvalidArgumentException('The cookie name cannot be empty.');
455		}
456
457		// convert expiration time to a Unix timestamp
458	3	if ($expire instanceof \DateTime) {
459	1	$expire = $expire->format('U');
460	2	} elseif (!is_numeric($expire)) {
461	1	$expire = strtotime($expire);
462	1	if (false === $expire \|\| -1 === $expire) {
463	1	throw new \InvalidArgumentException('The cookie expiration time is not valid.');
464		}
465		}
466
467	2	$this->cookies[$name] = [
468	2	'name' => $name,
469	2	'value' => $value,
470	2	'expire' => $expire,
471	2	'path' => $path,
472	2	'domain' => $domain,
473	2	'secure' => (bool)$secure,
474	2	'httpOnly' => (bool)$httpOnly
475		];
476	2	}
477
478		/**
479		* Get Cookie by name
480		*
481		* @param string $name
482		*
483		* @return array\|null
484		*/
485	2	public function getCookie($name)
486		{
487	2	return $this->cookies[$name] ?? null;
488		}
489
490		/**
491		* Process Cookies to Header
492		*
493		* Set-Cookie: <name>=<value>[; <name>=<value>]...
494		* [; expires=<date>][; domain=<domain_name>]
495		* [; path=<some_path>][; secure][; httponly]
496		*
497		* @return void
498		*/
499	1	protected function sendCookies()
500		{
501	1	foreach ($this->cookies as $cookie) {
502		setcookie(...array_values($cookie));
503		}
504	1	}
505		}
506

bluzphp / framework

Push — master ( d292ba...467d47 )

Response::getProtocolVersion() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like