Yiisoft\Yii\Debug\Helper\StreamWrapper\StreamWrapper

Complexity

Total Complexity

27

Size/Duplication

Total Lines	151
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	stream_set_option()	0	7	1
A	stream_open()	0	6	2
A	stream_flush()	0	3	1
A	stream_read()	0	3	2
A	url_stat()	0	12	3
A	stream_close()	0	4	1
A	stream_write()	0	3	1
A	stream_eof()	0	3	1
A	rename()	0	3	1
A	mkdir()	0	3	1
A	stream_tell()	0	3	1
A	dir_rewinddir()	0	3	1
A	stream_lock()	0	3	1
A	stream_seek()	0	3	1
A	dir_readdir()	0	3	1
A	dir_opendir()	0	3	1
A	stream_truncate()	0	3	1
A	dir_closedir()	0	3	1
A	stream_cast()	0	2	1
A	stream_stat()	0	3	1
A	stream_metadata()	0	8	1
A	unlink()	0	3	1
A	rmdir()	0	3	1

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Debug\Helper\StreamWrapper;

use Throwable;

use function trigger_error;

use const E_USER_ERROR;
use const STREAM_MKDIR_RECURSIVE;
use const STREAM_URL_STAT_QUIET;
use const STREAM_USE_PATH;

final class StreamWrapper implements StreamWrapperInterface
{
    /**
     * @var resource|null
     */
    public mixed $context = null;

    public ?string $filename = null;

    /**
     * @var resource|null
     */
    public $stream = null;

    public function dir_closedir(): bool

Method name "StreamWrapper::dir_closedir" is not in camel caps format

    {
        return true;
    }

    public function dir_opendir(string $path, int $options): bool

Method name "StreamWrapper::dir_opendir" is not in camel caps format

    {
        return true;
    }

    public function dir_readdir(): string

Method name "StreamWrapper::dir_readdir" is not in camel caps format

    {
        return readdir($this->stream);
    }

    public function dir_rewinddir(): bool

Method name "StreamWrapper::dir_rewinddir" is not in camel caps format

    {
        return rewinddir($this->stream);

Are you sure the usage of rewinddir($this->stream) is correct as it seems to always return null.

The expression return rewinddir($this->stream) returns the type void which is incompatible with the type-hinted return boolean.

    }

    public function mkdir(string $path, int $mode, int $options): bool
    {
        return mkdir($path, $mode, ($options & STREAM_MKDIR_RECURSIVE) === STREAM_MKDIR_RECURSIVE);
    }

    public function rename(string $path_from, string $path_to): bool
    {
        return rename($path_from, $path_to);
    }

    public function rmdir(string $path, int $options): bool
    {
        return rmdir($path);
    }

    public function stream_cast(int $cast_as)

Method name "StreamWrapper::stream_cast" is not in camel caps format

    {
        //????
    }

    public function stream_eof(): bool

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

    {
        return feof($this->stream);
    }

    public function stream_open(string $path, string $mode, int $options, ?string &$opened_path): bool

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

    {
        $this->filename = realpath($path) ?: $path;
        $this->stream = fopen($path, $mode, ($options & STREAM_USE_PATH) === STREAM_USE_PATH);

        return $this->stream !== false;
    }

    public function stream_read(int $count): string|false

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

    {
        return is_readable($this->filename) ? fread($this->stream, $count) : false;

It seems like $this->filename can also be of type null; however, parameter $filename of is_readable() does only seem to accept string, maybe add an additional type check?

    }

    public function stream_seek(int $offset, int $whence = SEEK_SET): bool

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

    {
        return fseek($this->stream, $offset, $whence) === 0;
    }

    public function stream_set_option(int $option, int $arg1, ?int $arg2): bool

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

    {
        return match ($option) {
            STREAM_OPTION_BLOCKING => stream_set_blocking($this->stream, $arg1 === STREAM_OPTION_BLOCKING),
            STREAM_OPTION_READ_TIMEOUT => stream_set_timeout($this->stream, $arg1, $arg2),

It seems like $arg2 can also be of type null; however, parameter $microseconds of stream_set_timeout() does only seem to accept integer, maybe add an additional type check?

            STREAM_OPTION_WRITE_BUFFER => stream_set_write_buffer($this->stream, $arg2) === 0,

It seems like $arg2 can also be of type null; however, parameter $size of stream_set_write_buffer() does only seem to accept integer, maybe add an additional type check?

            default => false,
        };
    }

    public function stream_stat(): array

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

    {
        return fstat($this->stream);
    }

    public function stream_tell(): int

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

    {
        return ftell($this->stream);
    }

    public function stream_write(string $data): int

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

    {
        return fwrite($this->stream, $data);
    }

    public function url_stat(string $path, int $flags): array|false

Method name "StreamWrapper::url_stat" is not in camel caps format

    {
        try {
            return stat($path);
        } catch (Throwable $e) {
            if (($flags & STREAM_URL_STAT_QUIET) === STREAM_URL_STAT_QUIET) {
                return false;
            }
            trigger_error($e->getMessage(), E_USER_ERROR);
        }

        return false;
    }

    public function stream_metadata(string $path, int $option, mixed $value): bool

Method name "StreamWrapper::stream_metadata" is not in camel caps format

    {
        return match ($option) {
            STREAM_META_TOUCH => touch($path, ...$value),

$value is expanded, but the parameter $mtime of touch() does not expect variable arguments.

            STREAM_META_OWNER_NAME, STREAM_META_OWNER => chown($path, $value),
            STREAM_META_GROUP_NAME, STREAM_META_GROUP => chgrp($path, $value),
            STREAM_META_ACCESS => chmod($path, $value),
            default => false
        };
    }

    public function stream_flush(): bool

Method name "StreamWrapper::stream_flush" is not in camel caps format

    {
        return fflush($this->stream);
    }

    public function stream_close(): void

Method name "StreamWrapper::stream_close" is not in camel caps format

    {
        fclose($this->stream);
        $this->stream = null;
    }

    public function stream_lock(int $operation): bool

Method name "StreamWrapper::stream_lock" is not in camel caps format

    {
        return flock($this->stream, $operation);
    }

    public function stream_truncate(int $new_size): bool

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

    {
        return ftruncate($this->stream, $new_size);
    }

    public function unlink(string $path): bool
    {
        return unlink($path, $this->context);
    }
}