Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 283 insertions, 0 deletions

diff --git a/library/vendor/iplx/Http/Stream.php b/library/vendor/iplx/Http/Stream.php
new file mode 100644
index 0000000..a113312
--- /dev/null
+++ b/library/vendor/iplx/Http/Stream.php
@@ -0,0 +1,283 @@
+<?php
+
+namespace iplx\Http;
+
+use Exception;
+use InvalidArgumentException;
+use RuntimeException;
+use Psr\Http\Message\StreamInterface;
+
+class Stream implements StreamInterface
+{
+    protected $stream;
+
+    protected $size;
+
+    protected $seekable;
+
+    protected $readable;
+
+    protected $writable;
+
+    public function __construct($stream)
+    {
+        if (! is_resource($stream)) {
+            throw new InvalidArgumentException('Invalid stream resource');
+        }
+
+        $this->stream = $stream;
+
+        $meta = stream_get_meta_data($this->stream);
+        $this->seekable = $meta['seekable'];
+        $this->readable = preg_match('/[r+]/', $meta['mode']) === 1;
+        $this->writable = preg_match('/[waxc+]/', $meta['mode']) === 1;
+    }
+
+    public function __destruct()
+    {
+        $this->close();
+    }
+
+    public function __toString()
+    {
+        try {
+            $this->seek(0);
+            $contents = stream_get_contents($this->stream);
+        } catch (Exception $e) {
+            $contents = '';
+        }
+
+        return $contents;
+    }
+
+    public function close()
+    {
+        if (isset($this->stream)) {
+            if (is_resource($this->stream)) {
+                fclose($this->stream);
+            }
+            $this->detach();
+        }
+    }
+
+    public function detach()
+    {
+        if (! isset($this->stream)) {
+            return null;
+        }
+
+        $stream = $this->stream;
+
+        $this->stream = null;
+        $this->size = null;
+        $this->seekable = false;
+        $this->readable = false;
+        $this->writable = false;
+
+        return $stream;
+    }
+
+    public function getSize()
+    {
+        if ($this->size !== null) {
+            return $this->size;
+        }
+
+        if (! isset($this->stream)) {
+            return null;
+        }
+
+        $stats = fstat($this->stream);
+        $this->size = $stats['size'];
+
+        return $this->size;
+    }
+
+    public function tell()
+    {
+        $this->assertAttached();
+
+        $position = ftell($this->stream);
+
+        if ($position === false) {
+            throw new RuntimeException('Unable to determine stream position');
+        }
+
+        return $position;
+    }
+
+    public function eof()
+    {
+        $this->assertAttached();
+
+        return feof($this->stream);
+    }
+
+    public function isSeekable()
+    {
+        return $this->seekable;
+    }
+
+    public function seek($offset, $whence = SEEK_SET)
+    {
+        $this->assertSeekable();
+
+        if (fseek($this->stream, $offset, $whence) === -1) {
+            throw new RuntimeException('Unable to seek to stream position');
+        }
+    }
+
+    public function rewind()
+    {
+        $this->seek(0);
+    }
+
+    public function isWritable()
+    {
+        return $this->writable;
+    }
+
+    public function write($string)
+    {
+        $this->assertWritable();
+
+        $written = fwrite($this->stream, $string);
+
+        if ($written === false) {
+            throw new RuntimeException('Unable to write to stream');
+        }
+
+        return $written;
+    }
+
+    public function isReadable()
+    {
+        return $this->readable;
+    }
+
+    public function read($length)
+    {
+        $this->assertReadable();
+
+        $data = fread($this->stream, $length);
+
+        if ($data === false) {
+            throw new RuntimeException('Unable to read from stream');
+        }
+
+        return $data;
+    }
+
+    public function getContents()
+    {
+        $this->assertReadable();
+
+        $contents = stream_get_contents($this->stream);
+
+        if ($contents === false) {
+            throw new RuntimeException('Unable to read stream contents');
+        }
+
+        return $contents;
+    }
+
+    public function getMetadata($key = null)
+    {
+        if (! isset($this->stream)) {
+            return $key === null ? [] : null;
+        }
+
+        $meta = stream_get_meta_data($this->stream);
+
+        if ($key === null) {
+            return $meta;
+        }
+
+        if (isset($meta[$key])) {
+            return $meta[$key];
+        }
+
+        return null;
+    }
+
+    public function assertAttached()
+    {
+        if (! isset($this->stream)) {
+            throw new RuntimeException('Stream is detached');
+        }
+    }
+
+    public function assertSeekable()
+    {
+        $this->assertAttached();
+
+        if (! $this->isSeekable()) {
+            throw new RuntimeException('Stream is not seekable');
+        }
+    }
+
+    public function assertReadable()
+    {
+        $this->assertAttached();
+
+        if (! $this->isReadable()) {
+            throw new RuntimeException('Stream is not readable');
+        }
+    }
+
+    public function assertWritable()
+    {
+        $this->assertAttached();
+
+        if (! $this->isWritable()) {
+            throw new RuntimeException('Stream is not writable');
+        }
+    }
+
+    /**
+     * Open a stream
+     *
+     * @param   string  $filename
+     * @param   string  $mode
+     *
+     * @return  static
+     */
+    public static function open($filename = 'php://temp', $mode = 'r+')
+    {
+        $stream = fopen($filename, $mode);
+
+        return new static($stream);
+    }
+
+    /**
+     * Create a stream
+     *
+     * @param   StreamInterface|string|resource $resource
+     *
+     * @return  StreamInterface
+     */
+    public static function create($resource)
+    {
+        if ($resource instanceof StreamInterface) {
+            return $resource;
+        }
+
+        if (is_scalar($resource)) {
+            $stream = fopen('php://temp', 'r+');
+
+            if ($resource !== '') {
+                fwrite($stream, $resource);
+                fseek($stream, 0);
+            }
+
+            return new static($stream);
+        }
+
+        if (is_resource($resource)) {
+            return new static($resource);
+        }
+
+        return static::open();
+    }
+
+}