roxblnfk\SmartStream\Stream\BucketStream

Complexity

Total Complexity

47

Size/Duplication

Total Lines	167
Duplicated Lines	0 %

Test Coverage

Coverage

21.18%

Importance

Changes	3
Bugs	0	Features	0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	rewind()	0	4	2
A	withBucket()	0	3	1
A	getConverter()	0	3	2
A	tell()	0	3	2
A	isWritable()	0	3	1
A	getMatchedFormat()	0	3	2
A	getMetadata()	0	12	2
A	getMatchedResult()	0	3	1
A	isSeekable()	0	3	1
A	seek()	0	3	1
A	close()	0	3	1
A	write()	0	3	1
A	isReadable()	0	7	3
A	eof()	0	3	2
A	getBucket()	0	3	1
A	getContents()	0	3	1
A	read()	0	7	2
A	detach()	0	6	1
A	isRenderStarted()	0	3	1
A	__construct()	0	12	4
A	hasConverter()	0	3	1
A	hasBucketFormat()	0	3	2
A	__toString()	0	9	3
A	hasMatchedFormat()	0	3	1
A	initConverter()	0	10	4
A	getSize()	0	3	2
A	getBucketFormat()	0	3	2

<?php

declare(strict_types=1);

namespace roxblnfk\SmartStream\Stream;

use Psr\Http\Message\StreamInterface;
use roxblnfk\SmartStream\ConverterInterface;
use roxblnfk\SmartStream\ConverterMatcherInterface;
use roxblnfk\SmartStream\Data\DataBucket;
use roxblnfk\SmartStream\Exception\ConverterNotFoundException;
use roxblnfk\SmartStream\Matching\MatchingResult;

final class BucketStream implements StreamInterface
{
    private ConverterMatcherInterface $converterMatcher;
    private ?DataBucket $bucket;
    private ?GeneratorStream $stream = null;
    private ?MatchingResult $matchedResult = null;

    public function __construct(ConverterMatcherInterface $converterMatcher, DataBucket $bucket)
    {
        $this->bucket = $bucket;
        $this->converterMatcher = $converterMatcher;

        if ($bucket->isConvertable()) {
            $result = $this->converterMatcher->match($this->bucket);
            // if should be converted but no converter was found
            if ($result === null && $bucket->hasFormat()) {
                throw new ConverterNotFoundException($bucket->getFormat());
            }
            $this->matchedResult = $result;
        }
    }
    public function __toString(): string
    {
        try {
            if ($this->isSeekable()) {
                $this->seek(0);
            }
            return $this->getContents();
        } catch (\Exception $e) {
            return '';
        }
    }
    public function close(): void
    {
        $this->detach();
    }
    public function detach()
    {
        $this->matchedResult = null;
        $this->stream = null;
        $this->bucket = null;
        return null;
    }
    public function getSize(): ?int
    {
        return $this->stream === null ? null : $this->stream->getSize();
    }
    public function tell(): int
    {
        return $this->stream === null ? 0 : $this->stream->tell();
    }
    public function eof(): bool
    {
        return $this->stream === null ? false : $this->stream->eof();
    }
    public function isSeekable(): bool
    {
        return false;
    }
    public function seek($offset, $whence = \SEEK_SET): void
    {
        throw new \RuntimeException('Stream is not seekable.');
    }
    public function rewind(): void
    {
        if ($this->stream !== null) {
            $this->stream->rewind();
        }
    }
    public function isWritable(): bool
    {
        return false;
    }
    public function write($string): int
    {
        throw new \RuntimeException('Cannot write to a non-writable stream.');
    }
    public function isReadable(): bool
    {
        if ($this->matchedResult === null) {
            return false;
        }
        $this->initConverter();
        return $this->stream === null ? false : $this->stream->isReadable();
    }
    public function read($length): string
    {
        if (!$this->isReadable()) {
            throw new \RuntimeException('Stream should be rendered.');
        }
        # read generator stream
        return $this->stream->read($length);

The method read() does not exist on null.

    }
    public function getContents(): string
    {
        return $this->read(PHP_INT_MAX);
    }
    public function getMetadata($key = null)
    {
        $meta = [
            'seekable' => $this->isSeekable(),
            'eof' => $this->eof(),
        ];

        if (null === $key) {
            return $meta;
        }

        return $meta[$key] ?? null;
    }

    public function withBucket(DataBucket $bucket): self
    {
        return new static($this->converterMatcher, $bucket);
    }

    public function hasConverter(): bool
    {
        return $this->matchedResult !== null;
    }
    public function getConverter(): ?ConverterInterface
    {
        return $this->matchedResult === null ? null : $this->matchedResult->getConverter();
    }

    public function hasBucketFormat(): bool
    {
        return $this->bucket === null ? false : $this->bucket->hasFormat();
    }
    public function getBucketFormat(): ?string
    {
        return $this->bucket === null ? null : $this->bucket->getFormat();
    }

    public function hasMatchedFormat(): bool
    {
        return $this->matchedResult !== null;
    }
    public function getMatchedFormat(): ?string
    {
        return $this->matchedResult === null ? null : $this->matchedResult->getFormat();
    }

    public function isRenderStarted(): bool
    {
        return $this->stream !== null;
    }

    public function getBucket(): ?DataBucket
    {
        return $this->bucket;
    }
    public function getMatchedResult(): ?MatchingResult
    {
        return $this->matchedResult;
    }

    private function initConverter(): bool
    {
        if ($this->stream !== null) {
            return true;
        }
        if ($this->matchedResult === null || $this->bucket === null) {
            return false;
        }
        $this->stream = new GeneratorStream($this->matchedResult->getConverter()->convert($this->bucket));
        return true;
    }
}