Http\Adapter\React\Promise

Complexity

Total Complexity

10

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	1	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	30	4
A	then()	0	3	1
A	wait()	0	16	4
A	getState()	0	3	1

<?php

namespace Http\Adapter\React;

use Http\Adapter\React\Exception\UnexpectedValueException;
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;

/**
 * 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(
            function (?ResponseInterface $response): ResponseInterface {
                $this->response = $response;
                $this->state = self::FULFILLED;

                return $response;

The expression return $response could return the type null which is incompatible with the type-hinted return Psr\Http\Message\ResponseInterface. Consider adding an additional type-check to rule them out.

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

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

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

                } elseif ($reason instanceof RuntimeException) {
                    $this->exception = new HttplugException\NetworkException($reason->getMessage(), $this->request, $reason);
                } elseif ($reason instanceof \Throwable) {
                    $this->exception = new HttplugException\TransferException('Invalid exception returned from ReactPHP', 0, $reason);
                } else {
                    $this->exception = new UnexpectedValueException('Reason returned from ReactPHP must be an 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;
        }
    }
}