borobudur-php / borobudur-http

src/Response.php

<?php
/*
 * This file is part of the Borobudur-Http package.
 *
 * (c) Hexacodelabs <http://hexacodelabs.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Borobudur\Http;

use Borobudur\Http\Exception\InvalidArgumentException;
use Borobudur\Http\Header\Accept\AcceptHeader;
use Borobudur\Http\Header\CacheControlHeader;
use Borobudur\Http\Header\Content\ContentLengthHeader;
use Borobudur\Http\Header\Content\ContentTypeHeader;
use Borobudur\Http\Header\ExpiresHeader;
use Borobudur\Http\Header\PragmaHeader;
use Borobudur\Http\Header\TransferEncodingHeader;
use DateTime;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     7/30/15
 */
class Response extends AbstractResponse
{
    use HttpStatusTrait;

    /**
     * @const string
     */
    const HTTP_VERSION_10 = '1.0';
    const HTTP_VERSION_11 = '1.1';

    /**
     * @var SetCookieHeaderBag
     */
    public $cookies;

    /**
     * @var int
     */
    protected $chunkLength;

    /**
     * @var int
     */
    protected $chunkDelayResponse;

    /**
     * Constructor.
     *
     * @param string $content
     * @param int    $statusCode
     * @param array  $headers
     * @param array  $cookies
     */
    public function __construct($content = '', $statusCode = 200, array $headers = array(), array $cookies = array())
    {
        $this->headers = new HeaderBag($headers);
        $this->cookies = new SetCookieHeaderBag($cookies);
        $this->setStatusCode($statusCode);
        $this->setContent($content);
        $this->setProtocolVersion(Response::HTTP_VERSION_11);
    }

    /**
     * Prepare Response base on Request.
     *
     * @param Request $request
     *
     * @return $this
     */
    public function prepare(Request $request)
    {
        if ($this->isEmpty() || $this->isInformational()) {
            $this->setContent(null);
            $this->headers->remove('Content-Type');
            $this->headers->remove('Content-Length');
        } else {
            $this->fixContentType($request);
            $this->fixContentLength($request);
        }

        // Fix protocol
        if ('HTTP/1.1' !== $request->getServerBag()->get('SERVER_PROTOCOL')) {
            $this->setProtocolVersion('1.0');
        }

        $this->fixExpire();

        return $this;
    }

    /**
     * Set response as chunked.
     *
     * @param int $length Content split length.
     * @param int $delay  Delay response in microseconds.
     *
     * @return $this
     */
    public function setChunkedTransferEncoding($length = 76, $delay = 1000000)
    {
        $this->headers->set(new TransferEncodingHeader('chunked'), true);
        $this->chunkLength = $length;
        $this->chunkDelayResponse = $delay;

        return $this;
    }

    /**
     * Set response as not modified.
     *
     * @return $this
     */
    public function setNotModified()
    {
        $this->setStatusCode(HttpStatus::HTTP_NOT_MODIFIED);
        $this->setContent(null);

        foreach (
            array(
                'Allow',
                'Content-Encoding',
                'Content-Language',
                'Content-Length',
                'Content-MD5',
                'Content-Type',
                'Transfer-Encoding',
                'Last-Modified',
            ) as $header
        ) {
            $this->headers->remove($header);
        }

        return $this;
    }

    /**
     * Check if response is no cache.
     *
     * @return bool
     */
    public function isNoCache()
    {
        return
            !$this->headers->has('Cache-Control')
            && !$this->headers->has('ETag')
            && !$this->headers->has('Last-Modified')
            && !$this->headers->has('Expires');
    }

    /**
     * Send response to client.
     *
     * @return $this
     */
    public function send()
    {
        $content = $this->computeContent();
        $this->sendHeaders();

        if ($content) {

The expression $content of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            if ($this->isChunked()) {
                $this->sendChunkContent($content);
            } else {
                echo $content;
            }

            if (function_exists('fastcgi_finish_request')) {
                fastcgi_finish_request();
            } else {
                ob_end_flush();
            }
        }

        return $this;
    }

    /**
     * Send response header.
     *
     * @return $this
     */
    public function sendHeaders()
    {
        // check is headers already sent.
        if (headers_sent()) {
            return $this;
        }

        $this->computeContentType();
        $this->headers->set($this->computeCacheControl(), true);

        // send status header
        header(sprintf('HTTP/%s %s %s', $this->version, $this->statusCode, $this->statusText), true, $this->statusCode);
        // send headers
        $this->createHeaders();
        // send cookies header
        $this->createCookieHeaders();

        return $this;
    }

    /**
     * Check if current response is chunked.
     *
     * @return bool
     */
    public function isChunked()
    {
        return
            $this->headers->has('Transfer-Encoding')
            && 'chunked' === $this->headers->first('Transfer-Encoding')->getFieldValue();
    }

    /**
     * Cast Response as string representation.
     *
     * @return string
     */
    public function __toString()
    {
        $content = $this->computeContent();
        $this->computeContentType();
        $this->headers->set($this->computeCacheControl(), true);

        return
            sprintf(sprintf('HTTP/%s %s %s', $this->version, $this->statusCode, $this->statusText)) . "\r\n" .
            $this->headers . "\r\n" .
            $this->cookies . "\r\n" .
            $content;
    }

    /**
     * Add charset if content type exist.
     */
    protected function computeContentType()
    {
        if ($this->headers->has('Content-Type')) {
            /**
             * @var ContentTypeHeader $contentType
             */
            $contentType = $this->headers->first('Content-Type');
            $contentType->setParameter('charset', $this->getCharset());

            $this->headers->set($contentType, true);
        }
    }

    /**
     * Get computed content with specific encoding.
     *
     * @return string
     */
    protected function computeContent()
    {
        if ($this->isNotModified()) {
            $this->setNotModified();

            return null;
        }

        $encoding = $this->fixEncoding();
        $this->headers->set(new ContentLengthHeader($encoding->encode()->getLength()), true);

        if ($this->isChunked()) {
            if ('1.0' === $this->getProtocolVersion()) {
                throw new InvalidArgumentException(sprintf(
                    'Transfer-Encoding chunked need HTTP Protocol version 1.1, "%s" given.',
                    $this->getProtocolVersion()
                ));
            }

            return chunk_split($encoding->getContent(), $this->chunkLength);
        }

        return $encoding->getContent();
    }

    /**
     * Get calculated cache control header.
     *
     * @return CacheControlHeader
     */
    protected function computeCacheControl()
    {
        if ($this->isNoCache()) {
            return (new CacheControlHeader())->setNoCache();
        }

        if (!$this->headers->has('Cache-Control')) {
            return (new CacheControlHeader())->setPrivate()->setMustReValidate();
        }

        /**
         * @var CacheControlHeader $header
         */
        $header = $this->headers->first('Cache-Control', new CacheControlHeader());

        return $header->setAutoPrivilege();
    }

    /**
     * Add content type header from request if not defined.
     *
     * @param Request $request
     */
    private function fixContentType(Request $request)
    {
        // Add content type from request if not defined.
        if (false === $this->headers->has('Content-Type') && true === $request->getHeaderBag()->has('Accept')) {
            /**
             * @var AcceptHeader $acceptHeader
             */
            $acceptHeader = $request->getHeaderBag()->first('Accept');
            // get first accept content type=
            $this->setContentType($acceptHeader->first()->getValue());
        }
    }

    /**
     * Fix content length header.
     *
     * @param Request $request
     */
    private function fixContentLength(Request $request)
    {
        if ($this->headers->has('Transfer-Encoding')) {
            $this->headers->remove('Content-Length');
        }

        if ($request->isMethod(Request::HTTP_METHOD_HEAD)) {
            $contentLengthHeader = $this->headers->first('Content-Length');
            $this->setContent(null);
            if ($length = $contentLengthHeader->getFieldValue()) {
                $this->headers->set(new ContentLengthHeader($length), true);
            }
        }
    }

    /**
     * Send extra expire info if needed.
     */
    private function fixExpire()
    {
        if ('1.0' === $this->getProtocolVersion() && $this->headers->has('Cache-Control')) {
            /**
             * @var CacheControlHeader $cacheControl
             */
            $cacheControl = $this->headers->first('Cache-Control');
            if (true === $cacheControl->isNoCache()) {
                $this->headers->set(new PragmaHeader('no-cache'), true);
                $this->headers->set(new ExpiresHeader(new DateTime('-1 year')), true);
            }
        }
    }

    /**
     * Fix http encoding header.
     */
    private function fixEncoding()
    {
        $encoding = new HttpEncoding($this->content, HttpEncoding::NONE);

        if ($this->headers->has('Content-Encoding')) {
            $contentEncoding = $this->headers->first('Content-Encoding');
            $encoding->setEncoding($contentEncoding->getFieldValue());
        }

        return $encoding;
    }

    /**
     * Send http headers.
     */
    private function createHeaders()
    {
        foreach ($this->headers as $headers) {
            foreach ($headers as $header) {
                header((string) $header, false, $this->statusCode);
            }
        }
    }

    /**
     * Send http cookie headers.
     */
    private function createCookieHeaders()
    {
        foreach ($this->cookies as $cookie) {
            header((string) $cookie, false, $this->statusCode);
        }
    }

    /**
     * Send chunk content.
     *
     * @param string $content
     */
    private function sendChunkContent($content)
    {
        flush();
        ob_flush();

        foreach (explode("\r\n", $content) as $chunk) {
            echo sprintf("%x\r\n", strlen($chunk));
            echo $chunk . "\r\n";
            flush();
            ob_flush();
            usleep($this->chunkDelayResponse);
        }
    }
}