FakeSocket\StreamFactory

Complexity

Total Complexity

22

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

98.28%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	make()	0	22	3
A	__construct()	0	8	2
B	register()	0	26	4
A	withProtocol()	0	4	1
A	withHost()	0	4	1
A	withPort()	0	11	3
A	withRead()	0	4	1
A	withWrite()	0	4	1
A	withoutRead()	0	4	1
A	withoutWrite()	0	4	1
A	withReadAfter()	0	4	1
A	withWriteAfter()	0	4	1
A	withReadEvery()	0	4	1
A	withWriteEvery()	0	4	1

<?php
declare(strict_types=1);

namespace FakeSocket;

use FakeSocket\{
    CanCopy,

This use statement conflicts with another class in this namespace, FakeSocket\CanCopy.

    StreamException,

This use statement conflicts with another class in this namespace, FakeSocket\StreamException.

    StreamWrapper,

This use statement conflicts with another class in this namespace, FakeSocket\StreamWrapper.

    Stream\Buffer
};
use InvalidArgumentException;

final class StreamFactory
{
    use CanCopy;

    /** @const int */
    private const MIN_PORT = 1;

    /** @const int 16bit */
    private const MAX_PORT = 65535;

    /** @var string */
    private $protocol;

    /** @var string */
    private $spec;

    /** @var string */
    private $host;

    /** @var int */
    private $port;

    /** @var int */
    private $read;

    /** @var int */
    private $readAfter;

    /** @var int */
    private $readEvery;

    /** @var int */
    private $write;

    /** @var int */
    private $writeAfter;

    /** @var int */
    private $writeEvery;

    public static function make(string $dataSourceName): self
    {
        $components = parse_url($dataSourceName);

        $host = $components['host'] ?? $components['path'];

        if (!isset($host)) {
            throw StreamException::invalidDataSource();
        }

        static $defaultSpec = Buffer::class;

        $factory = new self($defaultSpec);
        $factory->protocol = $components['scheme'] ?? 'fake';
        $factory->host = $host;

        if (isset($components['port'])) {
            $factory = $factory->withPort($components['port']);
        }

        return $factory;
    }

    public function __construct(string $spec)
    {
        if (!is_subclass_of($spec, StreamWrapper::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \FakeSocket\StreamWrapper::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            throw StreamException::invalidClass($spec);
        }

        $this->spec = $spec;
    }

    public function register(): string
    {
        if (in_array($this->protocol, stream_get_wrappers())) {
            stream_wrapper_unregister($this->protocol);
        }

        stream_wrapper_register($this->protocol, $this->spec);

        if (isset($this->port)) {
            $this->host = "{$this->host}:{$this->port}";
        }

        $query = [
            'read'        => $this->read,
            'read_after'  => $this->readAfter,
            'read_every'  => $this->readEvery,
            'write'       => $this->write,
            'write_after' => $this->writeAfter,
            'write_every' => $this->writeEvery,
        ];

        $query = http_build_query($query);
        empty($query) ?: $query = "/?$query";

        return "{$this->protocol}://{$this->host}{$query}";
    }

    public function withProtocol(string $protocol): self
    {
        return $this->copy('protocol', $protocol);
    }

    public function withHost(string $host): self
    {
        return $this->copy('host', $host);
    }

    public function withPort(int $port): self
    {
        if ($port < self::MIN_PORT || $port > self::MAX_PORT) {
            throw StreamException::invalidPortRange(
                self::MIN_PORT,
                self::MAX_PORT
            );
        }

        return $this->copy('port', $port);
    }

    public function withRead(int $limit = -1): self
    {
        return $this->copy('read', $limit);
    }

    public function withWrite(int $limit = -1): self
    {
        return $this->copy('write', $limit);
    }

    public function withoutRead(): self
    {
        return $this->copy('read', 0);
    }

    public function withoutWrite(): self
    {
        return $this->copy('write', 0);
    }

    public function withReadAfter(int $limit = 0): self
    {
        return $this->copy('readAfter', $limit);
    }

    public function withWriteAfter(int $limit = 0): self
    {
        return $this->copy('writeAfter', $limit);
    }

    public function withReadEvery(int $limit = 1): self
    {
        return $this->copy('readEvery', $limit);
    }

    public function withWriteEvery(int $limit = 1): self
    {
        return $this->copy('writeEvery', $limit);
    }
}