Http\Adapter\Artax\Internal\ResponseStream

Complexity

Total Complexity

25

Size/Duplication

Total Lines	140
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

98.39%

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	__toString()	0	8	2
A	__destruct()	0	4	1
A	close()	0	8	1
A	detach()	0	4	1
A	getSize()	0	4	1
A	tell()	0	4	1
A	eof()	0	4	1
A	isSeekable()	0	4	1
A	seek()	0	4	1
A	rewind()	0	4	1
A	isWritable()	0	4	1
A	write()	0	4	1
A	isReadable()	0	4	1
B	read()	0	28	6
A	getContents()	0	10	2
A	getMetadata()	0	4	2

<?php

namespace Http\Adapter\Artax\Internal;

use Amp\Artax;
use Amp\ByteStream\InputStream;
use Amp\ByteStream\IteratorStream;
use Amp\CancellationTokenSource;
use Amp\CancelledException;
use Amp\Emitter;
use Amp\Promise;

This use statement conflicts with another class in this namespace, Http\Adapter\Artax\Internal\Promise.

use Psr\Http\Message\StreamInterface;

/**
 * PSR-7 stream implementation that converts an `Amp\ByteStream\InputStream` into a PSR-7 compatible stream.
 *
 * @internal
 */
class ResponseStream implements StreamInterface
{
    private $buffer = '';

    private $position = 0;

    private $eof = false;

    private $body;

    private $cancellationTokenSource;

    /**
     * @param InputStream             $body                    HTTP response stream to wrap.
     * @param CancellationTokenSource $cancellationTokenSource Cancellation source bound to the request to abort it.
     */
    public function __construct(InputStream $body, CancellationTokenSource $cancellationTokenSource)
    {
        $this->body = $body;
        $this->cancellationTokenSource = $cancellationTokenSource;
    }

    public function __toString()
    {
        try {
            return $this->getContents();
        } catch (\Throwable $e) {
            return '';
        }
    }

    public function __destruct()
    {
        $this->close();
    }

    public function close()
    {
        $this->cancellationTokenSource->cancel();

        $emitter = new Emitter();
        $emitter->fail(new Artax\HttpException('The stream has been closed'));
        $this->body = new IteratorStream($emitter->iterate());
    }

    public function detach()
    {
        $this->close();
    }

    public function getSize()
    {
        return null;
    }

    public function tell()
    {
        return $this->position;
    }

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

    public function isSeekable()
    {
        return false;
    }

    public function seek($offset, $whence = SEEK_SET)
    {
        throw new \RuntimeException('Stream is not seekable');
    }

    public function rewind()
    {
        $this->seek(0);
    }

    public function isWritable()
    {
        return false;
    }

    public function write($string)
    {
        throw new \RuntimeException('Stream is not writable');
    }

    public function isReadable()
    {
        return true;
    }

    public function read($length)
    {
        if ($this->eof) {
            return '';
        }

        if ('' === $this->buffer) {
            try {
                $this->buffer = Promise\wait($this->body->read());
            } catch (Artax\HttpException $e) {
                throw new \RuntimeException('Reading from the stream failed', 0, $e);
            } catch (CancelledException $e) {
                throw new \RuntimeException('Reading from the stream failed', 0, $e);
            }

            if (null === $this->buffer) {
                $this->eof = true;

                return '';
            }
        }

        $read = \substr($this->buffer, 0, $length);
        $this->buffer = (string) \substr($this->buffer, $length);
        $this->position += \strlen($read);

        return $read;
    }

    public function getContents()
    {
        $buffer = '';

        while (!$this->eof()) {
            $buffer .= $this->read(8192 * 8);
        }

        return $buffer;
    }

    public function getMetadata($key = null)
    {
        return null === $key ? [] : null;
    }
}