StreamWrapper::getStreamStats() - Code Metrics - Inspection of "Adding PHP 8.4 to GitHub Actions" - spiral/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#1205)

by Aleksei
created 2025-01-27 12:26 UTC
StreamWrapper::getStreamStats() A

↳ Parent: StreamWrapper
Complexity

Conditions	5
Paths	7
Size

Total Lines	27
Code Lines	20
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	21
CRAP Score	5
Importance

Changes
Metric	Value
eloc	20
dl	0
loc	27
ccs	21
cts	21
cp	1
rs	9.2888
c	0
b	0
f	0
cc	5
nc	7
nop	1
crap	5
<?php

declare(strict_types=1);

namespace Spiral\Streams;

use Psr\Http\Message\StreamInterface;
use Spiral\Streams\Exception\WrapperException;

/**
 * Spiral converter of PSR-7 streams to virtual filenames. Static as hell.
 */
final class StreamWrapper
{
    /**
     * Stream context.
     *
     * @var resource
     */
    public mixed $context = null;

    private static bool $registered = false;

    /**
     * Uris associated with StreamInterfaces.
     */
    private static array $uris = [];

    private static array $modes = [
        'r'   => 33060,
        'rb'  => 33060,
        'r+'  => 33206,
        'rb+' => 33206,
        'w'   => 33188,
        'wb'  => 33188,
    ];
    private ?StreamInterface $stream = null;
    private string $mode = '';

    /**
     * Register stream wrapper.
     */
    public static function register(): void
    {
        if (self::$registered) {
            return;
        }

        \stream_wrapper_register('spiral', self::class);

        self::$registered = true;
    }

    /**
     * Check if given uri or stream has been allocated.
     */
    public static function has(StreamInterface|string $file): bool
    {
        if ($file instanceof StreamInterface) {
            $file = 'spiral://' . \spl_object_hash($file);
        }

        return isset(self::$uris[$file]);
    }

    /**
     * Create StreamInterface associated resource.
     *
     * @return resource
     * @throws WrapperException
     */
    public static function getResource(StreamInterface $stream)
    {
        $mode = null;
        if ($stream->isReadable()) {
            $mode = 'r';
        }

        if ($stream->isWritable()) {
            $mode = !empty($mode) ? 'r+' : 'w';
        }

        if (empty($mode)) {
            throw new WrapperException('Stream is not available in read or write modes');
        }

        $result = \fopen(self::getFilename($stream), $mode);
        return $result === false
            ? throw new WrapperException(\sprintf('Unable to open stream `%s`.', $stream->getMetadata('uri')))
            ? throw new WrapperException(\sprintf('Unable to open stream `%s`.', /** @scrutinizer ignore-type */ $stream->getMetadata('uri')))
            : $result;
    }

    /**
     * Register StreamInterface and get unique url for it.
     */
    public static function getFilename(StreamInterface $stream): string
    {
        self::register();

        $uri = 'spiral://' . \spl_object_hash($stream);
        self::$uris[$uri] = $stream;

        return $uri;
    }

    /**
     * Free uri dedicated to specified StreamInterface. Method is useful for long living
     * applications. You must close resource by yourself!
     *
     * @param string|StreamInterface $file String uri or StreamInterface.
     */
    public static function release(StreamInterface|string $file): void
    {
        if ($file instanceof StreamInterface) {
            $file = 'spiral://' . \spl_object_hash($file);
        }

        unset(self::$uris[$file]);
    }

    /**
     * Check if StreamInterface ended.
     */
    public function stream_eof(): bool
    {
        if ($this->stream === null) {
            throw new WrapperException('Stream is not opened.');
        }

        return $this->stream->eof();
    }

    /**
     * Open pre-mocked StreamInterface by it's unique uri.
     */
    public function stream_open(string $path, string $mode, int $options, ?string &$opened_path): bool
    public function stream_open(string $path, string $mode, int $options, /** @scrutinizer ignore-unused */ ?string &$opened_path): bool
    {
        if (!isset(self::$uris[$path])) {
            return false;
        }

        $this->stream = self::$uris[$path];
        $this->mode = $mode;

        $this->stream->rewind();
                       rewind();

        return true;
    }

    /**
     * Read data from StreamInterface.
     */
    public function stream_read(int $length): string|false
    {
        if ($this->stream === null) {
            throw new WrapperException('Stream is not opened.');
        }

        return $this->stream->isReadable() ? $this->stream->read($length) : false;
    }

    /**
     * Seek into StreamInterface.
     */
    public function stream_seek(int $offset, int $whence = SEEK_SET): bool
    {
        if ($this->stream === null) {
            throw new WrapperException('Stream is not opened.');
        }

        //Note, MongoDB native streams DO NOT support seeking at the moment
        //@see https://jira.mongodb.org/browse/PHPLIB-213
        $this->stream->seek($offset, $whence);

        return true;
    }

    /**
     * Get StreamInterface stats.
     *
     * @see stat()
     */
    public function stream_stat(): array
    {
        if ($this->stream === null) {
            throw new WrapperException('Stream is not opened.');
        }

        return $this->getStreamStats($this->stream);
    }

    /**
     * Get StreamInterface position.
     */
    public function stream_tell(): int
    {
        if ($this->stream === null) {
            throw new WrapperException('Stream is not opened.');
        }

        //Note, MongoDB native streams DO NOT support seeking at the moment
        //@see https://jira.mongodb.org/browse/PHPLIB-213
        return $this->stream->tell();
    }

    /**
     * Write content into StreamInterface.
     */
    public function stream_write(string $data): int
    {
        if ($this->stream === null) {
            throw new WrapperException('Stream is not opened.');
        }

        return $this->stream->write($data);
    }

    /**
     * Get stats based on wrapped StreamInterface by it's mocked uri.
     *
     * @see stat()
     */
    public function url_stat(string $path, int $flag): array|false
    {
        try {
            if (isset(self::$uris[$path])) {
                return $this->getStreamStats(self::$uris[$path]);
            }
        } catch (\Throwable $e) {
            if (($flag & \STREAM_URL_STAT_QUIET) === \STREAM_URL_STAT_QUIET) {
                return false;
            }
            \trigger_error($e->getMessage(), \E_USER_ERROR);
        }

        return false;
    }

    /**
     * Helper method used to correctly resolve StreamInterface stats.
     */
    private function getStreamStats(StreamInterface $stream): array
    {
        $mode = $this->mode;
        if (empty($mode)) {
            if ($stream->isReadable()) {
                $mode = 'r';
            }

            if ($stream->isWritable()) {
                $mode = !empty($mode) ? 'r+' : 'w';
            }
        }

        return [
            'dev'     => 0,
            'ino'     => 0,
            'mode'    => self::$modes[$mode],
            'nlink'   => 0,
            'uid'     => 0,
            'gid'     => 0,
            'rdev'    => 0,
            'size'    => (string) $stream->getSize(),
            'atime'   => 0,
            'mtime'   => 0,
            'ctime'   => 0,
            'blksize' => 0,
            'blocks'  => 0,
        ];
    }
}

spiral / framework

Pull Request — master (#1205)

StreamWrapper::getStreamStats() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
