@averay/codeformat 0.2.7 → 0.2.9

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

@@ -1,132 +0,0 @@
-<?php
-
-namespace React\Socket;
-
-use React\EventLoop\Loop;
-use React\EventLoop\LoopInterface;
-use React\Promise;
-use BadMethodCallException;
-use InvalidArgumentException;
-use UnexpectedValueException;
-
-final class SecureConnector implements ConnectorInterface
-{
-    private $connector;
-    private $streamEncryption;
-    private $context;
-
-    /**
-     * @param ConnectorInterface $connector
-     * @param ?LoopInterface $loop
-     * @param array $context
-     */
-    public function __construct(ConnectorInterface $connector, $loop = null, array $context = array())
-    {
-        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');
-        }
-
-        $this->connector = $connector;
-        $this->streamEncryption = new StreamEncryption($loop ?: Loop::get(), false);
-        $this->context = $context;
-    }
-
-    public function connect($uri)
-    {
-        if (!\function_exists('stream_socket_enable_crypto')) {
-            return Promise\reject(new \BadMethodCallException('Encryption not supported on your platform (HHVM < 3.8?)')); // @codeCoverageIgnore
-        }
-
-        if (\strpos($uri, '://') === false) {
-            $uri = 'tls://' . $uri;
-        }
-
-        $parts = \parse_url($uri);
-        if (!$parts || !isset($parts['scheme']) || $parts['scheme'] !== 'tls') {
-            return Promise\reject(new \InvalidArgumentException(
-                'Given URI "' . $uri . '" is invalid (EINVAL)',
-                \defined('SOCKET_EINVAL') ? \SOCKET_EINVAL : (\defined('PCNTL_EINVAL') ? \PCNTL_EINVAL : 22)
-            ));
-        }
-
-        $context = $this->context;
-        $encryption = $this->streamEncryption;
-        $connected = false;
-        /** @var \React\Promise\PromiseInterface<ConnectionInterface> $promise */
-        $promise = $this->connector->connect(
-            \str_replace('tls://', '', $uri)
-        )->then(function (ConnectionInterface $connection) use ($context, $encryption, $uri, &$promise, &$connected) {
-            // (unencrypted) TCP/IP connection succeeded
-            $connected = true;
-
-            if (!$connection instanceof Connection) {
-                $connection->close();
-                throw new \UnexpectedValueException('Base connector does not use internal Connection class exposing stream resource');
-            }
-
-            // set required SSL/TLS context options
-            foreach ($context as $name => $value) {
-                \stream_context_set_option($connection->stream, 'ssl', $name, $value);
-            }
-
-            // try to enable encryption
-            return $promise = $encryption->enable($connection)->then(null, function ($error) use ($connection, $uri) {
-                // establishing encryption failed => close invalid connection and return error
-                $connection->close();
-
-                throw new \RuntimeException(
-                    'Connection to ' . $uri . ' failed during TLS handshake: ' . $error->getMessage(),
-                    $error->getCode()
-                );
-            });
-        }, function (\Exception $e) use ($uri) {
-            if ($e instanceof \RuntimeException) {
-                $message = \preg_replace('/^Connection to [^ ]+/', '', $e->getMessage());
-                $e = new \RuntimeException(
-                    'Connection to ' . $uri . $message,
-                    $e->getCode(),
-                    $e
-                );
-
-                // avoid garbage references by replacing all closures in call stack.
-                // what a lovely piece of code!
-                $r = new \ReflectionProperty('Exception', 'trace');
-                $r->setAccessible(true);
-                $trace = $r->getValue($e);
-
-                // Exception trace arguments are not available on some PHP 7.4 installs
-                // @codeCoverageIgnoreStart
-                foreach ($trace as $ti => $one) {
-                    if (isset($one['args'])) {
-                        foreach ($one['args'] as $ai => $arg) {
-                            if ($arg instanceof \Closure) {
-                                $trace[$ti]['args'][$ai] = 'Object(' . \get_class($arg) . ')';
-                            }
-                        }
-                    }
-                }
-                // @codeCoverageIgnoreEnd
-                $r->setValue($e, $trace);
-            }
-
-            throw $e;
-        });
-
-        return new \React\Promise\Promise(
-            function ($resolve, $reject) use ($promise) {
-                $promise->then($resolve, $reject);
-            },
-            function ($_, $reject) use (&$promise, $uri, &$connected) {
-                if ($connected) {
-                    $reject(new \RuntimeException(
-                        'Connection to ' . $uri . ' cancelled during TLS handshake (ECONNABORTED)',
-                        \defined('SOCKET_ECONNABORTED') ? \SOCKET_ECONNABORTED : 103
-                    ));
-                }
-
-                $promise->cancel();
-                $promise = null;
-            }
-        );
-    }
-}

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

@@ -1,210 +0,0 @@
-<?php
-
-namespace React\Socket;
-
-use Evenement\EventEmitter;
-use React\EventLoop\Loop;
-use React\EventLoop\LoopInterface;
-use BadMethodCallException;
-use UnexpectedValueException;
-
-/**
- * The `SecureServer` class implements the `ServerInterface` and is responsible
- * for providing a secure TLS (formerly known as SSL) server.
- *
- * It does so by wrapping a `TcpServer` instance which waits for plaintext
- * TCP/IP connections and then performs a TLS handshake for each connection.
- *
- * ```php
- * $server = new React\Socket\TcpServer(8000);
- * $server = new React\Socket\SecureServer($server, null, array(
- *     // tls context options here…
- * ));
- * ```
- *
- * Whenever a client completes the TLS handshake, it will emit a `connection` event
- * with a connection instance implementing [`ConnectionInterface`](#connectioninterface):
- *
- * ```php
- * $server->on('connection', function (React\Socket\ConnectionInterface $connection) {
- *     echo 'Secure connection from' . $connection->getRemoteAddress() . PHP_EOL;
- *
- *     $connection->write('hello there!' . PHP_EOL);
- *     …
- * });
- * ```
- *
- * Whenever a client fails to perform a successful TLS handshake, it will emit an
- * `error` event and then close the underlying TCP/IP connection:
- *
- * ```php
- * $server->on('error', function (Exception $e) {
- *     echo 'Error' . $e->getMessage() . PHP_EOL;
- * });
- * ```
- *
- * See also the `ServerInterface` for more details.
- *
- * Note that the `SecureServer` class is a concrete implementation for TLS sockets.
- * If you want to typehint in your higher-level protocol implementation, you SHOULD
- * use the generic `ServerInterface` instead.
- *
- * @see ServerInterface
- * @see ConnectionInterface
- */
-final class SecureServer extends EventEmitter implements ServerInterface
-{
-    private $tcp;
-    private $encryption;
-    private $context;
-
-    /**
-     * Creates a secure TLS server and starts waiting for incoming connections
-     *
-     * It does so by wrapping a `TcpServer` instance which waits for plaintext
-     * TCP/IP connections and then performs a TLS handshake for each connection.
-     * It thus requires valid [TLS context options],
-     * which in its most basic form may look something like this if you're using a
-     * PEM encoded certificate file:
-     *
-     * ```php
-     * $server = new React\Socket\TcpServer(8000);
-     * $server = new React\Socket\SecureServer($server, null, array(
-     *     'local_cert' => 'server.pem'
-     * ));
-     * ```
-     *
-     * Note that the certificate file will not be loaded on instantiation but when an
-     * incoming connection initializes its TLS context.
-     * This implies that any invalid certificate file paths or contents will only cause
-     * an `error` event at a later time.
-     *
-     * If your private key is encrypted with a passphrase, you have to specify it
-     * like this:
-     *
-     * ```php
-     * $server = new React\Socket\TcpServer(8000);
-     * $server = new React\Socket\SecureServer($server, null, array(
-     *     'local_cert' => 'server.pem',
-     *     'passphrase' => 'secret'
-     * ));
-     * ```
-     *
-     * Note that available [TLS context options],
-     * their defaults and effects of changing these may vary depending on your system
-     * and/or PHP version.
-     * Passing unknown context options has no effect.
-     *
-     * 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.
-     *
-     * Advanced usage: Despite allowing any `ServerInterface` as first parameter,
-     * you SHOULD pass a `TcpServer` instance as first parameter, unless you
-     * know what you're doing.
-     * Internally, the `SecureServer` has to set the required TLS context options on
-     * the underlying stream resources.
-     * These resources are not exposed through any of the interfaces defined in this
-     * package, but only through the internal `Connection` class.
-     * The `TcpServer` class is guaranteed to emit connections that implement
-     * the `ConnectionInterface` and uses the internal `Connection` class in order to
-     * expose these underlying resources.
-     * If you use a custom `ServerInterface` and its `connection` event does not
-     * meet this requirement, the `SecureServer` will emit an `error` event and
-     * then close the underlying connection.
-     *
-     * @param ServerInterface|TcpServer $tcp
-     * @param ?LoopInterface $loop
-     * @param array $context
-     * @throws BadMethodCallException for legacy HHVM < 3.8 due to lack of support
-     * @see TcpServer
-     * @link https://www.php.net/manual/en/context.ssl.php for TLS context options
-     */
-    public function __construct(ServerInterface $tcp, $loop = null, array $context = array())
-    {
-        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 (!\function_exists('stream_socket_enable_crypto')) {
-            throw new \BadMethodCallException('Encryption not supported on your platform (HHVM < 3.8?)'); // @codeCoverageIgnore
-        }
-
-        // default to empty passphrase to suppress blocking passphrase prompt
-        $context += array(
-            'passphrase' => ''
-        );
-
-        $this->tcp = $tcp;
-        $this->encryption = new StreamEncryption($loop ?: Loop::get());
-        $this->context = $context;
-
-        $that = $this;
-        $this->tcp->on('connection', function ($connection) use ($that) {
-            $that->handleConnection($connection);
-        });
-        $this->tcp->on('error', function ($error) use ($that) {
-            $that->emit('error', array($error));
-        });
-    }
-
-    public function getAddress()
-    {
-        $address = $this->tcp->getAddress();
-        if ($address === null) {
-            return null;
-        }
-
-        return \str_replace('tcp://' , 'tls://', $address);
-    }
-
-    public function pause()
-    {
-        $this->tcp->pause();
-    }
-
-    public function resume()
-    {
-        $this->tcp->resume();
-    }
-
-    public function close()
-    {
-        return $this->tcp->close();
-    }
-
-    /** @internal */
-    public function handleConnection(ConnectionInterface $connection)
-    {
-        if (!$connection instanceof Connection) {
-            $this->emit('error', array(new \UnexpectedValueException('Base server does not use internal Connection class exposing stream resource')));
-            $connection->close();
-            return;
-        }
-
-        foreach ($this->context as $name => $value) {
-            \stream_context_set_option($connection->stream, 'ssl', $name, $value);
-        }
-
-        // get remote address before starting TLS handshake in case connection closes during handshake
-        $remote = $connection->getRemoteAddress();
-        $that = $this;
-
-        $this->encryption->enable($connection)->then(
-            function ($conn) use ($that) {
-                $that->emit('connection', array($conn));
-            },
-            function ($error) use ($that, $connection, $remote) {
-                $error = new \RuntimeException(
-                    'Connection from ' . $remote . ' failed during TLS handshake: ' . $error->getMessage(),
-                    $error->getCode()
-                );
-
-                $that->emit('error', array($error));
-                $connection->close();
-            }
-        );
-    }
-}

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

@@ -1,118 +0,0 @@
-<?php
-
-namespace React\Socket;
-
-use Evenement\EventEmitter;
-use React\EventLoop\Loop;
-use React\EventLoop\LoopInterface;
-use Exception;
-
-/**
- * @deprecated 1.9.0 See `SocketServer` instead
- * @see SocketServer
- */
-final class Server extends EventEmitter implements ServerInterface
-{
-    private $server;
-
-    /**
-     * [Deprecated] `Server`
-     *
-     * This class exists for BC reasons only and should not be used anymore.
-     *
-     * ```php
-     * // deprecated
-     * $socket = new React\Socket\Server(0);
-     * $socket = new React\Socket\Server('127.0.0.1:8000');
-     * $socket = new React\Socket\Server('127.0.0.1:8000', null, $context);
-     * $socket = new React\Socket\Server('127.0.0.1:8000', $loop, $context);
-     *
-     * // new
-     * $socket = new React\Socket\SocketServer('127.0.0.1:0');
-     * $socket = new React\Socket\SocketServer('127.0.0.1:8000');
-     * $socket = new React\Socket\SocketServer('127.0.0.1:8000', $context);
-     * $socket = new React\Socket\SocketServer('127.0.0.1:8000', $context, $loop);
-     * ```
-     *
-     * 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.
-     *
-     * For BC reasons, you can also pass the TCP socket context options as a simple
-     * array without wrapping this in another array under the `tcp` key.
-     *
-     * @param string|int     $uri
-     * @param ?LoopInterface $loop
-     * @param array          $context
-     * @deprecated 1.9.0 See `SocketServer` instead
-     * @see SocketServer
-     */
-    public function __construct($uri, $loop = null, array $context = array())
-    {
-        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');
-        }
-
-        $loop = $loop ?: Loop::get();
-
-        // sanitize TCP context options if not properly wrapped
-        if ($context && (!isset($context['tcp']) && !isset($context['tls']) && !isset($context['unix']))) {
-            $context = array('tcp' => $context);
-        }
-
-        // apply default options if not explicitly given
-        $context += array(
-            'tcp' => array(),
-            'tls' => array(),
-            'unix' => array()
-        );
-
-        $scheme = 'tcp';
-        $pos = \strpos($uri, '://');
-        if ($pos !== false) {
-            $scheme = \substr($uri, 0, $pos);
-        }
-
-        if ($scheme === 'unix') {
-            $server = new UnixServer($uri, $loop, $context['unix']);
-        } else {
-            $server = new TcpServer(str_replace('tls://', '', $uri), $loop, $context['tcp']);
-
-            if ($scheme === 'tls') {
-                $server = new SecureServer($server, $loop, $context['tls']);
-            }
-        }
-
-        $this->server = $server;
-
-        $that = $this;
-        $server->on('connection', function (ConnectionInterface $conn) use ($that) {
-            $that->emit('connection', array($conn));
-        });
-        $server->on('error', function (Exception $error) use ($that) {
-            $that->emit('error', array($error));
-        });
-    }
-
-    public function getAddress()
-    {
-        return $this->server->getAddress();
-    }
-
-    public function pause()
-    {
-        $this->server->pause();
-    }
-
-    public function resume()
-    {
-        $this->server->resume();
-    }
-
-    public function close()
-    {
-        $this->server->close();
-    }
-}

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

@@ -1,151 +0,0 @@
-<?php
-
-namespace React\Socket;
-
-use Evenement\EventEmitterInterface;
-
-/**
- * The `ServerInterface` is responsible for providing an interface for accepting
- * incoming streaming connections, such as a normal TCP/IP connection.
- *
- * Most higher-level components (such as a HTTP server) accept an instance
- * implementing this interface to accept incoming streaming connections.
- * This is usually done via dependency injection, so it's fairly simple to actually
- * swap this implementation against any other implementation of this interface.
- * This means that you SHOULD typehint against this interface instead of a concrete
- * implementation of this interface.
- *
- * Besides defining a few methods, this interface also implements the
- * `EventEmitterInterface` which allows you to react to certain events:
- *
- * connection event:
- *     The `connection` event will be emitted whenever a new connection has been
- *     established, i.e. a new client connects to this server socket:
- *
- *     ```php
- *     $socket->on('connection', function (React\Socket\ConnectionInterface $connection) {
- *         echo 'new connection' . PHP_EOL;
- *     });
- *     ```
- *
- *     See also the `ConnectionInterface` for more details about handling the
- *     incoming connection.
- *
- * error event:
- *     The `error` event will be emitted whenever there's an error accepting a new
- *     connection from a client.
- *
- *     ```php
- *     $socket->on('error', function (Exception $e) {
- *         echo 'error: ' . $e->getMessage() . PHP_EOL;
- *     });
- *     ```
- *
- *     Note that this is not a fatal error event, i.e. the server keeps listening for
- *     new connections even after this event.
- *
- * @see ConnectionInterface
- */
-interface ServerInterface extends EventEmitterInterface
-{
-    /**
-     * Returns the full address (URI) this server is currently listening on
-     *
-     * ```php
-     * $address = $socket->getAddress();
-     * echo 'Server listening on ' . $address . PHP_EOL;
-     * ```
-     *
-     * If the address can not be determined or is unknown at this time (such as
-     * after the socket 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` or `tls://127.0.0.1:443`.
-     * Note that individual URI components are application specific and depend
-     * on the underlying transport protocol.
-     *
-     * If this is a TCP/IP based server and you only want the local port, you may
-     * use something like this:
-     *
-     * ```php
-     * $address = $socket->getAddress();
-     * $port = parse_url($address, PHP_URL_PORT);
-     * echo 'Server listening on port ' . $port . PHP_EOL;
-     * ```
-     *
-     * @return ?string the full listening address (URI) or NULL if it is unknown (not applicable to this server socket or already closed)
-     */
-    public function getAddress();
-
-    /**
-     * Pauses accepting new incoming connections.
-     *
-     * Removes the socket resource from the EventLoop and thus stop accepting
-     * new connections. Note that the listening socket stays active and is not
-     * closed.
-     *
-     * This means that new incoming connections will stay pending in the
-     * operating system backlog until its configurable backlog is filled.
-     * Once the backlog is filled, the operating system may reject further
-     * incoming connections until the backlog is drained again by resuming
-     * to accept new connections.
-     *
-     * Once the server is paused, no futher `connection` events SHOULD
-     * be emitted.
-     *
-     * ```php
-     * $socket->pause();
-     *
-     * $socket->on('connection', assertShouldNeverCalled());
-     * ```
-     *
-     * This method is advisory-only, though generally not recommended, the
-     * server MAY continue emitting `connection` events.
-     *
-     * Unless otherwise noted, a successfully opened server SHOULD NOT start
-     * in paused state.
-     *
-     * You can continue processing events by calling `resume()` again.
-     *
-     * Note that both methods can be called any number of times, in particular
-     * calling `pause()` more than once SHOULD NOT have any effect.
-     * Similarly, calling this after `close()` is a NO-OP.
-     *
-     * @see self::resume()
-     * @return void
-     */
-    public function pause();
-
-    /**
-     * Resumes accepting new incoming connections.
-     *
-     * Re-attach the socket resource to the EventLoop after a previous `pause()`.
-     *
-     * ```php
-     * $socket->pause();
-     *
-     * Loop::addTimer(1.0, function () use ($socket) {
-     *     $socket->resume();
-     * });
-     * ```
-     *
-     * Note that both methods can be called any number of times, in particular
-     * calling `resume()` without a prior `pause()` SHOULD NOT have any effect.
-     * Similarly, calling this after `close()` is a NO-OP.
-     *
-     * @see self::pause()
-     * @return void
-     */
-    public function resume();
-
-    /**
-     * Shuts down this listening socket
-     *
-     * This will stop listening for new incoming connections on this socket.
-     *
-     * Calling this method more than once on the same instance is a NO-OP.
-     *
-     * @return void
-     */
-    public function close();
-}