FakeSocket\Stream\Buffer

Complexity

Total Complexity

27

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

92.54%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	stream_open()	0	14	2
A	stream_eof()	0	4	1
A	stream_tell()	0	4	1
A	stream_write()	0	15	2
A	stream_read()	0	18	3
A	stream_seek()	0	17	4
A	stream_stat()	0	4	1
A	stream_truncate()	0	15	2
A	stream_set_option()	0	4	1
A	configureLimits()	0	14	4
A	canRead()	0	8	3
A	canWrite()	0	8	3

<?php
declare(strict_types=1);

namespace FakeSocket\Stream;

use FakeSocket\StreamWrapper;

final class Buffer implements StreamWrapper
{
    /** @var string */
    private $stream = '';

    /** @var int */
    private $position = 0;

    /** @var int */
    private $readCount = 0;

    /** @var int */
    private $writeCount = 0;

    /** @var array */
    private $limits = [
        'read'        => -1,
        'read_after'  => 0,
        'read_every'  => 1,
        'write'       => -1,
        'write_after' => 0,
        'write_every' => 1,
    ];

    public function stream_open($path, $mode, $options, &$opened_path)

The parameter $mode is not used and could be removed.

The parameter $options is not used and could be removed.

The parameter $opened_path is not used and could be removed.

Method name "Buffer::stream_open" is not in camel caps format

    {
        $components = parse_url($path);

        static $query = [];

        if (isset($components['query'])) {
            parse_str($components['query'], $query);
        }

        $this->configureLimits($query);

It seems like $query can also be of type null; however, FakeSocket\Stream\Buffer::configureLimits() does only seem to accept array, maybe add an additional type check?

        return true;
    }

    public function stream_eof()

Method name "Buffer::stream_eof" is not in camel caps format

    {
        return $this->position >= strlen($this->stream);
    }

    public function stream_tell()

Method name "Buffer::stream_tell" is not in camel caps format

    {
        return $this->position;
    }

    public function stream_write($data)

Method name "Buffer::stream_write" is not in camel caps format

    {
        ++$this->writeCount;

        if (!$this->canWrite()) {
            return false;
        }

        $left = substr($this->stream, 0, $this->position);

        $this->stream = "{$left}{$data}";
        $this->position += $bytesWritten = strlen($data);

        return $bytesWritten;
    }

    public function stream_read($count)

Method name "Buffer::stream_read" is not in camel caps format

    {
        ++$this->readCount;

        if (!$this->canRead()) {
            return false;
        }

        $data = substr($this->stream, $this->position, $count);

        if (false === $data) {
            return false;
        }

        $this->position += strlen($data);

        return $data;
    }

    public function stream_seek($offset, $whence)

Method name "Buffer::stream_seek" is not in camel caps format

    {
        static $values = [SEEK_SET, SEEK_CUR, SEEK_END];

        if (in_array($whence, $values)) {
            if (SEEK_END === $whence) {
                $offset = strlen($this->stream) + $offset;
            }

            if ($offset >= 0) {
                $this->position = $offset;
                return true;
            }
        }

        return false;
    }

    public function stream_stat()

Method name "Buffer::stream_stat" is not in camel caps format

    {
        return [];
    }

    public function stream_truncate($new_size)

Method name "Buffer::stream_truncate" is not in camel caps format

    {
        $currentLength = strlen($this->stream);

        if ($new_size > $currentLength) {
            $multiplier = $new_size - $currentLength;
            $this->stream .= str_repeat(chr(0), $multiplier);

            return true;
        }

        $this->stream = substr($this->stream, 0, $new_size);

        return true;
    }

    public function stream_set_option($option, $arg1, $arg2)

Method name "Buffer::stream_set_option" is not in camel caps format

    {
        return true;
    }

    private function configureLimits(array $query): void
    {
        foreach (array_keys($this->limits) as $limit) {
            if (!isset($query[$limit])) {
                continue;
            }

            if (false !== strrpos($limit, 'every')) {
                $query[$limit] = max(1, (int) $query[$limit]);
            }

            $this->limits[$limit] = (int) $query[$limit];
        }
    }

    private function canRead(): bool
    {
        $noLimit = $this->readCount !== $this->limits['read'] + 1;

        return $noLimit
            && $this->readCount > $this->limits['read_after']
            && $this->readCount % $this->limits['read_every'] === 0;
    }

    private function canWrite(): bool
    {
        $noLimit = $this->writeCount !== $this->limits['write'] + 1;

        return $noLimit
            && $this->writeCount > $this->limits['write_after']
            && $this->writeCount % $this->limits['write_every'] === 0;
    }
}