@averay/codeformat 0.2.7 → 0.2.9

package/vendor/react/stream/composer.json

@@ -1,47 +0,0 @@
-{
-    "name": "react/stream",
-    "description": "Event-driven readable and writable streams for non-blocking I/O in ReactPHP",
-    "keywords": ["event-driven", "readable", "writable", "stream", "non-blocking", "io", "pipe", "ReactPHP"],
-    "license": "MIT",
-    "authors": [
-        {
-            "name": "Christian Lück",
-            "homepage": "https://clue.engineering/",
-            "email": "christian@clue.engineering"
-        },
-        {
-            "name": "Cees-Jan Kiewiet",
-            "homepage": "https://wyrihaximus.net/",
-            "email": "reactphp@ceesjankiewiet.nl"
-        },
-        {
-            "name": "Jan Sorgalla",
-            "homepage": "https://sorgalla.com/",
-            "email": "jsorgalla@gmail.com"
-        },
-        {
-            "name": "Chris Boden",
-            "homepage": "https://cboden.dev/",
-            "email": "cboden@gmail.com"
-        }
-    ],
-    "require": {
-        "php": ">=5.3.8",
-        "react/event-loop": "^1.2",
-        "evenement/evenement": "^3.0 || ^2.0 || ^1.0"
-    },
-    "require-dev": {
-        "phpunit/phpunit": "^9.6 || ^5.7 || ^4.8.36",
-        "clue/stream-filter": "~1.2"
-    },
-    "autoload": {
-        "psr-4": {
-            "React\\Stream\\": "src/"
-        }
-    },
-    "autoload-dev": {
-        "psr-4": {
-            "React\\Tests\\Stream\\": "tests/"
-        }
-    }
-}

package/vendor/react/stream/src/CompositeStream.php

@@ -1,83 +0,0 @@
-<?php
-
-namespace React\Stream;
-
-use Evenement\EventEmitter;
-
-final class CompositeStream extends EventEmitter implements DuplexStreamInterface
-{
-    private $readable;
-    private $writable;
-    private $closed = false;
-
-    public function __construct(ReadableStreamInterface $readable, WritableStreamInterface $writable)
-    {
-        $this->readable = $readable;
-        $this->writable = $writable;
-
-        if (!$readable->isReadable() || !$writable->isWritable()) {
-            $this->close();
-            return;
-        }
-
-        Util::forwardEvents($this->readable, $this, array('data', 'end', 'error'));
-        Util::forwardEvents($this->writable, $this, array('drain', 'error', 'pipe'));
-
-        $this->readable->on('close', array($this, 'close'));
-        $this->writable->on('close', array($this, 'close'));
-    }
-
-    public function isReadable()
-    {
-        return $this->readable->isReadable();
-    }
-
-    public function pause()
-    {
-        $this->readable->pause();
-    }
-
-    public function resume()
-    {
-        if (!$this->writable->isWritable()) {
-            return;
-        }
-
-        $this->readable->resume();
-    }
-
-    public function pipe(WritableStreamInterface $dest, array $options = array())
-    {
-        return Util::pipe($this, $dest, $options);
-    }
-
-    public function isWritable()
-    {
-        return $this->writable->isWritable();
-    }
-
-    public function write($data)
-    {
-        return $this->writable->write($data);
-    }
-
-    public function end($data = null)
-    {
-        $this->readable->pause();
-        $this->writable->end($data);
-    }
-
-    public function close()
-    {
-        if ($this->closed) {
-            return;
-        }
-
-        $this->closed = true;
-        $this->readable->close();
-        $this->writable->close();
-
-        $this->emit('close');
-        $this->removeAllListeners();
-    }
-}

package/vendor/react/stream/src/DuplexResourceStream.php

@@ -1,240 +0,0 @@
-<?php
-
-namespace React\Stream;
-
-use Evenement\EventEmitter;
-use React\EventLoop\Loop;
-use React\EventLoop\LoopInterface;
-use InvalidArgumentException;
-
-final class DuplexResourceStream extends EventEmitter implements DuplexStreamInterface
-{
-    private $stream;
-
-    /** @var LoopInterface */
-    private $loop;
-
-    /**
-     * Controls the maximum buffer size in bytes to read at once from the stream.
-     *
-     * This can be a positive number which means that up to X bytes will be read
-     * at once from the underlying stream resource. Note that the actual number
-     * of bytes read may be lower if the stream resource has less than X bytes
-     * currently available.
-     *
-     * This can be `-1` which means read everything available from the
-     * underlying stream resource.
-     * This should read until the stream resource is not readable anymore
-     * (i.e. underlying buffer drained), note that this does not neccessarily
-     * mean it reached EOF.
-     *
-     * @var int
-     */
-    private $bufferSize;
-    private $buffer;
-
-    private $readable = true;
-    private $writable = true;
-    private $closing = false;
-    private $listening = false;
-
-    /**
-     * @param resource $stream
-     * @param ?LoopInterface $loop
-     * @param ?int $readChunkSize
-     * @param ?WritableStreamInterface $buffer
-     */
-    public function __construct($stream, $loop = null, $readChunkSize = null, $buffer = null)
-    {
-        if (!\is_resource($stream) || \get_resource_type($stream) !== "stream") {
-             throw new InvalidArgumentException('First parameter must be a valid stream resource');
-        }
-
-        // ensure resource is opened for reading and wrting (fopen mode must contain "+")
-        $meta = \stream_get_meta_data($stream);
-        if (isset($meta['mode']) && $meta['mode'] !== '' && \strpos($meta['mode'], '+') === false) {
-            throw new InvalidArgumentException('Given stream resource is not opened in read and write mode');
-        }
-
-        // this class relies on non-blocking I/O in order to not interrupt the event loop
-        // e.g. pipes on Windows do not support this: https://bugs.php.net/bug.php?id=47918
-        if ($buffer !== null && !$buffer instanceof WritableResourceStream && \stream_set_blocking($stream, false) !== true) {
-            throw new \RuntimeException('Unable to set stream resource to non-blocking mode');
-        }
-
-        if ($loop !== null && !$loop instanceof LoopInterface) { // manual type check to support legacy PHP < 7.1
-            throw new \InvalidArgumentException('Argument #2 ($loop) expected null|React\EventLoop\LoopInterface');
-        }
-        if ($buffer !== null && !$buffer instanceof WritableStreamInterface) { // manual type check to support legacy PHP < 7.1
-            throw new \InvalidArgumentException('Argument #4 ($buffer) expected null|React\Stream\WritableStreamInterface');
-        }
-
-        // Use unbuffered read operations on the underlying stream resource.
-        // Reading chunks from the stream may otherwise leave unread bytes in
-        // PHP's stream buffers which some event loop implementations do not
-        // trigger events on (edge triggered).
-        // This does not affect the default event loop implementation (level
-        // triggered), so we can ignore platforms not supporting this (HHVM).
-        // Pipe streams (such as STDIN) do not seem to require this and legacy
-        // PHP versions cause SEGFAULTs on unbuffered pipe streams, so skip this.
-        if (\function_exists('stream_set_read_buffer') && !$this->isLegacyPipe($stream)) {
-            \stream_set_read_buffer($stream, 0);
-        }
-
-        if ($buffer === null) {
-            $buffer = new WritableResourceStream($stream, $loop);
-        }
-
-        $this->stream = $stream;
-        $this->loop = $loop ?: Loop::get();
-        $this->bufferSize = ($readChunkSize === null) ? 65536 : (int)$readChunkSize;
-        $this->buffer = $buffer;
-
-        $that = $this;
-
-        $this->buffer->on('error', function ($error) use ($that) {
-            $that->emit('error', array($error));
-        });
-
-        $this->buffer->on('close', array($this, 'close'));
-
-        $this->buffer->on('drain', function () use ($that) {
-            $that->emit('drain');
-        });
-
-        $this->resume();
-    }
-
-    public function isReadable()
-    {
-        return $this->readable;
-    }
-
-    public function isWritable()
-    {
-        return $this->writable;
-    }
-
-    public function pause()
-    {
-        if ($this->listening) {
-            $this->loop->removeReadStream($this->stream);
-            $this->listening = false;
-        }
-    }
-
-    public function resume()
-    {
-        if (!$this->listening && $this->readable) {
-            $this->loop->addReadStream($this->stream, array($this, 'handleData'));
-            $this->listening = true;
-        }
-    }
-
-    public function write($data)
-    {
-        if (!$this->writable) {
-            return false;
-        }
-
-        return $this->buffer->write($data);
-    }
-
-    public function close()
-    {
-        if (!$this->writable && !$this->closing) {
-            return;
-        }
-
-        $this->closing = false;
-
-        $this->readable = false;
-        $this->writable = false;
-
-        $this->emit('close');
-        $this->pause();
-        $this->buffer->close();
-        $this->removeAllListeners();
-
-        if (\is_resource($this->stream)) {
-            \fclose($this->stream);
-        }
-    }
-
-    public function end($data = null)
-    {
-        if (!$this->writable) {
-            return;
-        }
-
-        $this->closing = true;
-
-        $this->readable = false;
-        $this->writable = false;
-        $this->pause();
-
-        $this->buffer->end($data);
-    }
-
-    public function pipe(WritableStreamInterface $dest, array $options = array())
-    {
-        return Util::pipe($this, $dest, $options);
-    }
-
-    /** @internal */
-    public function handleData($stream)
-    {
-        $error = null;
-        \set_error_handler(function ($errno, $errstr, $errfile, $errline) use (&$error) {
-            $error = new \ErrorException(
-                $errstr,
-                0,
-                $errno,
-                $errfile,
-                $errline
-            );
-        });
-
-        $data = \stream_get_contents($stream, $this->bufferSize);
-
-        \restore_error_handler();
-
-        if ($error !== null) {
-            $this->emit('error', array(new \RuntimeException('Unable to read from stream: ' . $error->getMessage(), 0, $error)));
-            $this->close();
-            return;
-        }
-
-        if ($data !== '') {
-            $this->emit('data', array($data));
-        } elseif (\feof($this->stream)) {
-            // no data read => we reached the end and close the stream
-            $this->emit('end');
-            $this->close();
-        }
-    }
-
-    /**
-     * Returns whether this is a pipe resource in a legacy environment
-     *
-     * This works around a legacy PHP bug (#61019) that was fixed in PHP 5.4.28+
-     * and PHP 5.5.12+ and newer.
-     *
-     * @param resource $resource
-     * @return bool
-     * @link https://github.com/reactphp/child-process/issues/40
-     *
-     * @codeCoverageIgnore
-     */
-    private function isLegacyPipe($resource)
-    {
-        if (\PHP_VERSION_ID < 50428 || (\PHP_VERSION_ID >= 50500 && \PHP_VERSION_ID < 50512)) {
-            $meta = \stream_get_meta_data($resource);
-
-            if (isset($meta['stream_type']) && $meta['stream_type'] === 'STDIO') {
-                return true;
-            }
-        }
-        return false;
-    }
-}

package/vendor/react/stream/src/DuplexStreamInterface.php

@@ -1,39 +0,0 @@
-<?php
-
-namespace React\Stream;
-
-/**
- * The `DuplexStreamInterface` is responsible for providing an interface for
- * duplex streams (both readable and writable).
- *
- * It builds on top of the existing interfaces for readable and writable streams
- * and follows the exact same method and event semantics.
- * If you're new to this concept, you should look into the
- * `ReadableStreamInterface` and `WritableStreamInterface` first.
- *
- * Besides defining a few methods, this interface also implements the
- * `EventEmitterInterface` which allows you to react to the same events defined
- * on the `ReadbleStreamInterface` and `WritableStreamInterface`.
- *
- * The event callback functions MUST be a valid `callable` that obeys strict
- * parameter definitions and MUST accept event parameters exactly as documented.
- * The event callback functions MUST NOT throw an `Exception`.
- * The return value of the event callback functions will be ignored and has no
- * effect, so for performance reasons you're recommended to not return any
- * excessive data structures.
- *
- * Every implementation of this interface MUST follow these event semantics in
- * order to be considered a well-behaving stream.
- *
- * > Note that higher-level implementations of this interface may choose to
- *   define additional events with dedicated semantics not defined as part of
- *   this low-level stream specification. Conformance with these event semantics
- *   is out of scope for this interface, so you may also have to refer to the
- *   documentation of such a higher-level implementation.
- *
- * @see ReadableStreamInterface
- * @see WritableStreamInterface
- */
-interface DuplexStreamInterface extends ReadableStreamInterface, WritableStreamInterface
-{
-}

package/vendor/react/stream/src/ReadableResourceStream.php

@@ -1,188 +0,0 @@
-<?php
-
-namespace React\Stream;
-
-use Evenement\EventEmitter;
-use React\EventLoop\Loop;
-use React\EventLoop\LoopInterface;
-use InvalidArgumentException;
-
-final class ReadableResourceStream extends EventEmitter implements ReadableStreamInterface
-{
-    /**
-     * @var resource
-     */
-    private $stream;
-
-    /** @var LoopInterface */
-    private $loop;
-
-    /**
-     * Controls the maximum buffer size in bytes to read at once from the stream.
-     *
-     * This value SHOULD NOT be changed unless you know what you're doing.
-     *
-     * This can be a positive number which means that up to X bytes will be read
-     * at once from the underlying stream resource. Note that the actual number
-     * of bytes read may be lower if the stream resource has less than X bytes
-     * currently available.
-     *
-     * This can be `-1` which means read everything available from the
-     * underlying stream resource.
-     * This should read until the stream resource is not readable anymore
-     * (i.e. underlying buffer drained), note that this does not neccessarily
-     * mean it reached EOF.
-     *
-     * @var int
-     */
-    private $bufferSize;
-
-    private $closed = false;
-    private $listening = false;
-
-    /**
-     * @param resource $stream
-     * @param ?LoopInterface $loop
-     * @param ?int $readChunkSize
-     */
-    public function __construct($stream, $loop = null, $readChunkSize = null)
-    {
-        if (!\is_resource($stream) || \get_resource_type($stream) !== "stream") {
-             throw new InvalidArgumentException('First parameter must be a valid stream resource');
-        }
-
-        // ensure resource is opened for reading (fopen mode must contain "r" or "+")
-        $meta = \stream_get_meta_data($stream);
-        if (isset($meta['mode']) && $meta['mode'] !== '' && \strpos($meta['mode'], 'r') === \strpos($meta['mode'], '+')) {
-            throw new InvalidArgumentException('Given stream resource is not opened in read mode');
-        }
-
-        // this class relies on non-blocking I/O in order to not interrupt the event loop
-        // e.g. pipes on Windows do not support this: https://bugs.php.net/bug.php?id=47918
-        if (\stream_set_blocking($stream, false) !== true) {
-            throw new \RuntimeException('Unable to set stream resource to non-blocking mode');
-        }
-
-        if ($loop !== null && !$loop instanceof LoopInterface) { // manual type check to support legacy PHP < 7.1
-            throw new \InvalidArgumentException('Argument #2 ($loop) expected null|React\EventLoop\LoopInterface');
-        }
-
-        // Use unbuffered read operations on the underlying stream resource.
-        // Reading chunks from the stream may otherwise leave unread bytes in
-        // PHP's stream buffers which some event loop implementations do not
-        // trigger events on (edge triggered).
-        // This does not affect the default event loop implementation (level
-        // triggered), so we can ignore platforms not supporting this (HHVM).
-        // Pipe streams (such as STDIN) do not seem to require this and legacy
-        // PHP versions cause SEGFAULTs on unbuffered pipe streams, so skip this.
-        if (\function_exists('stream_set_read_buffer') && !$this->isLegacyPipe($stream)) {
-            \stream_set_read_buffer($stream, 0);
-        }
-
-        $this->stream = $stream;
-        $this->loop = $loop ?: Loop::get();
-        $this->bufferSize = ($readChunkSize === null) ? 65536 : (int)$readChunkSize;
-
-        $this->resume();
-    }
-
-    public function isReadable()
-    {
-        return !$this->closed;
-    }
-
-    public function pause()
-    {
-        if ($this->listening) {
-            $this->loop->removeReadStream($this->stream);
-            $this->listening = false;
-        }
-    }
-
-    public function resume()
-    {
-        if (!$this->listening && !$this->closed) {
-            $this->loop->addReadStream($this->stream, array($this, 'handleData'));
-            $this->listening = true;
-        }
-    }
-
-    public function pipe(WritableStreamInterface $dest, array $options = array())
-    {
-        return Util::pipe($this, $dest, $options);
-    }
-
-    public function close()
-    {
-        if ($this->closed) {
-            return;
-        }
-
-        $this->closed = true;
-
-        $this->emit('close');
-        $this->pause();
-        $this->removeAllListeners();
-
-        if (\is_resource($this->stream)) {
-            \fclose($this->stream);
-        }
-    }
-
-    /** @internal */
-    public function handleData()
-    {
-        $error = null;
-        \set_error_handler(function ($errno, $errstr, $errfile, $errline) use (&$error) {
-            $error = new \ErrorException(
-                $errstr,
-                0,
-                $errno,
-                $errfile,
-                $errline
-            );
-        });
-
-        $data = \stream_get_contents($this->stream, $this->bufferSize);
-
-        \restore_error_handler();
-
-        if ($error !== null) {
-            $this->emit('error', array(new \RuntimeException('Unable to read from stream: ' . $error->getMessage(), 0, $error)));
-            $this->close();
-            return;
-        }
-
-        if ($data !== '') {
-            $this->emit('data', array($data));
-        } elseif (\feof($this->stream)) {
-            // no data read => we reached the end and close the stream
-            $this->emit('end');
-            $this->close();
-        }
-    }
-
-    /**
-     * Returns whether this is a pipe resource in a legacy environment
-     *
-     * This works around a legacy PHP bug (#61019) that was fixed in PHP 5.4.28+
-     * and PHP 5.5.12+ and newer.
-     *
-     * @param resource $resource
-     * @return bool
-     * @link https://github.com/reactphp/child-process/issues/40
-     *
-     * @codeCoverageIgnore
-     */
-    private function isLegacyPipe($resource)
-    {
-        if (\PHP_VERSION_ID < 50428 || (\PHP_VERSION_ID >= 50500 && \PHP_VERSION_ID < 50512)) {
-            $meta = \stream_get_meta_data($resource);
-
-            if (isset($meta['stream_type']) && $meta['stream_type'] === 'STDIO') {
-                return true;
-            }
-        }
-        return false;
-    }
-}