Borobudur\Http\Header\AllowHeader

Complexity

Total Complexity

24

Size/Duplication

Total Lines	231
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	3
A	allowMethod()	0	6	1
A	setState()	0	9	2
A	setAllState()	0	6	2
A	fromString()	0	12	2
A	allowMethods()	0	8	2
A	disallowMethods()	0	8	2
A	disallowMethod()	0	6	1
A	getAllowedMethods()	0	4	1
A	getDisallowedMethods()	0	4	1
A	isMethodAllowed()	0	8	2
A	isMethodDisallowed()	0	4	1
A	__toString()	0	4	1
A	getFieldName()	0	4	1
A	getFieldValue()	0	4	1
A	getAllMethods()	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 Borobudur\Http\Request;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     7/19/15
 */
class AllowHeader implements HeaderInterface
{
    /**
     * List of request methods, true state indicate that method is allowed
     * and false is disallowed.
     * By default GET and POST are allowed.
     *
     * @var array
     */
    private $methods = array(
        Request::HTTP_METHOD_GET     => true,
        Request::HTTP_METHOD_POST    => true,
        Request::HTTP_METHOD_PATCH   => false,
        Request::HTTP_METHOD_PUT     => false,
        Request::HTTP_METHOD_OPTIONS => false,
        Request::HTTP_METHOD_HEAD    => false,
    );

    /**
     * Constructor.
     *
     * @param array $allowedMethods
     */
    public function __construct(array $allowedMethods = array())
    {
        if (!empty($allowedMethods)) {
            $this->setAllState(false);
            foreach ($allowedMethods as $method) {
                $this->allowMethod($method);
            }
        }
    }

    /**
     * Allow method.
     *
     * @param string $method
     *
     * @return $this
     */
    public function allowMethod($method)
    {
        $this->setState($method, true);

        return $this;
    }

    /**
     * Change method state.
     *
     * @param string $method
     * @param bool   $state
     *
     * @throws InvalidHeaderValueException
     */
    private function setState($method, $state)
    {
        $method = trim(strtoupper($method));
        if (false === array_key_exists($method, $this->methods)) {
            throw new InvalidHeaderValueException(sprintf('Method "%s" is not supported.', $method));
        }

        $this->methods[$method] = $state;
    }

    /**
     * Set all method state.
     *
     * @param bool $state
     */
    private function setAllState($state)
    {
        foreach (array_keys($this->methods) as $method) {
            $this->methods[$method] = $state;
        }
    }

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

        if ($fieldValue !== null) {
            $fieldValue = array_filter(explode(',', $fieldValue), 'trim');
            $fieldValue = array_map('trim', $fieldValue);
        }

        return new static($fieldValue);
    }

    /**
     * Allow sets of method.
     *
     * @param array $methods
     *
     * @return $this
     */
    public function allowMethods(array $methods)
    {
        foreach ($methods as $method) {
            $this->allowMethod($method);
        }

        return $this;
    }

    /**
     * Disallow sets of method.
     *
     * @param array $methods
     *
     * @return $this
     */
    public function disallowMethods(array $methods)
    {
        foreach ($methods as $method) {
            $this->disallowMethod($method);
        }

        return $this;
    }

    /**
     * Disallow method.
     *
     * @param string $method
     *
     * @return $this
     */
    public function disallowMethod($method)
    {
        $this->setState($method, false);

        return $this;
    }

    /**
     * Get allowed methods.
     *
     * @return array
     */
    public function getAllowedMethods()
    {
        return array_keys($this->methods, true, true);
    }

    /**
     * Get disallowed methods.
     *
     * @return array
     */
    public function getDisallowedMethods()
    {
        return array_keys($this->methods, false, true);
    }

    /**
     * Check that method is allowed.
     *
     * @param string $method
     *
     * @return bool Return true if method is allowed, false otherwise
     */
    public function isMethodAllowed($method)
    {
        $method = trim(strtoupper($method));

        return !isset($this->methods[$method])
            ? false //unknown method mark as disallowed
            : true === $this->methods[$method];
    }

    /**
     * Check that method is disallowed.
     *
     * @param string $method
     *
     * @return bool Return true if method is disallowed, false otherwise
     */
    public function isMethodDisallowed($method)
    {
        return false === $this->isMethodAllowed($method);
    }

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

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

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

    /**
     * Get all methods.
     *
     * @return array
     */
    public function getAllMethods()
    {
        return $this->methods;
    }
}