Borobudur\Http\Header\GenericHeader

Complexity

Total Complexity

23

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	fromString()	0	6	1
A	splitHeaderLine()	0	19	3
A	computeDeltaSeconds()	0	13	3
B	isValidHeaderValue()	0	17	6
A	assertEmptyHeaderFieldName()	0	9	2
A	assertHeaderFieldName()	0	6	2
A	assertHeaderValue()	0	6	2
A	getFieldName()	0	4	1
A	getFieldValue()	0	4	1
A	__toString()	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\Exception\InvalidArgumentException;
use Borobudur\Http\Header\Exception\InvalidHeaderValueException;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     7/19/15
 */
class GenericHeader implements HeaderInterface
{
    /**
     * @var string
     */
    private $fieldName;

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

    /**
     * Constructor.
     *
     * @param string $fieldName
     * @param string $fieldValue
     */
    public function __construct($fieldName, $fieldValue)
    {
        $this->fieldName  = $fieldName;
        $this->fieldValue = $fieldValue;
    }

    /**
     * Factory create GenericHeader from string representation.
     *
     * @param string $headerLine
     *
     * @return $this
     */
    public static function fromString($headerLine)
    {
        list($fieldName, $fieldValue) = self::splitHeaderLine($headerLine);

        return new static($fieldName, $fieldValue);
    }

    /**
     * Split name and value by header line.
     *
     * @param string $headerLine
     *
     * @return array
     *
     * @throws InvalidArgumentException
     */
    public static function splitHeaderLine($headerLine)
    {
        $parts = explode(':', (string) $headerLine, 2);

        if (2 !== count($parts)) {
            throw new InvalidArgumentException(sprintf(
                'Header must match with format "name: value", "%s" given.',
                $headerLine
            ));
        }

        if (!self::isValidHeaderValue($parts[1])) {
            throw new InvalidArgumentException('Invalid header value.');
        }

        $parts[1] = ltrim($parts[1]);

        return $parts;
    }

    /**
     * Compute delta seconds.
     *
     * @param int $deltaSeconds
     *
     * @return int
     */
    public static function computeDeltaSeconds($deltaSeconds)
    {
        if (!is_numeric($deltaSeconds)) {
            throw new InvalidHeaderValueException(sprintf(
                'Delta seconds should be integer, "%s" given',
                $deltaSeconds
            ));
        }

        $max = PHP_INT_MAX;

        return $deltaSeconds > $max ? $max : (int)$deltaSeconds;
    }

    /**
     * Check if header value is valid based on RFC 7230.
     * Borrowed from Zend-Framework.
     *
     * @see http://en.wikipedia.org/wiki/HTTP_response_splitting
     *
     * @param string $value
     *
     * @return bool
     */
    public static function isValidHeaderValue($value)
    {
        $value  = (string) $value;
        $length = strlen($value);
        for ($i = 0; $i < $length; $i += 1) {
            $ascii = ord($value[$i]);

            if (($ascii < 32 && $ascii !== 9)
                || $ascii === 127
                || $ascii > 254
            ) {
                return false;
            }
        }

        return true;
    }

    /**
     * Assert empty header field name.
     *
     * @param string $headerName
     */
    public static function assertEmptyHeaderFieldName($headerName)
    {
        if (null === $headerName) {
            throw new InvalidHeaderValueException(sprintf(
                'Header name not defined on class "%s".',
                get_called_class()
            ));
        }
    }

    /**
     * Assert match header field name.
     *
     * @param string $fieldName
     * @param string $givenFieldName
     *
     * @throws InvalidHeaderValueException
     */
    public static function assertHeaderFieldName($fieldName, $givenFieldName)
    {
        if (strtolower($fieldName) !== strtolower($givenFieldName)) {
            throw InvalidHeaderValueException::invalidHeaderName($givenFieldName, $fieldName);
        }
    }

    /**
     * Assert header value.
     *
     * @param string $value
     *
     * @throws InvalidHeaderValueException
     */
    public static function assertHeaderValue($value)
    {
        if (!GenericHeader::isValidHeaderValue($value)) {
            throw InvalidHeaderValueException::invalidValue($value);
        }
    }
    
    /**
     * Get header field name.
     *
     * @return string
     */
    public function getFieldName()
    {
        return $this->fieldName;
    }

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

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