Http\Adapter\ReactPromiseAdapter

Complexity

Total Complexity

11

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	1	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getState()	0	4	1
A	__construct()	0	14	1
A	then()	0	13	3
A	setLoop()	0	5	1
B	wait()	0	17	5

<?php

namespace Http\Adapter;

use React\EventLoop\LoopInterface;
use React\Promise\PromiseInterface as ReactPromise;
use Http\Client\Exception;
use Http\Promise\Promise;
use Psr\Http\Message\ResponseInterface;

/**
 * React promise adapter implementation
 * @author Stéphane Hulard <stephane@hlrd.me>
 */
class ReactPromiseAdapter implements Promise
{
    /**
     * Promise status
     * @var string
     */
    private $state = Promise::PENDING;

    /**
     * Adapted React promise
     * @var ReactPromise
     */
    private $promise;

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

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

    /**
     * React Event Loop used for synchronous processing
     * @var LoopInterface
     */
    private $loop;

    /**
     * Initialize the promise
     * @param ReactPromise $promise
     */
    public function __construct(ReactPromise $promise)
    {
        $promise->then(
            function (ResponseInterface $response) {
                $this->state = Promise::FULFILLED;
                $this->response = $response;
            },
            function (Exception $error) {
                $this->state = Promise::REJECTED;
                $this->exception = $error;
            }
        );
        $this->promise = $promise;
    }

    /**
     * Allow to apply callable when the promise resolve
     * @param  callable|null $onFulfilled
     * @param  callable|null $onRejected
     * @return ReactPromiseAdapter
     */
    public function then(callable $onFulfilled = null, callable $onRejected = null)
    {
        $this->promise->then(function () use ($onFulfilled) {
            if (null !== $onFulfilled) {
                call_user_func($onFulfilled, $this->response);
            }
        }, function () use ($onRejected) {
            if (null !== $onRejected) {
                call_user_func($onRejected, $this->exception);
            }
        });
        return $this;
    }

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

    /**
     * Set EventLoop used for synchronous processing
     * @param LoopInterface $loop
     * @return ReactPromiseAdapter
     */
    public function setLoop(LoopInterface $loop)
    {
        $this->loop = $loop;
        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function wait($unwrap = true)
    {
        if (null === $this->loop) {
            throw new \LogicException("You must set the loop before wait!");
        }
        while (Promise::PENDING === $this->getState()) {
            $this->loop->tick();
        }

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

            return $this->response;
        }
    }
}