Http\Adapter\React\Promise

Complexity

Total Complexity

10

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	35	4
A	then()	0	4	1
A	getState()	0	4	1
A	wait()	0	18	4

<?php

namespace Http\Adapter\React;

use Http\Client\Exception as HttplugException;
use Http\Promise\Promise as HttpPromise;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use React\EventLoop\LoopInterface;
use React\Promise\PromiseInterface;
use RuntimeException;
use UnexpectedValueException;

/**
 * React promise adapter implementation.
 *
 * @author Stéphane Hulard <s.hulard@chstudio.fr>
 *
 * @internal
 */
final class Promise implements HttpPromise
{
    /**
     * Promise status.
     *
     * @var string
     */
    private $state = HttpPromise::PENDING;

    /**
     * PSR7 received response.
     *
     * @var ResponseInterface
     */
    private $response;

    /**
     * Execution error.
     *
     * @var Exception
     */
    private $exception;

    /**
     * HTTP Request
     *
     * @var RequestInterface
     */
    private $request;

    /**
     * Adapted ReactPHP promise
     *
     * @var PromiseInterface
     */
    private $promise;

    /**
     * ReactPHP LoopInterface
     *
     * @var LoopInterface
     */
    private $loop;

    public function __construct(PromiseInterface $promise, LoopInterface $loop, RequestInterface $request)
    {
        $this->state = self::PENDING;

        $this->request = $request;
        $this->loop    = $loop;
        $this->promise = $promise->then(
            /**
             * @param ResponseInterface|null $response
             */
            function (?ResponseInterface $response): ResponseInterface {
                $this->response = $response;
                $this->state = self::FULFILLED;

                return $response;
            },
            /**
             * @param mixed $reason
             */
            function ($reason): void {
                $this->state = self::REJECTED;

                if ($reason instanceof HttplugException) {
                    $this->exception = $reason;

It seems like $reason of type object<Http\Client\Exception> is incompatible with the declared type object<Http\Adapter\React\Exception> of property $exception.

                } elseif ($reason instanceof RuntimeException) {
                    $this->exception = new HttplugException\NetworkException($reason->getMessage(), $this->request, $reason);

It seems like new \Http\Client\Exception\NetworkException($reason->getMessage(), $this->request, $reason) of type object<Http\Client\Exception\NetworkException> is incompatible with the declared type object<Http\Adapter\React\Exception> of property $exception.

                } elseif ($reason instanceof \Throwable) {
                    $this->exception = new HttplugException\TransferException('Invalid exception returned from ReactPHP', 0, $reason);

It seems like new \Http\Client\Exception\TransferException('Invalid exception returned from ReactPHP', 0, $reason) of type object<Http\Client\Exception\TransferException> is incompatible with the declared type object<Http\Adapter\React\Exception> of property $exception.

                } else {
                    $this->exception = new UnexpectedValueException('Reason returned from ReactPHP must be an Exception');

It seems like new \UnexpectedValueException('Reason returned from ReactPHP must be an Exception') of type object<UnexpectedValueException> is incompatible with the declared type object<Http\Adapter\React\Exception> of property $exception.

                }

                throw $this->exception;
            });
    }

    public function then(?callable $onFulfilled = null, ?callable $onRejected = null)
    {
        return new self($this->promise->then($onFulfilled, $onRejected), $this->loop, $this->request);
    }

    /**
     * {@inheritdoc}
     */
    public function getState()
    {
        return $this->state;
    }

    /**
     * {@inheritdoc}
     */
    public function wait($unwrap = true)
    {
        $loop = $this->loop;
        while (HttpPromise::PENDING === $this->getState()) {
            $loop->futureTick(function () use ($loop) {
                $loop->stop();
            });
            $loop->run();
        }

        if ($unwrap) {
            if (HttpPromise::REJECTED == $this->getState()) {
                throw $this->exception;
            }

            return $this->response;
        }
    }
}