AbstractResponse::header() - Code Metrics - Inspection of "Merge pull request #15 from php-school/composer-in..." - php-school/learn-you-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 93f6e0...a7ea34 )

by Aydin

created 2015-12-30 14:22 UTC

AbstractResponse::header() A

↳ Parent: AbstractResponse

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
c	2
b	0
f	1
dl	0
loc	6
rs	9.4286
cc	1
eloc	3
nc	1
nop	2

<?php
/**
 * Klein (klein.php) - A fast & flexible router for PHP
 *
 * @author      Chris O'Hara <[email protected]>
 * @author      Trevor Suarez (Rican7) (contributor and v2 refactorer)
 * @copyright   (c) Chris O'Hara
 * @link        https://github.com/chriso/klein.php
 * @license     MIT
 */

namespace Klein;

use Klein\DataCollection\HeaderDataCollection;
use Klein\DataCollection\ResponseCookieDataCollection;
use Klein\Exceptions\LockedResponseException;
use Klein\Exceptions\ResponseAlreadySentException;
use Klein\ResponseCookie;

/**
 * AbstractResponse
 */
abstract class AbstractResponse
{

    /**
     * Properties
     */

    /**
     * The default response HTTP status code
     *
     * @type int
     */
    protected static $default_status_code = 200;

    /**
     * The HTTP version of the response
     *
     * @type string
     */
    protected $protocol_version = '1.1';

    /**
     * The response body
     *
     * @type string
     */
    protected $body;

    /**
     * HTTP response status
     *
     * @type HttpStatus
     */
    protected $status;

    /**
     * HTTP response headers
     *
     * @type HeaderDataCollection
     */
    protected $headers;

    /**
     * HTTP response cookies
     *
     * @type ResponseCookieDataCollection
     */
    protected $cookies;

    /**
     * Whether or not the response is "locked" from
     * any further modification
     *
     * @type boolean
     */
    protected $locked = false;

    /**
     * Whether or not the response has been sent
     *
     * @type boolean
     */
    protected $sent = false;

    /**
     * Whether the response has been chunked or not
     *
     * @type boolean
     */
    public $chunked = false;


    /**
     * Methods
     */

    /**
     * Constructor
     *
     * Create a new AbstractResponse object with a dependency injected Headers instance
     *
     * @param string $body          The response body's content
     * @param int $status_code      The status code
     * @param array $headers        The response header "hash"
     */
    public function __construct($body = '', $status_code = null, array $headers = array())
    {
        $status_code   = $status_code ?: static::$default_status_code;

        // Set our body and code using our internal methods
        $this->body($body);
        $this->code($status_code);

        $this->headers = new HeaderDataCollection($headers);
        $this->cookies = new ResponseCookieDataCollection();
    }

    /**
     * Get (or set) the HTTP protocol version
     *
     * Simply calling this method without any arguments returns the current protocol version.
     * Calling with an integer argument, however, attempts to set the protocol version to what
     * was provided by the argument.
     *
     * @param string $protocol_version
     * @return string|AbstractResponse
     */
    public function protocolVersion($protocol_version = null)
    {
        if (null !== $protocol_version) {
            // Require that the response be unlocked before changing it
            $this->requireUnlocked();

            $this->protocol_version = (string) $protocol_version;

            return $this;
        }

        return $this->protocol_version;
    }

    /**
     * Get (or set) the response's body content
     *
     * Simply calling this method without any arguments returns the current response body.
     * Calling with an argument, however, sets the response body to what was provided by the argument.
     *
     * @param string $body  The body content string
     * @return string|AbstractResponse
     */
    public function body($body = null)
    {
        if (null !== $body) {
            // Require that the response be unlocked before changing it
            $this->requireUnlocked();

            $this->body = (string) $body;

            return $this;
        }

        return $this->body;
    }

    /**
     * Returns the status object
     *
     * @return \Klein\HttpStatus
     */
    public function status()
    {
        return $this->status;
    }

    /**
     * Returns the headers collection
     *
     * @return HeaderDataCollection
     */
    public function headers()
    {
        return $this->headers;
    }

    /**
     * Returns the cookies collection
     *
     * @return ResponseCookieDataCollection
     */
    public function cookies()
    {
        return $this->cookies;
    }

    /**
     * Get (or set) the HTTP response code
     *
     * Simply calling this method without any arguments returns the current response code.
     * Calling with an integer argument, however, attempts to set the response code to what
     * was provided by the argument.
     *
     * @param int $code     The HTTP status code to send
     * @return int|AbstractResponse
     */
    public function code($code = null)
    {
        if (null !== $code) {
            // Require that the response be unlocked before changing it
            $this->requireUnlocked();

            $this->status = new HttpStatus($code);

            return $this;
        }

        return $this->status->getCode();
    }

    /**
     * Prepend a string to the response's content body
     *
     * @param string $content   The string to prepend
     * @return AbstractResponse
     */
    public function prepend($content)
    {
        // Require that the response be unlocked before changing it
        $this->requireUnlocked();

        $this->body = $content . $this->body;

        return $this;
    }

    /**
     * Append a string to the response's content body
     *
     * @param string $content   The string to append
     * @return AbstractResponse
     */
    public function append($content)
    {
        // Require that the response be unlocked before changing it
        $this->requireUnlocked();

        $this->body .= $content;

        return $this;
    }

    /**
     * Check if the response is locked
     *
     * @return boolean
     */
    public function isLocked()
    {
        return $this->locked;
    }

    /**
     * Require that the response is unlocked
     *
     * Throws an exception if the response is locked,
     * preventing any methods from mutating the response
     * when its locked
     *
     * @throws LockedResponseException  If the response is locked
     * @return AbstractResponse
     */
    public function requireUnlocked()
    {
        if ($this->isLocked()) {
            throw new LockedResponseException('Response is locked');
        }

        return $this;
    }

    /**
     * Lock the response from further modification
     *
     * @return AbstractResponse
     */
    public function lock()
    {
        $this->locked = true;

        return $this;
    }

    /**
     * Unlock the response from further modification
     *
     * @return AbstractResponse
     */
    public function unlock()
    {
        $this->locked = false;

        return $this;
    }

    /**
     * Generates an HTTP compatible status header line string
     *
     * Creates the string based off of the response's properties
     *
     * @return string
     */
    protected function httpStatusLine()
    {
        return sprintf('HTTP/%s %s', $this->protocol_version, $this->status);
    }

    /**
     * Send our HTTP headers
     *
     * @param boolean $cookies_also Whether or not to also send the cookies after sending the normal headers
     * @param boolean $override     Whether or not to override the check if headers have already been sent
     * @return AbstractResponse
     */
    public function sendHeaders($cookies_also = true, $override = false)
    {
        if (headers_sent() && !$override) {
            return $this;
        }

        // Send our HTTP status line
        header($this->httpStatusLine());

        // Iterate through our Headers data collection and send each header
        foreach ($this->headers as $key => $value) {
            header($key .': '. $value, false);
        }

        if ($cookies_also) {
            $this->sendCookies($override);
        }

        return $this;
    }

    /**
     * Send our HTTP response cookies
     *
     * @param boolean $override     Whether or not to override the check if headers have already been sent
     * @return AbstractResponse
     */
    public function sendCookies($override = false)
    {
        if (headers_sent() && !$override) {
            return $this;
        }

        // Iterate through our Cookies data collection and set each cookie natively
        foreach ($this->cookies as $cookie) {
            // Use the built-in PHP "setcookie" function
            setcookie(
                $cookie->getName(),
                $cookie->getValue(),
                $cookie->getExpire(),
                $cookie->getPath(),
                $cookie->getDomain(),
                $cookie->getSecure(),
                $cookie->getHttpOnly()
            );
        }

        return $this;
    }

    /**
     * Send our body's contents
     *
     * @return AbstractResponse
     */
    public function sendBody()
    {
        echo (string) $this->body;

        return $this;
    }

    /**
     * Send the response and lock it
     *
     * @param boolean $override             Whether or not to override the check if the response has already been sent
     * @throws ResponseAlreadySentException If the response has already been sent
     * @return AbstractResponse
     */
    public function send($override = false)
    {
        if ($this->sent && !$override) {
            throw new ResponseAlreadySentException('Response has already been sent');
        }

        // Send our response data
        $this->sendHeaders();
        $this->sendBody();

        // Lock the response from further modification
        $this->lock();

        // Mark as sent
        $this->sent = true;

        // If there running FPM, tell the process manager to finish the server request/response handling
        if (function_exists('fastcgi_finish_request')) {
            fastcgi_finish_request();
        }

        return $this;
    }

    /**
     * Check if the response has been sent
     *
     * @return boolean
     */
    public function isSent()
    {
        return $this->sent;
    }

    /**
     * Enable response chunking
     *
     * @link https://github.com/chriso/klein.php/wiki/Response-Chunking
     * @link http://bit.ly/hg3gHb
     * @return AbstractResponse
     */
    public function chunk()
    {
        if (false === $this->chunked) {
            $this->chunked = true;
            $this->header('Transfer-encoding', 'chunked');
            flush();
        }

        if (($body_length = strlen($this->body)) > 0) {
            printf("%x\r\n", $body_length);
            $this->sendBody();
            $this->body('');
            echo "\r\n";
            flush();
        }

        return $this;
    }

    /**
     * Sets a response header
     *
     * @param string $key       The name of the HTTP response header
     * @param mixed $value      The value to set the header with
     * @return AbstractResponse
     */
    public function header($key, $value)
    {
        $this->headers->set($key, $value);

        return $this;
    }

    /**
     * Sets a response cookie
     *
     * @param string $key           The name of the cookie
     * @param string $value         The value to set the cookie with
     * @param int $expiry           The time that the cookie should expire
     * @param string $path          The path of which to restrict the cookie
     * @param string $domain        The domain of which to restrict the cookie
     * @param boolean $secure       Flag of whether the cookie should only be sent over a HTTPS connection
     * @param boolean $httponly     Flag of whether the cookie should only be accessible over the HTTP protocol
     * @return AbstractResponse
     */
    public function cookie(
        $key,
        $value = '',
        $expiry = null,
        $path = '/',
        $domain = null,
        $secure = false,
        $httponly = false
    ) {
        if (null === $expiry) {
            $expiry = time() + (3600 * 24 * 30);
        }

        $this->cookies->set(
            $key,
            new ResponseCookie($key, $value, $expiry, $path, $domain, $secure, $httponly)
        );

        return $this;
    }

    /**
     * Tell the browser not to cache the response
     *
     * @return AbstractResponse
     */
    public function noCache()
    {
        $this->header('Pragma', 'no-cache');
        $this->header('Cache-Control', 'no-store, no-cache');

        return $this;
    }

    /**
     * Redirects the request to another URL
     *
     * @param string $url   The URL to redirect to
     * @param int $code     The HTTP status code to use for redirection
     * @return AbstractResponse
     */
    public function redirect($url, $code = 302)
    {
        $this->code($code);
        $this->header('Location', $url);
        $this->lock();

        return $this;
    }
}


1			<?php
2			/**
3			* Klein (klein.php) - A fast & flexible router for PHP
4			*
5			* @author Chris O'Hara <[email protected]>
6			* @author Trevor Suarez (Rican7) (contributor and v2 refactorer)
7			* @copyright (c) Chris O'Hara
8			* @link https://github.com/chriso/klein.php
9			* @license MIT
10			*/
11
12			namespace Klein;
13
14			use Klein\DataCollection\HeaderDataCollection;
15			use Klein\DataCollection\ResponseCookieDataCollection;
16			use Klein\Exceptions\LockedResponseException;
17			use Klein\Exceptions\ResponseAlreadySentException;
18			use Klein\ResponseCookie;
19
20			/**
21			* AbstractResponse
22			*/
23			abstract class AbstractResponse
24			{
25
26			/**
27			* Properties
28			*/
29
30			/**
31			* The default response HTTP status code
32			*
33			* @type int
34			*/
35			protected static $default_status_code = 200;
36
37			/**
38			* The HTTP version of the response
39			*
40			* @type string
41			*/
42			protected $protocol_version = '1.1';
43
44			/**
45			* The response body
46			*
47			* @type string
48			*/
49			protected $body;
50
51			/**
52			* HTTP response status
53			*
54			* @type HttpStatus
55			*/
56			protected $status;
57
58			/**
59			* HTTP response headers
60			*
61			* @type HeaderDataCollection
62			*/
63			protected $headers;
64
65			/**
66			* HTTP response cookies
67			*
68			* @type ResponseCookieDataCollection
69			*/
70			protected $cookies;
71
72			/**
73			* Whether or not the response is "locked" from
74			* any further modification
75			*
76			* @type boolean
77			*/
78			protected $locked = false;
79
80			/**
81			* Whether or not the response has been sent
82			*
83			* @type boolean
84			*/
85			protected $sent = false;
86
87			/**
88			* Whether the response has been chunked or not
89			*
90			* @type boolean
91			*/
92			public $chunked = false;
93
94
95			/**
96			* Methods
97			*/
98
99			/**
100			* Constructor
101			*
102			* Create a new AbstractResponse object with a dependency injected Headers instance
103			*
104			* @param string $body The response body's content
105			* @param int $status_code The status code
106			* @param array $headers The response header "hash"
107			*/
108			public function __construct($body = '', $status_code = null, array $headers = array())
109			{
110			$status_code = $status_code ?: static::$default_status_code;
111
112			// Set our body and code using our internal methods
113			$this->body($body);
114			$this->code($status_code);
115
116			$this->headers = new HeaderDataCollection($headers);
117			$this->cookies = new ResponseCookieDataCollection();
118			}
119
120			/**
121			* Get (or set) the HTTP protocol version
122			*
123			* Simply calling this method without any arguments returns the current protocol version.
124			* Calling with an integer argument, however, attempts to set the protocol version to what
125			* was provided by the argument.
126			*
127			* @param string $protocol_version
128			* @return string\|AbstractResponse
129			*/
130			public function protocolVersion($protocol_version = null)
131			{
132			if (null !== $protocol_version) {
133			// Require that the response be unlocked before changing it
134			$this->requireUnlocked();
135
136			$this->protocol_version = (string) $protocol_version;
137
138			return $this;
139			}
140
141			return $this->protocol_version;
142			}
143
144			/**
145			* Get (or set) the response's body content
146			*
147			* Simply calling this method without any arguments returns the current response body.
148			* Calling with an argument, however, sets the response body to what was provided by the argument.
149			*
150			* @param string $body The body content string
151			* @return string\|AbstractResponse
152			*/
153			public function body($body = null)
154			{
155			if (null !== $body) {
156			// Require that the response be unlocked before changing it
157			$this->requireUnlocked();
158
159			$this->body = (string) $body;
160
161			return $this;
162			}
163
164			return $this->body;
165			}
166
167			/**
168			* Returns the status object
169			*
170			* @return \Klein\HttpStatus
171			*/
172			public function status()
173			{
174			return $this->status;
175			}
176
177			/**
178			* Returns the headers collection
179			*
180			* @return HeaderDataCollection
181			*/
182			public function headers()
183			{
184			return $this->headers;
185			}
186
187			/**
188			* Returns the cookies collection
189			*
190			* @return ResponseCookieDataCollection
191			*/
192			public function cookies()
193			{
194			return $this->cookies;
195			}
196
197			/**
198			* Get (or set) the HTTP response code
199			*
200			* Simply calling this method without any arguments returns the current response code.
201			* Calling with an integer argument, however, attempts to set the response code to what
202			* was provided by the argument.
203			*
204			* @param int $code The HTTP status code to send
205			* @return int\|AbstractResponse
206			*/
207			public function code($code = null)
208			{
209			if (null !== $code) {
210			// Require that the response be unlocked before changing it
211			$this->requireUnlocked();
212
213			$this->status = new HttpStatus($code);
214
215			return $this;
216			}
217
218			return $this->status->getCode();
219			}
220
221			/**
222			* Prepend a string to the response's content body
223			*
224			* @param string $content The string to prepend
225			* @return AbstractResponse
226			*/
227			public function prepend($content)
228			{
229			// Require that the response be unlocked before changing it
230			$this->requireUnlocked();
231
232			$this->body = $content . $this->body;
233
234			return $this;
235			}
236
237			/**
238			* Append a string to the response's content body
239			*
240			* @param string $content The string to append
241			* @return AbstractResponse
242			*/
243			public function append($content)
244			{
245			// Require that the response be unlocked before changing it
246			$this->requireUnlocked();
247
248			$this->body .= $content;
249
250			return $this;
251			}
252
253			/**
254			* Check if the response is locked
255			*
256			* @return boolean
257			*/
258			public function isLocked()
259			{
260			return $this->locked;
261			}
262
263			/**
264			* Require that the response is unlocked
265			*
266			* Throws an exception if the response is locked,
267			* preventing any methods from mutating the response
268			* when its locked
269			*
270			* @throws LockedResponseException If the response is locked
271			* @return AbstractResponse
272			*/
273			public function requireUnlocked()
274			{
275			if ($this->isLocked()) {
276			throw new LockedResponseException('Response is locked');
277			}
278
279			return $this;
280			}
281
282			/**
283			* Lock the response from further modification
284			*
285			* @return AbstractResponse
286			*/
287			public function lock()
288			{
289			$this->locked = true;
290
291			return $this;
292			}
293
294			/**
295			* Unlock the response from further modification
296			*
297			* @return AbstractResponse
298			*/
299			public function unlock()
300			{
301			$this->locked = false;
302
303			return $this;
304			}
305
306			/**
307			* Generates an HTTP compatible status header line string
308			*
309			* Creates the string based off of the response's properties
310			*
311			* @return string
312			*/
313			protected function httpStatusLine()
314			{
315			return sprintf('HTTP/%s %s', $this->protocol_version, $this->status);
316			}
317
318			/**
319			* Send our HTTP headers
320			*
321			* @param boolean $cookies_also Whether or not to also send the cookies after sending the normal headers
322			* @param boolean $override Whether or not to override the check if headers have already been sent
323			* @return AbstractResponse
324			*/
325			public function sendHeaders($cookies_also = true, $override = false)
326			{
327			if (headers_sent() && !$override) {
328			return $this;
329			}
330
331			// Send our HTTP status line
332			header($this->httpStatusLine());
333
334			// Iterate through our Headers data collection and send each header
335			foreach ($this->headers as $key => $value) {
336			header($key .': '. $value, false);
337			}
338
339			if ($cookies_also) {
340			$this->sendCookies($override);
341			}
342
343			return $this;
344			}
345
346			/**
347			* Send our HTTP response cookies
348			*
349			* @param boolean $override Whether or not to override the check if headers have already been sent
350			* @return AbstractResponse
351			*/
352			public function sendCookies($override = false)
353			{
354			if (headers_sent() && !$override) {
355			return $this;
356			}
357
358			// Iterate through our Cookies data collection and set each cookie natively
359			foreach ($this->cookies as $cookie) {
360			// Use the built-in PHP "setcookie" function
361			setcookie(
362			$cookie->getName(),
363			$cookie->getValue(),
364			$cookie->getExpire(),
365			$cookie->getPath(),
366			$cookie->getDomain(),
367			$cookie->getSecure(),
368			$cookie->getHttpOnly()
369			);
370			}
371
372			return $this;
373			}
374
375			/**
376			* Send our body's contents
377			*
378			* @return AbstractResponse
379			*/
380			public function sendBody()
381			{
382			echo (string) $this->body;
383
384			return $this;
385			}
386
387			/**
388			* Send the response and lock it
389			*
390			* @param boolean $override Whether or not to override the check if the response has already been sent
391			* @throws ResponseAlreadySentException If the response has already been sent
392			* @return AbstractResponse
393			*/
394			public function send($override = false)
395			{
396			if ($this->sent && !$override) {
397			throw new ResponseAlreadySentException('Response has already been sent');
398			}
399
400			// Send our response data
401			$this->sendHeaders();
402			$this->sendBody();
403
404			// Lock the response from further modification
405			$this->lock();
406
407			// Mark as sent
408			$this->sent = true;
409
410			// If there running FPM, tell the process manager to finish the server request/response handling
411			if (function_exists('fastcgi_finish_request')) {
412			fastcgi_finish_request();
413			}
414
415			return $this;
416			}
417
418			/**
419			* Check if the response has been sent
420			*
421			* @return boolean
422			*/
423			public function isSent()
424			{
425			return $this->sent;
426			}
427
428			/**
429			* Enable response chunking
430			*
431			* @link https://github.com/chriso/klein.php/wiki/Response-Chunking
432			* @link http://bit.ly/hg3gHb
433			* @return AbstractResponse
434			*/
435			public function chunk()
436			{
437			if (false === $this->chunked) {
438			$this->chunked = true;
439			$this->header('Transfer-encoding', 'chunked');
440			flush();
441			}
442
443			if (($body_length = strlen($this->body)) > 0) {
444			printf("%x\r\n", $body_length);
445			$this->sendBody();
446			$this->body('');
447			echo "\r\n";
448			flush();
449			}
450
451			return $this;
452			}
453
454			/**
455			* Sets a response header
456			*
457			* @param string $key The name of the HTTP response header
458			* @param mixed $value The value to set the header with
459			* @return AbstractResponse
460			*/
461			public function header($key, $value)
462			{
463			$this->headers->set($key, $value);
464
465			return $this;
466			}
467
468			/**
469			* Sets a response cookie
470			*
471			* @param string $key The name of the cookie
472			* @param string $value The value to set the cookie with
473			* @param int $expiry The time that the cookie should expire
474			* @param string $path The path of which to restrict the cookie
475			* @param string $domain The domain of which to restrict the cookie
476			* @param boolean $secure Flag of whether the cookie should only be sent over a HTTPS connection
477			* @param boolean $httponly Flag of whether the cookie should only be accessible over the HTTP protocol
478			* @return AbstractResponse
479			*/
480			public function cookie(
481			$key,
482			$value = '',
483			$expiry = null,
484			$path = '/',
485			$domain = null,
486			$secure = false,
487			$httponly = false
488			) {
489			if (null === $expiry) {
490			$expiry = time() + (3600 * 24 * 30);
491			}
492
493			$this->cookies->set(
494			$key,
495			new ResponseCookie($key, $value, $expiry, $path, $domain, $secure, $httponly)
496			);
497
498			return $this;
499			}
500
501			/**
502			* Tell the browser not to cache the response
503			*
504			* @return AbstractResponse
505			*/
506			public function noCache()
507			{
508			$this->header('Pragma', 'no-cache');
509			$this->header('Cache-Control', 'no-store, no-cache');
510
511			return $this;
512			}
513
514			/**
515			* Redirects the request to another URL
516			*
517			* @param string $url The URL to redirect to
518			* @param int $code The HTTP status code to use for redirection
519			* @return AbstractResponse
520			*/
521			public function redirect($url, $code = 302)
522			{
523			$this->code($code);
524			$this->header('Location', $url);
525			$this->lock();
526
527			return $this;
528			}
529			}
530

php-school / learn-you-php

Push — master ( 93f6e0...a7ea34 )

AbstractResponse::header() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like