Http\Adapter\ReactHttpAdapter

Complexity

Total Complexity

12

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

85%

Importance

Changes	3
Bugs	2	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	16	4
A	sendRequest()	0	6	1
A	sendAsyncRequest()	0	47	3
A	buildReactRequest()	0	19	4

<?php

namespace Http\Adapter;

use React\EventLoop\LoopInterface;
use React\Promise\Deferred;
use React\HttpClient\Client;
use React\HttpClient\Request as ReactRequest;
use React\HttpClient\Response as ReactResponse;
use Http\Client\HttpClient;
use Http\Client\HttpAsyncClient;
use Http\Client\Exception\HttpException;
use Http\Client\Exception\RequestException;
use Http\Promise\Promise;
use Http\Message\MessageFactory;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\StreamInterface;

/**
 * Client for the React promise implementation
 * @author Stéphane Hulard <stephane@hlrd.me>
 */
class ReactHttpAdapter implements HttpClient, HttpAsyncClient
{
    /**
     * React HTTP client
     * @var Client
     */
    private $client;

    /**
     * React event loop
     * @var LoopInterface
     */
    private $loop;

    /**
     * Initialize the React client
     * @param LoopInterface|null $loop     React Event loop
     * @param Resolver           $resolver React async DNS resolver

There is no parameter named $resolver. Was it maybe removed?

     */
    public function __construct(
        MessageFactory $messageFactory,
        LoopInterface $loop = null,
        Client $client = null
    ) {
        $this->loop = null === $loop?ReactFactory::buildEventLoop():$loop;
        if (null === $client) {
            $this->client = ReactFactory::buildHttpClient($this->loop);
        } elseif (null === $loop) {
            throw new \RuntimeException(
                "You must give a LoopInterface instance with the Client"
            );
        }

        $this->messageFactory = new ReactMessageFactory($messageFactory);

The property messageFactory does not exist. Did you maybe forget to declare it?

    }

    /**
     * {@inheritdoc}
     */
    public function sendRequest(RequestInterface $request)
    {
        $promise = $this->sendAsyncRequest($request);

        return $promise->wait();
    }

    /**
     * {@inheritdoc}
     */
    public function sendAsyncRequest(RequestInterface $request)
    {
        $requestStream = $this->buildReactRequest($request);
        $deferred = new Deferred();

        $requestStream->on('error', function (\Exception $error) use ($deferred, $request) {
            $deferred->reject(new RequestException(
                $error->getMessage(),
                $request,
                $error
            ));
        });
        $requestStream->on('response', function (ReactResponse $response = null) use ($deferred, $requestStream, $request) {
            $bodyStream = null;
            $response->on('data', function ($data) use (&$bodyStream) {

It seems like $response is not always an object, but can also be of type null. Maybe add an additional type check?

                if ($data instanceof StreamInterface) {
                    $bodyStream = $data;
                } else {
                    $bodyStream->write($data);

The method write cannot be called on $bodyStream (of type null).

                }
            });

            $response->on('end', function (\Exception $error = null) use ($deferred, $request, $response, &$bodyStream) {

It seems like $response is not always an object, but can also be of type null. Maybe add an additional type check?

                $bodyStream->rewind();

The method rewind cannot be called on $bodyStream (of type null).

                $psr7Response = $this->messageFactory->buildResponse(
                    $response,
                    $bodyStream
                );
                if (null !== $error) {
                    $deferred->reject(new HttpException(
                        $error->getMessage(),
                        $request,
                        $psr7Response,
                        $error
                    ));
                } else {
                    $deferred->resolve($psr7Response);
                }
            });
        });

        $requestStream->end((string)$request->getBody());

        $promise = new ReactPromiseAdapter($deferred->promise());
        $promise->setLoop($this->loop);
        return $promise;
    }

    /**
     * Build a React request from the PSR7 RequestInterface
     * @param  RequestInterface $request
     * @return ReactRequest
     */
    private function buildReactRequest(RequestInterface $request)
    {
        $headers = [];
        foreach ($request->getHeaders() as $name => $value) {
            $headers[$name] = (is_array($value)?$value[0]:$value);
        }
        if ($request->getBody()->getSize() > 0) {
            $headers['Content-Length'] = $request->getBody()->getSize();
        }

        $reactRequest = $this->client->request(
            $request->getMethod(),
            (string)$request->getUri(),
            $headers,
            $request->getProtocolVersion()
        );

        return $reactRequest;
    }
}