Yiisoft\Yii\Debug\Collector\Stream\HttpStreamProxy

Complexity

Total Complexity

43

Size/Duplication

Total Lines	263
Duplicated Lines	0 %

Importance

Changes

0

30 Methods

Rating	Name	Duplication	Size	Complexity
A	stream_cast()	0	3	1
A	stream_read()	0	23	3
A	stream_seek()	0	3	1
A	isIgnored()	0	9	3
A	stream_tell()	0	3	1
A	stream_close()	0	3	1
A	dir_closedir()	0	3	1
A	__destruct()	0	7	2
A	rmdir()	0	11	2
A	__construct()	0	4	1
A	mkdir()	0	12	2
A	dir_rewinddir()	0	3	1
A	url_stat()	0	3	1
A	stream_open()	0	4	1
A	stream_metadata()	0	3	1
A	dir_readdir()	0	9	2
A	dir_opendir()	0	3	1
A	stream_eof()	0	3	1
A	stream_set_option()	0	3	1
A	stream_write()	0	10	2
A	__call()	0	7	1
A	stream_stat()	0	3	1
A	rename()	0	11	2
A	stream_truncate()	0	3	1
A	__get()	0	3	1
A	unregister()	0	8	2
A	unlink()	0	9	2
A	stream_lock()	0	3	1
A	stream_flush()	0	3	1
A	register()	0	14	2

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Debug\Collector\Stream;

use Yiisoft\Yii\Debug\Helper\BacktraceIgnoreMatcher;
use Yiisoft\Yii\Debug\Helper\StreamWrapper\StreamWrapper;
use Yiisoft\Yii\Debug\Helper\StreamWrapper\StreamWrapperInterface;

use const SEEK_SET;

class HttpStreamProxy implements StreamWrapperInterface
{
    public static bool $registered = false;
    public static array $ignoredPathPatterns = [];
    public static array $ignoredClasses = [];
    public static array $ignoredUrls = [];
    /**
     * @var resource|null
     */
    public $context;
    public StreamWrapperInterface $decorated;
    public bool $ignored = false;

    public static ?HttpStreamCollector $collector = null;
    public array $operations = [];

    public function __construct()
    {
        $this->decorated = new StreamWrapper();
        $this->decorated->context = $this->context;

Accessing context on the interface Yiisoft\Yii\Debug\Helper\StreamWrapper\StreamWrapperInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    public function __call(string $name, array $arguments)
    {
        try {
            self::unregister();
            return $this->decorated->{$name}(...$arguments);
        } finally {
            self::register();
        }
    }

    public function __destruct()
    {
        foreach ($this->operations as $name => $operation) {
            self::$collector->collect(

The method collect() does not exist on null.

                operation: $name,
                path: $operation['path'],
                args: $operation['args'],
            );
        }
    }

    public function __get(string $name)
    {
        return $this->decorated->{$name};
    }

    public static function register(): void
    {
        if (self::$registered) {
            return;
        }
        /**
         * It's important to trigger autoloader before unregistering the file stream handler
         */
        class_exists(StreamWrapper::class);
        stream_wrapper_unregister('http');
        stream_wrapper_register('http', self::class, STREAM_IS_URL);
        stream_wrapper_unregister('https');
        stream_wrapper_register('https', self::class, STREAM_IS_URL);
        self::$registered = true;
    }

    public static function unregister(): void
    {
        if (!self::$registered) {
            return;
        }
        @stream_wrapper_restore('http');

It seems like you do not handle an error condition for stream_wrapper_restore(). This can introduce security issues, and is generally not recommended.

        @stream_wrapper_restore('https');
        self::$registered = false;
    }

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

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

    {
        $this->ignored = $this->isIgnored($path);
        return $this->__call(__FUNCTION__, func_get_args());
    }

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

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

    {
        if (!$this->ignored) {
            $metadata = stream_get_meta_data($this->decorated->stream);

Accessing stream on the interface Yiisoft\Yii\Debug\Helper\StreamWrapper\StreamWrapperInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            $context = $this->decorated->context === null

Accessing context on the interface Yiisoft\Yii\Debug\Helper\StreamWrapper\StreamWrapperInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                ? null
                : stream_context_get_options($this->decorated->context);
            /**
             * @link https://www.php.net/manual/en/context.http.php
             */
            $method = $context['http']['method'] ?? $context['https']['method'] ?? 'GET';
            $headers = (array) ($context['http']['header'] ?? $context['https']['header'] ?? []);

            $this->operations['read'] = [
                'path' => $this->decorated->filename,

Accessing filename on the interface Yiisoft\Yii\Debug\Helper\StreamWrapper\StreamWrapperInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                'args' => [
                    'method' => $method,
                    'response_headers' => $metadata['wrapper_data'],
                    'request_headers' => $headers,
                ],
            ];
        }
        return $this->__call(__FUNCTION__, func_get_args());
    }

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

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function stream_tell(): int

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function stream_eof(): bool

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

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

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function stream_cast(int $castAs)

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function stream_stat(): array|false

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function dir_closedir(): bool

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

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

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function dir_readdir(): false|string

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

    {
        if (!$this->ignored) {
            $this->operations[__FUNCTION__] = [
                'path' => $this->decorated->filename,

Accessing filename on the interface Yiisoft\Yii\Debug\Helper\StreamWrapper\StreamWrapperInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                'args' => [],
            ];
        }
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function dir_rewinddir(): bool

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function mkdir(string $path, int $mode, int $options): bool
    {
        if (!$this->ignored) {
            $this->operations[__FUNCTION__] = [
                'path' => $path,
                'args' => [
                    'mode' => $mode,
                    'options' => $options,
                ],
            ];
        }
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function rename(string $path_from, string $path_to): bool
    {
        if (!$this->ignored) {
            $this->operations[__FUNCTION__] = [
                'path' => $path_from,
                'args' => [
                    'path_to' => $path_to,
                ],
            ];
        }
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function rmdir(string $path, int $options): bool
    {
        if (!$this->ignored) {
            $this->operations[__FUNCTION__] = [
                'path' => $path,
                'args' => [
                    'options' => $options,
                ],
            ];
        }
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function stream_close(): void

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

    {
        $this->__call(__FUNCTION__, func_get_args());
    }

    public function stream_flush(): bool

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function stream_lock(int $operation): bool

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

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

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function stream_truncate(int $new_size): bool

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function stream_write(string $data): int

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

    {
        if (!$this->ignored) {
            $this->operations['write'] = [
                'path' => $this->decorated->filename,

Accessing filename on the interface Yiisoft\Yii\Debug\Helper\StreamWrapper\StreamWrapperInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                'args' => [],
            ];
        }

        return $this->__call(__FUNCTION__, func_get_args());
    }

    public function unlink(string $path): bool
    {
        if (!$this->ignored) {
            $this->operations[__FUNCTION__] = [
                'path' => $path,
                'args' => [],
            ];
        }
        return $this->__call(__FUNCTION__, func_get_args());
    }

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

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

    {
        return $this->__call(__FUNCTION__, func_get_args());
    }

    private function isIgnored(string $url): bool
    {
        if (BacktraceIgnoreMatcher::doesStringMatchPattern($url, self::$ignoredUrls)) {
            return true;
        }

        $backtrace = debug_backtrace();
        return BacktraceIgnoreMatcher::isIgnoredByClass($backtrace, self::$ignoredClasses)
            || BacktraceIgnoreMatcher::isIgnoredByFile($backtrace, self::$ignoredPathPatterns);
    }
}