@averay/codeformat 0.2.7 → 0.2.10

package/vendor/react/socket/composer.json

@@ -1,52 +0,0 @@
-{
-    "name": "react/socket",
-    "description": "Async, streaming plaintext TCP/IP and secure TLS socket server and client connections for ReactPHP",
-    "keywords": ["async", "socket", "stream", "connection", "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.0",
-        "evenement/evenement": "^3.0 || ^2.0 || ^1.0",
-        "react/dns": "^1.13",
-        "react/event-loop": "^1.2",
-        "react/promise": "^3.2 || ^2.6 || ^1.2.1",
-        "react/stream": "^1.4"
-    },
-    "require-dev": {
-        "phpunit/phpunit": "^9.6 || ^5.7 || ^4.8.36",
-        "react/async": "^4.3 || ^3.3 || ^2",
-        "react/promise-stream": "^1.4",
-        "react/promise-timer": "^1.11"
-    },
-    "autoload": {
-        "psr-4": {
-            "React\\Socket\\": "src/"
-        }
-    },
-    "autoload-dev": {
-        "psr-4": {
-            "React\\Tests\\Socket\\": "tests/"
-        }
-    }
-}

package/vendor/react/socket/src/Connection.php

@@ -1,183 +0,0 @@
-<?php
-
-namespace React\Socket;
-
-use Evenement\EventEmitter;
-use React\EventLoop\LoopInterface;
-use React\Stream\DuplexResourceStream;
-use React\Stream\Util;
-use React\Stream\WritableResourceStream;
-use React\Stream\WritableStreamInterface;
-
-/**
- * The actual connection implementation for ConnectionInterface
- *
- * This class should only be used internally, see ConnectionInterface instead.
- *
- * @see ConnectionInterface
- * @internal
- */
-class Connection extends EventEmitter implements ConnectionInterface
-{
-    /**
-     * Internal flag whether this is a Unix domain socket (UDS) connection
-     *
-     * @internal
-     */
-    public $unix = false;
-
-    /**
-     * Internal flag whether encryption has been enabled on this connection
-     *
-     * Mostly used by internal StreamEncryption so that connection returns
-     * `tls://` scheme for encrypted connections instead of `tcp://`.
-     *
-     * @internal
-     */
-    public $encryptionEnabled = false;
-
-    /** @internal */
-    public $stream;
-
-    private $input;
-
-    public function __construct($resource, LoopInterface $loop)
-    {
-        // PHP < 7.3.3 (and PHP < 7.2.15) suffers from a bug where feof() might
-        // block with 100% CPU usage on fragmented TLS records.
-        // We try to work around this by always consuming the complete receive
-        // buffer at once to avoid stale data in TLS buffers. This is known to
-        // work around high CPU usage for well-behaving peers, but this may
-        // cause very large data chunks for high throughput scenarios. The buggy
-        // behavior can still be triggered due to network I/O buffers or
-        // malicious peers on affected versions, upgrading is highly recommended.
-        // @link https://bugs.php.net/bug.php?id=77390
-        $clearCompleteBuffer = \PHP_VERSION_ID < 70215 || (\PHP_VERSION_ID >= 70300 && \PHP_VERSION_ID < 70303);
-
-        // PHP < 7.1.4 (and PHP < 7.0.18) suffers from a bug when writing big
-        // chunks of data over TLS streams at once.
-        // We try to work around this by limiting the write chunk size to 8192
-        // bytes for older PHP versions only.
-        // This is only a work-around and has a noticable performance penalty on
-        // affected versions. Please update your PHP version.
-        // This applies to all streams because TLS may be enabled later on.
-        // See https://github.com/reactphp/socket/issues/105
-        $limitWriteChunks = (\PHP_VERSION_ID < 70018 || (\PHP_VERSION_ID >= 70100 && \PHP_VERSION_ID < 70104));
-
-        $this->input = new DuplexResourceStream(
-            $resource,
-            $loop,
-            $clearCompleteBuffer ? -1 : null,
-            new WritableResourceStream($resource, $loop, null, $limitWriteChunks ? 8192 : null)
-        );
-
-        $this->stream = $resource;
-
-        Util::forwardEvents($this->input, $this, array('data', 'end', 'error', 'close', 'pipe', 'drain'));
-
-        $this->input->on('close', array($this, 'close'));
-    }
-
-    public function isReadable()
-    {
-        return $this->input->isReadable();
-    }
-
-    public function isWritable()
-    {
-        return $this->input->isWritable();
-    }
-
-    public function pause()
-    {
-        $this->input->pause();
-    }
-
-    public function resume()
-    {
-        $this->input->resume();
-    }
-
-    public function pipe(WritableStreamInterface $dest, array $options = array())
-    {
-        return $this->input->pipe($dest, $options);
-    }
-
-    public function write($data)
-    {
-        return $this->input->write($data);
-    }
-
-    public function end($data = null)
-    {
-        $this->input->end($data);
-    }
-
-    public function close()
-    {
-        $this->input->close();
-        $this->handleClose();
-        $this->removeAllListeners();
-    }
-
-    public function handleClose()
-    {
-        if (!\is_resource($this->stream)) {
-            return;
-        }
-
-        // Try to cleanly shut down socket and ignore any errors in case other
-        // side already closed. Underlying Stream implementation will take care
-        // of closing stream resource, so we otherwise keep this open here.
-        @\stream_socket_shutdown($this->stream, \STREAM_SHUT_RDWR);
-    }
-
-    public function getRemoteAddress()
-    {
-        if (!\is_resource($this->stream)) {
-            return null;
-        }
-
-        return $this->parseAddress(\stream_socket_get_name($this->stream, true));
-    }
-
-    public function getLocalAddress()
-    {
-        if (!\is_resource($this->stream)) {
-            return null;
-        }
-
-        return $this->parseAddress(\stream_socket_get_name($this->stream, false));
-    }
-
-    private function parseAddress($address)
-    {
-        if ($address === false) {
-            return null;
-        }
-
-        if ($this->unix) {
-            // remove trailing colon from address for HHVM < 3.19: https://3v4l.org/5C1lo
-            // note that technically ":" is a valid address, so keep this in place otherwise
-            if (\substr($address, -1) === ':' && \defined('HHVM_VERSION_ID') && \HHVM_VERSION_ID < 31900) {
-                $address = (string)\substr($address, 0, -1); // @codeCoverageIgnore
-            }
-
-            // work around unknown addresses should return null value: https://3v4l.org/5C1lo and https://bugs.php.net/bug.php?id=74556
-            // PHP uses "\0" string and HHVM uses empty string (colon removed above)
-            if ($address === '' || $address[0] === "\x00" ) {
-                return null; // @codeCoverageIgnore
-            }
-
-            return 'unix://' . $address;
-        }
-
-        // check if this is an IPv6 address which includes multiple colons but no square brackets
-        $pos = \strrpos($address, ':');
-        if ($pos !== false && \strpos($address, ':') < $pos && \substr($address, 0, 1) !== '[') {
-            $address = '[' . \substr($address, 0, $pos) . ']:' . \substr($address, $pos + 1); // @codeCoverageIgnore
-        }
-
-        return ($this->encryptionEnabled ? 'tls' : 'tcp') . '://' . $address;
-    }
-}

package/vendor/react/socket/src/ConnectionInterface.php

@@ -1,119 +0,0 @@
-<?php
-
-namespace React\Socket;
-
-use React\Stream\DuplexStreamInterface;
-
-/**
- * Any incoming and outgoing connection is represented by this interface,
- * such as a normal TCP/IP connection.
- *
- * An incoming or outgoing connection is a duplex stream (both readable and
- * writable) that implements React's
- * [`DuplexStreamInterface`](https://github.com/reactphp/stream#duplexstreaminterface).
- * It contains additional properties for the local and remote address (client IP)
- * where this connection has been established to/from.
- *
- * Most commonly, instances implementing this `ConnectionInterface` are emitted
- * by all classes implementing the [`ServerInterface`](#serverinterface) and
- * used by all classes implementing the [`ConnectorInterface`](#connectorinterface).
- *
- * Because the `ConnectionInterface` implements the underlying
- * [`DuplexStreamInterface`](https://github.com/reactphp/stream#duplexstreaminterface)
- * you can use any of its events and methods as usual:
- *
- * ```php
- * $connection->on('data', function ($chunk) {
- *     echo $chunk;
- * });
- *
- * $connection->on('end', function () {
- *     echo 'ended';
- * });
- *
- * $connection->on('error', function (Exception $e) {
- *     echo 'error: ' . $e->getMessage();
- * });
- *
- * $connection->on('close', function () {
- *     echo 'closed';
- * });
- *
- * $connection->write($data);
- * $connection->end($data = null);
- * $connection->close();
- * // …
- * ```
- *
- * For more details, see the
- * [`DuplexStreamInterface`](https://github.com/reactphp/stream#duplexstreaminterface).
- *
- * @see DuplexStreamInterface
- * @see ServerInterface
- * @see ConnectorInterface
- */
-interface ConnectionInterface extends DuplexStreamInterface
-{
-    /**
-     * Returns the full remote address (URI) where this connection has been established with
-     *
-     * ```php
-     * $address = $connection->getRemoteAddress();
-     * echo 'Connection with ' . $address . PHP_EOL;
-     * ```
-     *
-     * If the remote address can not be determined or is unknown at this time (such as
-     * after the connection has been closed), it MAY return a `NULL` value instead.
-     *
-     * Otherwise, it will return the full address (URI) as a string value, such
-     * as `tcp://127.0.0.1:8080`, `tcp://[::1]:80`, `tls://127.0.0.1:443`,
-     * `unix://example.sock` or `unix:///path/to/example.sock`.
-     * Note that individual URI components are application specific and depend
-     * on the underlying transport protocol.
-     *
-     * If this is a TCP/IP based connection and you only want the remote IP, you may
-     * use something like this:
-     *
-     * ```php
-     * $address = $connection->getRemoteAddress();
-     * $ip = trim(parse_url($address, PHP_URL_HOST), '[]');
-     * echo 'Connection with ' . $ip . PHP_EOL;
-     * ```
-     *
-     * @return ?string remote address (URI) or null if unknown
-     */
-    public function getRemoteAddress();
-
-    /**
-     * Returns the full local address (full URI with scheme, IP and port) where this connection has been established with
-     *
-     * ```php
-     * $address = $connection->getLocalAddress();
-     * echo 'Connection with ' . $address . PHP_EOL;
-     * ```
-     *
-     * If the local address can not be determined or is unknown at this time (such as
-     * after the connection has been closed), it MAY return a `NULL` value instead.
-     *
-     * Otherwise, it will return the full address (URI) as a string value, such
-     * as `tcp://127.0.0.1:8080`, `tcp://[::1]:80`, `tls://127.0.0.1:443`,
-     * `unix://example.sock` or `unix:///path/to/example.sock`.
-     * Note that individual URI components are application specific and depend
-     * on the underlying transport protocol.
-     *
-     * This method complements the [`getRemoteAddress()`](#getremoteaddress) method,
-     * so they should not be confused.
-     *
-     * If your `TcpServer` instance is listening on multiple interfaces (e.g. using
-     * the address `0.0.0.0`), you can use this method to find out which interface
-     * actually accepted this connection (such as a public or local interface).
-     *
-     * If your system has multiple interfaces (e.g. a WAN and a LAN interface),
-     * you can use this method to find out which interface was actually
-     * used for this connection.
-     *
-     * @return ?string local address (URI) or null if unknown
-     * @see self::getRemoteAddress()
-     */
-    public function getLocalAddress();
-}

package/vendor/react/socket/src/Connector.php

@@ -1,236 +0,0 @@
-<?php
-
-namespace React\Socket;
-
-use React\Dns\Config\Config as DnsConfig;
-use React\Dns\Resolver\Factory as DnsFactory;
-use React\Dns\Resolver\ResolverInterface;
-use React\EventLoop\LoopInterface;
-
-/**
- * The `Connector` class is the main class in this package that implements the
- * `ConnectorInterface` and allows you to create streaming connections.
- *
- * You can use this connector to create any kind of streaming connections, such
- * as plaintext TCP/IP, secure TLS or local Unix connection streams.
- *
- * Under the hood, the `Connector` is implemented as a *higher-level facade*
- * for the lower-level connectors implemented in this package. This means it
- * also shares all of their features and implementation details.
- * If you want to typehint in your higher-level protocol implementation, you SHOULD
- * use the generic [`ConnectorInterface`](#connectorinterface) instead.
- *
- * @see ConnectorInterface for the base interface
- */
-final class Connector implements ConnectorInterface
-{
-    private $connectors = array();
-
-    /**
-     * Instantiate new `Connector`
-     *
-     * ```php
-     * $connector = new React\Socket\Connector();
-     * ```
-     *
-     * This class takes two optional arguments for more advanced usage:
-     *
-     * ```php
-     * // constructor signature as of v1.9.0
-     * $connector = new React\Socket\Connector(array $context = [], ?LoopInterface $loop = null);
-     *
-     * // legacy constructor signature before v1.9.0
-     * $connector = new React\Socket\Connector(?LoopInterface $loop = null, array $context = []);
-     * ```
-     *
-     * This class takes an optional `LoopInterface|null $loop` parameter that can be used to
-     * pass the event loop instance to use for this object. You can use a `null` value
-     * here in order to use the [default loop](https://github.com/reactphp/event-loop#loop).
-     * This value SHOULD NOT be given unless you're sure you want to explicitly use a
-     * given event loop instance.
-     *
-     * @param array|LoopInterface|null $context
-     * @param null|LoopInterface|array $loop
-     * @throws \InvalidArgumentException for invalid arguments
-     */
-    public function __construct($context = array(), $loop = null)
-    {
-        // swap arguments for legacy constructor signature
-        if (($context instanceof LoopInterface || $context === null) && (\func_num_args() <= 1 || \is_array($loop))) {
-            $swap = $loop === null ? array(): $loop;
-            $loop = $context;
-            $context = $swap;
-        }
-
-        if (!\is_array($context) || ($loop !== null && !$loop instanceof LoopInterface)) {
-            throw new \InvalidArgumentException('Expected "array $context" and "?LoopInterface $loop" arguments');
-        }
-
-        // apply default options if not explicitly given
-        $context += array(
-            'tcp' => true,
-            'tls' => true,
-            'unix' => true,
-
-            'dns' => true,
-            'timeout' => true,
-            'happy_eyeballs' => true,
-        );
-
-        if ($context['timeout'] === true) {
-            $context['timeout'] = (float)\ini_get("default_socket_timeout");
-        }
-
-        if ($context['tcp'] instanceof ConnectorInterface) {
-            $tcp = $context['tcp'];
-        } else {
-            $tcp = new TcpConnector(
-                $loop,
-                \is_array($context['tcp']) ? $context['tcp'] : array()
-            );
-        }
-
-        if ($context['dns'] !== false) {
-            if ($context['dns'] instanceof ResolverInterface) {
-                $resolver = $context['dns'];
-            } else {
-                if ($context['dns'] !== true) {
-                    $config = $context['dns'];
-                } else {
-                    // try to load nameservers from system config or default to Google's public DNS
-                    $config = DnsConfig::loadSystemConfigBlocking();
-                    if (!$config->nameservers) {
-                        $config->nameservers[] = '8.8.8.8'; // @codeCoverageIgnore
-                    }
-                }
-
-                $factory = new DnsFactory();
-                $resolver = $factory->createCached(
-                    $config,
-                    $loop
-                );
-            }
-
-            if ($context['happy_eyeballs'] === true) {
-                $tcp = new HappyEyeBallsConnector($loop, $tcp, $resolver);
-            } else {
-                $tcp = new DnsConnector($tcp, $resolver);
-            }
-        }
-
-        if ($context['tcp'] !== false) {
-            $context['tcp'] = $tcp;
-
-            if ($context['timeout'] !== false) {
-                $context['tcp'] = new TimeoutConnector(
-                    $context['tcp'],
-                    $context['timeout'],
-                    $loop
-                );
-            }
-
-            $this->connectors['tcp'] = $context['tcp'];
-        }
-
-        if ($context['tls'] !== false) {
-            if (!$context['tls'] instanceof ConnectorInterface) {
-                $context['tls'] = new SecureConnector(
-                    $tcp,
-                    $loop,
-                    \is_array($context['tls']) ? $context['tls'] : array()
-                );
-            }
-
-            if ($context['timeout'] !== false) {
-                $context['tls'] = new TimeoutConnector(
-                    $context['tls'],
-                    $context['timeout'],
-                    $loop
-                );
-            }
-
-            $this->connectors['tls'] = $context['tls'];
-        }
-
-        if ($context['unix'] !== false) {
-            if (!$context['unix'] instanceof ConnectorInterface) {
-                $context['unix'] = new UnixConnector($loop);
-            }
-            $this->connectors['unix'] = $context['unix'];
-        }
-    }
-
-    public function connect($uri)
-    {
-        $scheme = 'tcp';
-        if (\strpos($uri, '://') !== false) {
-            $scheme = (string)\substr($uri, 0, \strpos($uri, '://'));
-        }
-
-        if (!isset($this->connectors[$scheme])) {
-            return \React\Promise\reject(new \RuntimeException(
-                'No connector available for URI scheme "' . $scheme . '" (EINVAL)',
-                \defined('SOCKET_EINVAL') ? \SOCKET_EINVAL : (\defined('PCNTL_EINVAL') ? \PCNTL_EINVAL : 22)
-            ));
-        }
-
-        return $this->connectors[$scheme]->connect($uri);
-    }
-
-
-    /**
-     * [internal] Builds on URI from the given URI parts and ip address with original hostname as query
-     *
-     * @param array  $parts
-     * @param string $host
-     * @param string $ip
-     * @return string
-     * @internal
-     */
-    public static function uri(array $parts, $host, $ip)
-    {
-        $uri = '';
-
-        // prepend original scheme if known
-        if (isset($parts['scheme'])) {
-            $uri .= $parts['scheme'] . '://';
-        }
-
-        if (\strpos($ip, ':') !== false) {
-            // enclose IPv6 addresses in square brackets before appending port
-            $uri .= '[' . $ip . ']';
-        } else {
-            $uri .= $ip;
-        }
-
-        // append original port if known
-        if (isset($parts['port'])) {
-            $uri .= ':' . $parts['port'];
-        }
-
-        // append orignal path if known
-        if (isset($parts['path'])) {
-            $uri .= $parts['path'];
-        }
-
-        // append original query if known
-        if (isset($parts['query'])) {
-            $uri .= '?' . $parts['query'];
-        }
-
-        // append original hostname as query if resolved via DNS and if
-        // destination URI does not contain "hostname" query param already
-        $args = array();
-        \parse_str(isset($parts['query']) ? $parts['query'] : '', $args);
-        if ($host !== $ip && !isset($args['hostname'])) {
-            $uri .= (isset($parts['query']) ? '&' : '?') . 'hostname=' . \rawurlencode($host);
-        }
-
-        // append original fragment if known
-        if (isset($parts['fragment'])) {
-            $uri .= '#' . $parts['fragment'];
-        }
-
-        return $uri;
-    }
-}

package/vendor/react/socket/src/ConnectorInterface.php

@@ -1,59 +0,0 @@
-<?php
-
-namespace React\Socket;
-
-/**
- * The `ConnectorInterface` is responsible for providing an interface for
- * establishing streaming connections, such as a normal TCP/IP connection.
- *
- * This is the main interface defined in this package and it is used throughout
- * React's vast ecosystem.
- *
- * Most higher-level components (such as HTTP, database or other networking
- * service clients) accept an instance implementing this interface to create their
- * TCP/IP connection to the underlying networking service.
- * This is usually done via dependency injection, so it's fairly simple to actually
- * swap this implementation against any other implementation of this interface.
- *
- * The interface only offers a single `connect()` method.
- *
- * @see ConnectionInterface
- */
-interface ConnectorInterface
-{
-    /**
-     * Creates a streaming connection to the given remote address
-     *
-     * If returns a Promise which either fulfills with a stream implementing
-     * `ConnectionInterface` on success or rejects with an `Exception` if the
-     * connection is not successful.
-     *
-     * ```php
-     * $connector->connect('google.com:443')->then(
-     *     function (React\Socket\ConnectionInterface $connection) {
-     *         // connection successfully established
-     *     },
-     *     function (Exception $error) {
-     *         // failed to connect due to $error
-     *     }
-     * );
-     * ```
-     *
-     * The returned Promise MUST be implemented in such a way that it can be
-     * cancelled when it is still pending. Cancelling a pending promise MUST
-     * reject its value with an Exception. It SHOULD clean up any underlying
-     * resources and references as applicable.
-     *
-     * ```php
-     * $promise = $connector->connect($uri);
-     *
-     * $promise->cancel();
-     * ```
-     *
-     * @param string $uri
-     * @return \React\Promise\PromiseInterface<ConnectionInterface>
-     *     Resolves with a `ConnectionInterface` on success or rejects with an `Exception` on error.
-     * @see ConnectionInterface
-     */
-    public function connect($uri);
-}