Muzzle\Messages\ResponseDecorator

Complexity

Total Complexity

23

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__call()	0	12	3
A	getHeader()	0	4	1
A	getStatusCode()	0	4	1
A	withBody()	0	4	1
A	withProtocolVersion()	0	4	1
A	hasHeader()	0	4	1
A	__get()	0	8	2
A	__construct()	0	4	1
A	withStatus()	0	4	1
A	getProtocolVersion()	0	4	1
A	__isset()	0	4	1
A	withoutHeader()	0	4	1
A	withHeader()	0	4	1
A	fromBaseResponse()	0	8	2
A	getBody()	0	4	1
A	getHeaderLine()	0	4	1
A	getHeaders()	0	4	1
A	withAddedHeader()	0	4	1
A	getReasonPhrase()	0	4	1

<?php

namespace Muzzle\Messages;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\StreamInterface;

trait ResponseDecorator
{

    /**
     * @var ResponseInterface
     */
    protected $response;

    public function __construct(ResponseInterface $response)
    {

        $this->response = $response;
    }

    /**
     * Create a new AssertableResponse from another response.
     *
     * @param  ResponseInterface $response
     * @return self
     */
    public static function fromBaseResponse($response)
    {

        if ($response instanceof static) {
            return $response;
        }

        return new static($response);
    }

    /**
     * {@inheritdoc}
     */
    public function getProtocolVersion()
    {

        return $this->response->getProtocolVersion();
    }

    /**
     * {@inheritdoc}
     */
    public function withProtocolVersion($version)
    {

        return static::fromBaseResponse($this->response->withProtocolVersion($version));
    }

    /**
     * {@inheritdoc}
     */
    public function getHeaders()
    {

        return $this->response->getHeaders();
    }

    /**
     * {@inheritdoc}
     */
    public function hasHeader($name)
    {

        return $this->response->hasHeader($name);
    }

    /**
     * {@inheritdoc}
     */
    public function getHeader($name)
    {

        return $this->response->getHeader($name);
    }

    /**
     * {@inheritdoc}
     */
    public function getHeaderLine($name)
    {

        return $this->response->getHeaderLine($name);
    }

    /**
     * {@inheritdoc}
     */
    public function withHeader($name, $value)
    {

        return static::fromBaseResponse($this->response->withHeader($name, $value));
    }

    /**
     * {@inheritdoc}
     */
    public function withAddedHeader($name, $value)
    {

        return static::fromBaseResponse($this->response->withAddedHeader($name, $value));
    }

    /**
     * {@inheritdoc}
     */
    public function withoutHeader($name)
    {

        return static::fromBaseResponse($this->response->withoutHeader($name));
    }

    /**
     * {@inheritdoc}
     */
    public function getBody()
    {

        return $this->response->getBody();
    }

    /**
     * {@inheritdoc}
     */
    public function withBody(StreamInterface $body)
    {

        return static::fromBaseResponse($this->response->withBody($body));
    }

    /**
     * {@inheritdoc}
     */
    public function getStatusCode()
    {

        return $this->response->getStatusCode();
    }

    /**
     * {@inheritdoc}
     */
    public function withStatus($code, $reasonPhrase = '')
    {

        return static::fromBaseResponse($this->response->withStatus($code, $reasonPhrase));
    }

    /**
     * {@inheritdoc}
     */
    public function getReasonPhrase()
    {

        return $this->response->getReasonPhrase();
    }

    public function __get($property)
    {

        if (property_exists($this->response, $property)) {
            return $this->response->{$property};
        }

        return null;
    }

    public function __call($method, $arguments)
    {

        if (method_exists($this->response, $method)) {
            $response = $this->response->{$method}(...$arguments);
            if (starts_with($method, 'with')) {
                return static::fromBaseResponse($response);
            }
            return $response;
        }

        throw new \BadMethodCallException("The method \"$method\" is not defined.");
    }

    /**
     * Proxy isset() checks to the underlying base response.
     *
     * @param  string $key
     * @return mixed
     */
    public function __isset($key)
    {

        return isset($this->response->{$key});
    }
}