Stream::getSize() - Code Metrics - Inspection of "Added clover.xml" - Furious-PHP/psr7 - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Branch — master (f83914)

by Rasul

created 2020-07-19 11:27 UTC

Stream::getSize() A

↳ Parent: Project

Complexity

Conditions	5
Paths	6

Size

Total Lines	21
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	11
nc	6
nop	0
dl	0
loc	21
rs	9.6111
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Furious\Psr7;

use Furious\Psr7\Exception\IncorrectStreamPositionException;
use Furious\Psr7\Exception\InvalidArgumentException;
use Furious\Psr7\Exception\NotReadableStreamException;
use Furious\Psr7\Exception\NotSeekableStreamException;
use Furious\Psr7\Exception\NotWritableStreamException;
use Furious\Psr7\Exception\RuntimeException;
use Furious\Psr7\Exception\UnableToSeekException;
use Psr\Http\Message\StreamInterface;
use const SEEK_CUR;
use function is_string;
use function fwrite;
use function is_resource;
use function fopen;
use function fseek;
use function fread;
use function stream_get_meta_data;
use function clearstatcache;
use function fstat;
use function ftell;
use function feof;
use function stream_get_contents;

class Stream implements StreamInterface
{
    private bool $seekable;

    private bool $readable;
    private bool $writable;
    /** @var mixed */
    private $uri = null;
    private ?int $size = null;
    /** @var resource|null */
    private $stream;

    private const READ_HASH = [
        'r' => true, 'w+' => true, 'r+' => true, 'x+' => true, 'c+' => true,
        'rb' => true, 'w+b' => true, 'r+b' => true, 'x+b' => true,
        'c+b' => true, 'rt' => true, 'w+t' => true, 'r+t' => true,
        'x+t' => true, 'c+t' => true, 'a+' => true,
    ];

    private const WRITE_HASH = [
        'w' => true, 'w+' => true, 'rw' => true, 'r+' => true, 'x+' => true,
        'c+' => true, 'wb' => true, 'w+b' => true, 'r+b' => true,
        'x+b' => true, 'c+b' => true, 'w+t' => true, 'r+t' => true,
        'x+t' => true, 'c+t' => true, 'a' => true, 'a+' => true
    ];

    public static function new($body = ''): StreamInterface
    {
        $new = new self();

        if ($body instanceof StreamInterface) {
            return $body;
        }

        if (is_string($body)) {
            $body = $new->initializeAsString($body);
        }

        if (is_array($body)) {
            $body = $new->initializeAsArray($body);
        }

        if (is_resource($body)) {
            $new->stream = $body;
            $meta = stream_get_meta_data($new->stream);
            $new->seekable = $meta['seekable'] and !fseek($new->stream, 0, SEEK_CUR);
            $new->readable = isset(self::READ_HASH[$meta['mode']]);
            $new->writable = isset(self::WRITE_HASH[$meta['mode']]);
            $new->uri = $new->getMetadata('uri');

            return $new;
        }

        throw new InvalidArgumentException('Body must be array, instance of StreamInterface or null');
    }

    private function initializeAsString(string $body)
    {
        if ($body === 'php://input') {
            $resource = fopen('php://input', 'rw+');
        } else {
            $resource = fopen('php://temp', 'rw+');
        }

        if (false === $resource) {
            throw new RuntimeException('Could not open file');
        }

        fwrite($resource, $body);
        return $resource;
    }

    private function initializeAsArray(array $body)
    {
        $body = json_encode($body);
        $resource = fopen('php://temp', 'rw+');

        if (false === $resource) {
            throw new RuntimeException('Could not open file');
        }

        fwrite($resource, $body);
        return $resource;
    }

    public function __toString()
    {
        if ($this->isSeekable()) {
            $this->seek(0);
        }

        return $this->getContents();
    }

    public function __destruct()
    {
        $this->close();
    }

    public function close(): void
    {
        if (isset($this->stream)) {
            if (is_resource($this->stream)) {
                fclose($this->stream);
            }
            $this->detach();
        }
    }

    /**
     * @return resource|null
     */
    public function detach()
    {
        if (!isset($this->stream)) {
            return null;
        }

        $result = $this->stream;
        unset($this->stream);

        $this->size = null;
        $this->uri = null;
        $this->readable = false;
        $this->writable = false;
        $this->seekable = false;

        return $result;
    }

    public function getSize(): ?int
    {
        if (null !== $this->size) {
            return $this->size;
        }

        if (!isset($this->stream)) {
            return null;
        }

        if ($this->uri) {
            clearstatcache(true, $this->uri);
        }

        $stats = fstat($this->stream);
        if (isset($stats['size'])) {
            $this->size = $stats['size'];
            return $this->size;
        }

        return null;
    }

    public function tell(): int
    {
        if (false === $result = ftell($this->stream)) {
            throw new IncorrectStreamPositionException();
        }

        return $result;
    }

    public function read($length): string
    {
        if (!$this->readable) {
            throw new NotReadableStreamException();
        }

        return fread($this->stream, $length);
    }


    public function eof(): bool
    {
        return !$this->stream or feof($this->stream);
    }

    public function isSeekable(): bool
    {
        return $this->seekable;
    }

    public function isWritable(): bool
    {
        return $this->writable;
    }

    public function isReadable(): bool
    {
        return $this->readable;
    }

    public function seek($offset, $whence = SEEK_SET): void
    {
        if (!$this->seekable) {
            throw new NotSeekableStreamException();
        }

        if (-1 === fseek($this->stream, $offset, $whence)) {
            throw new UnableToSeekException($offset, $whence);
        }
    }

    public function rewind(): void
    {
        $this->seek(0);
    }

    public function write($string): int
    {
        if (!$this->writable) {
            throw new NotWritableStreamException('Cannot write to a non-writable stream');
        }

        $this->size = null;

        $result = fwrite($this->stream, $string);
        if (false === $result) {
            throw new NotWritableStreamException();
        }

        return $result;
    }

    public function getContents(): string
    {
        if (!isset($this->stream)) {
            throw new NotReadableStreamException();
        }

        $contents = stream_get_contents($this->stream);
        if (false === $contents) {
            throw new NotReadableStreamException();
        }

        return $contents;
    }

    /**
     * @param string $key
     * @return array|mixed|null
     */
    public function getMetadata($key = null)
    {
        if (!isset($this->stream)) {
            return $key ? null : [];
        }

        $meta = stream_get_meta_data($this->stream);

        if (null === $key) {
            return $meta;
        }

        return $meta[$key] ?? null;
    }
}

1			<?php
2
3			declare(strict_types=1);
4
5			namespace Furious\Psr7;
6
7			use Furious\Psr7\Exception\IncorrectStreamPositionException;
8			use Furious\Psr7\Exception\InvalidArgumentException;
9			use Furious\Psr7\Exception\NotReadableStreamException;
10			use Furious\Psr7\Exception\NotSeekableStreamException;
11			use Furious\Psr7\Exception\NotWritableStreamException;
12			use Furious\Psr7\Exception\RuntimeException;
13			use Furious\Psr7\Exception\UnableToSeekException;
14			use Psr\Http\Message\StreamInterface;
15			use const SEEK_CUR;
16			use function is_string;
17			use function fwrite;
18			use function is_resource;
19			use function fopen;
20			use function fseek;
21			use function fread;
22			use function stream_get_meta_data;
23			use function clearstatcache;
24			use function fstat;
25			use function ftell;
26			use function feof;
27			use function stream_get_contents;
28
29			class Stream implements StreamInterface
30			{
31			private bool $seekable;
			1 ignored issue – show Bug introduced 2020-07-19 11:23 UTC by Report Bug Copy Issue Report This code did not parse for me. Apparently, there is an error somewhere around this line: Syntax error, unexpected T_STRING, expecting T_FUNCTION or T_CONST Loading history...
32			private bool $readable;
33			private bool $writable;
34			/** @var mixed */
35			private $uri = null;
36			private ?int $size = null;
37			/** @var resource\|null */
38			private $stream;
39
40			private const READ_HASH = [
41			'r' => true, 'w+' => true, 'r+' => true, 'x+' => true, 'c+' => true,
42			'rb' => true, 'w+b' => true, 'r+b' => true, 'x+b' => true,
43			'c+b' => true, 'rt' => true, 'w+t' => true, 'r+t' => true,
44			'x+t' => true, 'c+t' => true, 'a+' => true,
45			];
46
47			private const WRITE_HASH = [
48			'w' => true, 'w+' => true, 'rw' => true, 'r+' => true, 'x+' => true,
49			'c+' => true, 'wb' => true, 'w+b' => true, 'r+b' => true,
50			'x+b' => true, 'c+b' => true, 'w+t' => true, 'r+t' => true,
51			'x+t' => true, 'c+t' => true, 'a' => true, 'a+' => true
52			];
53
54			public static function new($body = ''): StreamInterface
55			{
56			$new = new self();
57
58			if ($body instanceof StreamInterface) {
59			return $body;
60			}
61
62			if (is_string($body)) {
63			$body = $new->initializeAsString($body);
64			}
65
66			if (is_array($body)) {
67			$body = $new->initializeAsArray($body);
68			}
69
70			if (is_resource($body)) {
71			$new->stream = $body;
72			$meta = stream_get_meta_data($new->stream);
73			$new->seekable = $meta['seekable'] and !fseek($new->stream, 0, SEEK_CUR);
74			$new->readable = isset(self::READ_HASH[$meta['mode']]);
75			$new->writable = isset(self::WRITE_HASH[$meta['mode']]);
76			$new->uri = $new->getMetadata('uri');
77
78			return $new;
79			}
80
81			throw new InvalidArgumentException('Body must be array, instance of StreamInterface or null');
82			}
83
84			private function initializeAsString(string $body)
85			{
86			if ($body === 'php://input') {
87			$resource = fopen('php://input', 'rw+');
88			} else {
89			$resource = fopen('php://temp', 'rw+');
90			}
91
92			if (false === $resource) {
93			throw new RuntimeException('Could not open file');
94			}
95
96			fwrite($resource, $body);
97			return $resource;
98			}
99
100			private function initializeAsArray(array $body)
101			{
102			$body = json_encode($body);
103			$resource = fopen('php://temp', 'rw+');
104
105			if (false === $resource) {
106			throw new RuntimeException('Could not open file');
107			}
108
109			fwrite($resource, $body);
110			return $resource;
111			}
112
113			public function __toString()
114			{
115			if ($this->isSeekable()) {
116			$this->seek(0);
117			}
118
119			return $this->getContents();
120			}
121
122			public function __destruct()
123			{
124			$this->close();
125			}
126
127			public function close(): void
128			{
129			if (isset($this->stream)) {
130			if (is_resource($this->stream)) {
131			fclose($this->stream);
132			}
133			$this->detach();
134			}
135			}
136
137			/**
138			* @return resource\|null
139			*/
140			public function detach()
141			{
142			if (!isset($this->stream)) {
143			return null;
144			}
145
146			$result = $this->stream;
147			unset($this->stream);
148
149			$this->size = null;
150			$this->uri = null;
151			$this->readable = false;
152			$this->writable = false;
153			$this->seekable = false;
154
155			return $result;
156			}
157
158			public function getSize(): ?int
159			{
160			if (null !== $this->size) {
161			return $this->size;
162			}
163
164			if (!isset($this->stream)) {
165			return null;
166			}
167
168			if ($this->uri) {
169			clearstatcache(true, $this->uri);
170			}
171
172			$stats = fstat($this->stream);
173			if (isset($stats['size'])) {
174			$this->size = $stats['size'];
175			return $this->size;
176			}
177
178			return null;
179			}
180
181			public function tell(): int
182			{
183			if (false === $result = ftell($this->stream)) {
184			throw new IncorrectStreamPositionException();
185			}
186
187			return $result;
188			}
189
190			public function read($length): string
191			{
192			if (!$this->readable) {
193			throw new NotReadableStreamException();
194			}
195
196			return fread($this->stream, $length);
197			}
198
199
200			public function eof(): bool
201			{
202			return !$this->stream or feof($this->stream);
203			}
204
205			public function isSeekable(): bool
206			{
207			return $this->seekable;
208			}
209
210			public function isWritable(): bool
211			{
212			return $this->writable;
213			}
214
215			public function isReadable(): bool
216			{
217			return $this->readable;
218			}
219
220			public function seek($offset, $whence = SEEK_SET): void
221			{
222			if (!$this->seekable) {
223			throw new NotSeekableStreamException();
224			}
225
226			if (-1 === fseek($this->stream, $offset, $whence)) {
227			throw new UnableToSeekException($offset, $whence);
228			}
229			}
230
231			public function rewind(): void
232			{
233			$this->seek(0);
234			}
235
236			public function write($string): int
237			{
238			if (!$this->writable) {
239			throw new NotWritableStreamException('Cannot write to a non-writable stream');
240			}
241
242			$this->size = null;
243
244			$result = fwrite($this->stream, $string);
245			if (false === $result) {
246			throw new NotWritableStreamException();
247			}
248
249			return $result;
250			}
251
252			public function getContents(): string
253			{
254			if (!isset($this->stream)) {
255			throw new NotReadableStreamException();
256			}
257
258			$contents = stream_get_contents($this->stream);
259			if (false === $contents) {
260			throw new NotReadableStreamException();
261			}
262
263			return $contents;
264			}
265
266			/**
267			* @param string $key
268			* @return array\|mixed\|null
269			*/
270			public function getMetadata($key = null)
271			{
272			if (!isset($this->stream)) {
273			return $key ? null : [];
274			}
275
276			$meta = stream_get_meta_data($this->stream);
277
278			if (null === $key) {
279			return $meta;
280			}
281
282			return $meta[$key] ?? null;
283			}
284			}

Furious-PHP / psr7

Branch — master (f83914)

Stream::getSize() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like