Borobudur\Http\Header\SetCookieHeader

Complexity

Total Complexity

52

Size/Duplication

Total Lines	499
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	2
Bugs	0	Features	0

29 Methods

Rating	Name	Duplication	Size	Complexity
D	__construct()	0	42	8
A	fromString()	0	9	1
A	create()	0	17	4
A	getFieldName()	0	4	1
A	setName()	0	7	1
A	getName()	0	4	1
A	setValue()	0	7	1
A	getValue()	0	4	1
A	setVersion()	0	10	2
A	getVersion()	0	4	1
A	setMaxAge()	0	6	1
A	getMaxAge()	0	4	1
A	setDomain()	0	4	1
A	getDomain()	0	4	1
A	setPath()	0	4	1
A	getPath()	0	4	1
A	setHttpOnly()	0	6	1
A	isHttpOnly()	0	4	1
A	setSecure()	0	6	1
A	isSecure()	0	4	1
A	setExpires()	0	7	1
A	getExpires()	0	4	1
A	isExpired()	0	6	3
C	getFieldValue()	0	31	7
B	setDirective()	0	28	4
A	__toString()	0	4	1
A	set()	0	7	1
A	get()	0	4	2
A	has()	0	4	1

<?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\Header;

use Borobudur\Http\Header\Exception\InvalidHeaderValueException;
use DateTime;
use DateTimeZone;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     7/28/15
 */
class SetCookieHeader implements HeaderInterface
{
    /**
     * Expires date format.
     */
    const DATE_FORMAT = 'D, d M Y H:i:s \G\M\T';

    /**
     * @var array
     */
    private $parts = array();

    /**
     * @var string
     */
    private $name;

    /**
     * @var string
     */
    private $value;

    /**
     * @var bool
     */
    private $httpOnly = false;

    /**
     * @var bool
     */
    private $secure = false;

    /**
     * Constructor.
     *
     * @param string|null   $name
     * @param string|null   $value
     * @param int|null      $version
     * @param int|null      $maxAge
     * @param string|null   $domain
     * @param string|null   $path
     * @param DateTime|null $expires
     * @param bool|false    $httpOnly
     * @param bool|false    $secure
     */
    public function __construct(
        $name = null,
        $value = null,
        $version = null,
        $maxAge = null,
        $domain = null,
        $path = null,
        DateTime $expires = null,
        $httpOnly = false,
        $secure = false
    ) {
        if (null !== $name) {
            $this->setName($name);
        }

        if (null !== $value) {
            $this->setValue($value);
        }

        if (null !== $version) {
            $this->setVersion($version);
        }

        if (null !== $maxAge) {
            $this->setMaxAge($maxAge);
        }

        if (null !== $domain) {
            $this->setDomain($domain);
        }

        if (null !== $path) {
            $this->setPath($path);
        }

        if (null !== $expires) {
            $this->setExpires($expires);
        }

        $this->setHttpOnly($httpOnly);
        $this->setSecure($secure);
    }

    /**
     * Factory create SetCookieHeader from string representation.
     *
     * @param string $headerLine
     *
     * @return $this
     */
    public static function fromString($headerLine)
    {
        $pos = strpos($headerLine, ':');
        $fieldName = trim(substr($headerLine, 0, $pos));
        $fieldValue = trim(substr($headerLine, $pos + 1));
        GenericHeader::assertHeaderFieldName('Set-Cookie', $fieldName);

        return self::create($fieldValue);
    }

    /**
     * Factory create header.
     *
     * @param string $fieldValue
     *
     * @return $this
     */
    private static function create($fieldValue)
    {
        $header = new static();
        foreach (explode(';', $fieldValue) as $index => $item) {
            $parts = explode('=', $item, 2);

            if (0 === $index) {
                $header->setName($parts[0]);
                $header->setValue($parts[1]);
                continue;
            }

            $header->setDirective($parts[0], isset($parts[1]) ? $parts[1] : null);
        }

        return $header;
    }

    /**
     * Get header field name.
     *
     * @return string
     */
    public function getFieldName()
    {
        return 'Set-Cookie';
    }

    /**
     * Set name.
     *
     * @param string $name
     *
     * @return $this
     */
    public function setName($name)
    {
        GenericHeader::assertHeaderValue($name);
        $this->name = $name;

        return $this;
    }

    /**
     * Get name.
     *
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Set value.
     *
     * @param string $value
     *
     * @return $this
     */
    public function setValue($value)
    {
        GenericHeader::assertHeaderValue($value);
        $this->value = $value;

        return $this;
    }

    /**
     * Get value.
     *
     * @return string
     */
    public function getValue()
    {
        return $this->value;
    }

    /**
     * Set cookie version.
     *
     * @param int $version
     *
     * @return $this
     *
     * @throws InvalidHeaderValueException
     */
    public function setVersion($version)
    {
        if (!is_numeric($version)) {
            throw new InvalidHeaderValueException('Invalid Version number specified');
        }

        $this->set('version', (int) $version);

        return $this;
    }

    /**
     * Get cookie version.
     *
     * @return int|null
     */
    public function getVersion()
    {
        return $this->get('version');
    }

    /**
     * Set cookie max age.
     *
     * @param int $deltaSeconds
     *
     * @return $this
     */
    public function setMaxAge($deltaSeconds)
    {
        $this->set('max-age', GenericHeader::computeDeltaSeconds($deltaSeconds));

        return $this;
    }

    /**
     * Get max age.
     *
     * @return int|null
     */
    public function getMaxAge()
    {
        return $this->get('max-age');
    }

    /**
     * Set cookie domain.
     *
     * @param string $domain
     *
     * @return $this
     */
    public function setDomain($domain)
    {
        return $this->set('domain', $domain);
    }

    /**
     * Get cookie domain.
     *
     * @return string|null
     */
    public function getDomain()
    {
        return $this->get('domain');
    }

    /**
     * Set cookie path.
     *
     * @param string $path
     *
     * @return $this
     */
    public function setPath($path)
    {
        return $this->set('path', $path);
    }

    /**
     * Get cookie path.
     *
     * @return string|null
     */
    public function getPath()
    {
        return $this->get('path');
    }

    /**
     * Set cookie as http only.
     *
     * @param bool $flag
     *
     * @return $this
     */
    public function setHttpOnly($flag = true)
    {
        $this->httpOnly = (bool) $flag;

        return $this;
    }

    /**
     * Check is cookie http only.
     *
     * @return bool
     */
    public function isHttpOnly()
    {
        return $this->httpOnly;
    }

    /**
     * Set secure cookie.
     *
     * @param bool $flag
     *
     * @return $this
     */
    public function setSecure($flag = true)
    {
        $this->secure = (bool) $flag;

        return $this;
    }

    /**
     * Check is cookie secure.
     *
     * @return bool
     */
    public function isSecure()
    {
        return $this->secure;
    }

    /**
     * Set cookie expires.
     *
     * @param DateTime $date
     *
     * @return $this
     */
    public function setExpires(DateTime $date)
    {
        $date->setTimezone(new DateTimeZone('GMT'));
        $this->parts['expires'] = $date;

        return $this;
    }

    /**
     * Get expires.
     *
     * @return DateTime|null
     */
    public function getExpires()
    {
        return $this->get('expires');
    }

    /**
     * Check that cookie has expires.
     *
     * @param DateTime|null $now
     *
     * @return bool
     */
    public function isExpired(DateTime $now = null)
    {
        $now = $now ?: new DateTime('now', new DateTimeZone('GMT'));

        return $this->has('expires') && $this->getExpires() < $now;
    }

    /**
     * Get header field value.
     *
     * @return mixed
     */
    public function getFieldValue()
    {
        if (empty($this->name)) {
            return '';
        }

        $cookie = sprintf('%s=%s', $this->getName(), $this->getValue());

        foreach ($this->parts as $key => $value) {
            if (null === $value) {
                // skip null value (unset)
                continue;
            }

            if ($value instanceof DateTime) {
                $value = $value->format(self::DATE_FORMAT);
            }

            $cookie .= sprintf(';%s=%s', $key, $value);
        }

        if (true === $this->isHttpOnly()) {
            $cookie .= ';HttpOnly';
        }

        if (true === $this->isSecure()) {
            $cookie .= ';Secure';
        }

        return $cookie;
    }

    /**
     * Set cookie directive.
     *
     * @param string $key
     * @param string $value
     *
     * @return $this
     */
    public function setDirective($key, $value)
    {
        $maps = array(
            'httponly' => 'setHttpOnly',
            'secure'   => 'setSecure',
            'version'  => 'setVersion',
            'max-age'  => 'setMaxAge',
            'domain'   => 'setDomain',
            'path'     => 'setPath',
            'expires'  => 'setExpires',
        );

        $key = strtolower($key);

        if (isset($maps[$key])) {
            if (in_array($key, array('httponly', 'secure'))) {
                $value = true;
            } elseif ('expires' === $key) {
                $value = new DateTime($value);
            }

            $this->{$maps[$key]}($value);
        } else {
            $this->set($key, $value);
        }

        return $this;
    }

    /**
     * Cast header to string.
     *
     * @return string
     */
    public function __toString()
    {
        return sprintf('%s: %s', $this->getFieldName(), $this->getFieldValue());
    }

    /**
     * Set cookie part.
     *
     * @param string $key
     * @param string $value
     *
     * @return $this
     */
    private function set($key, $value)
    {
        GenericHeader::assertHeaderValue($value);
        $this->parts[$key] = $value;

        return $this;
    }

    /**
     * Get cookie part by key.
     *
     * @param string $key
     *
     * @return string|int|null
     */
    private function get($key)
    {
        return $this->has($key) ? $this->parts[$key] : null;
    }

    /**
     * Check is parts has key.
     *
     * @param string $key
     *
     * @return bool
     */
    private function has($key)
    {
        return array_key_exists($key, $this->parts);
    }
}