App\DeferredResponse

Complexity

Total Complexity

25

Size/Duplication

Total Lines	135
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	formatResponse()	0	3	1
A	getStatusCode()	0	3	1
A	withProtocolVersion()	0	4	1
A	hasHeader()	0	3	1
A	withBody()	0	4	1
A	getHeaders()	0	3	1
A	getHeader()	0	3	1
A	withResponseFormatter()	0	8	2
A	withAddedHeader()	0	4	1
A	getHeaderLine()	0	3	1
A	withStatus()	0	4	1
A	getBody()	0	20	5
A	getResponse()	0	3	1
A	getReasonPhrase()	0	3	1
A	getData()	0	3	2
A	getProtocolVersion()	0	3	1
A	withoutHeader()	0	4	1
A	withHeader()	0	4	1

<?php

namespace App;

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

class DeferredResponse implements ResponseInterface
{
    private ResponseInterface $response;

    private StreamFactoryInterface $streamFactory;

    private $data;

    private ?StreamInterface $dataStream = null;

    private ?ResponseFormatterInterface $responseFormatter = null;

    public function __construct($data, ResponseFactoryInterface $responseFactory, StreamFactoryInterface $streamFactory)
    {
        $this->response = $responseFactory->createResponse();
        $this->streamFactory = $streamFactory;
        $this->data = $data;
    }

    public function getBody()
    {
        if ($this->dataStream !== null) {
            return $this->dataStream;
        }

        if (is_callable($this->data)) {
            $this->data = ($this->data)();
        }

        if ($this->responseFormatter !== null) {
            $this->response = $this->formatResponse();
            return $this->dataStream = $this->response->getBody();
        }

        if (is_string($this->data)) {
            return $this->dataStream = $this->streamFactory->createStream($this->data);
        }

        throw new \RuntimeException('Data must be a string value.');
    }

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

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

    public function getHeaders()
    {
        return $this->response->getHeaders();
    }

    public function getProtocolVersion()
    {
        return $this->response->getProtocolVersion();
    }

    public function getReasonPhrase()
    {
        return $this->response->getReasonPhrase();
    }

    public function getStatusCode()
    {
        return $this->response->getStatusCode();
    }

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

    public function withAddedHeader($name, $value)
    {
        $this->response = $this->response->withAddedHeader($name, $value);
        return clone $this;
    }

    public function withBody(StreamInterface $body)
    {
        $this->dataStream = $body;
        return clone $this;
    }

    public function withHeader($name, $value)
    {
        $this->response = $this->response->withHeader($name, $value);
        return clone $this;
    }

    public function withoutHeader($name)
    {
        $this->response = $this->response->withoutHeader($name);
        return clone $this;
    }

    public function withProtocolVersion($version)
    {
        $this->response = $this->response->withProtocolVersion($version);
        return clone $this;
    }

    public function withStatus($code, $reasonPhrase = '')
    {
        $this->response = $this->response->withStatus($code, $reasonPhrase);
        return clone $this;
    }

    public function withResponseFormatter(ResponseFormatterInterface $responseFormatter)
    {
        if ($this->responseFormatter !== null) {
            return $this;
        }
        $this->responseFormatter = $responseFormatter;

        return clone $this;
    }

    public function getResponse(): ResponseInterface
    {
        return $this->response;
    }

    public function getData()
    {
        return is_object($this->data) ? clone $this->data : $this->data;
    }

    private function formatResponse(): ResponseInterface
    {
        return $this->responseFormatter->format($this);

The method format() does not exist on null.

    }
}