Ivory\HttpAdapter\Guzzle3HttpAdapter

Complexity

Total Complexity

12

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

10.47%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	getName()	0	4	1
B	sendInternalRequest()	0	27	2
A	sendInternalRequests()	0	12	3
A	createFile()	0	4	1
A	createRequest()	0	64	3

<?php

/*
 * This file is part of the Ivory Http Adapter package.
 *
 * (c) Eric GELOEN <geloen.eric@gmail.com>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Ivory\HttpAdapter;

use Guzzle\Common\Event;
use Guzzle\Http\Client;
use Guzzle\Http\ClientInterface;
use Guzzle\Http\Exception\RequestException;
use Ivory\HttpAdapter\Message\InternalRequestInterface;
use Ivory\HttpAdapter\Normalizer\BodyNormalizer;

/**
 * @author GeLo <geloen.eric@gmail.com>
 */
class Guzzle3HttpAdapter extends AbstractCurlHttpAdapter
{
    /**
     * @var ClientInterface
     */
    private $client;

    /**
     * @param ClientInterface|null        $client
     * @param ConfigurationInterface|null $configuration
     */
    public function __construct(ClientInterface $client = null, ConfigurationInterface $configuration = null)
    {
        parent::__construct($configuration);

        $this->client = $client ?: new Client();
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return 'guzzle3';
    }

    /**
     * {@inheritdoc}
     */
    protected function sendInternalRequest(InternalRequestInterface $internalRequest)
    {
        try {
            $response = $this->createRequest($internalRequest)->send();
        } catch (RequestException $e) {
            throw HttpAdapterException::cannotFetchUri(
                $e->getRequest()->getUrl(),

It seems like $e->getRequest()->getUrl() targeting Guzzle\Http\Message\RequestInterface::getUrl() can also be of type object<Guzzle\Http\Url>; however, Ivory\HttpAdapter\HttpAdapterException::cannotFetchUri() does only seem to accept string, maybe add an additional type check?

                $this->getName(),
                $e->getMessage()
            );
        }

        return $this->getConfiguration()->getMessageFactory()->createResponse(
            $response->getStatusCode(),
            $response->getProtocolVersion(),
            $response->getHeaders()->toArray(),
            BodyNormalizer::normalize(
                function () use ($response) {
                    $resource = $response->getBody()->getStream();
                    $response->getBody()->detachStream();

                    return $resource;
                },
                $internalRequest->getMethod()
            )
        );
    }

    /**
     * {@inheritdoc}
     */
    protected function sendInternalRequests(array $internalRequests, $success, $error)
    {
        $requests = [];
        foreach ($internalRequests as $internalRequest) {
            $requests[] = $this->createRequest($internalRequest, $success, $error);
        }

        try {
            $this->client->send($requests);
        } catch (\Exception $e) {

Consider adding a comment why this CATCH block is empty.

        }
    }

    /**
     * {@inheritdoc}
     */
    protected function createFile($file)
    {
        return '@'.$file;
    }

    /**
     * @param InternalRequestInterface $internalRequest
     * @param callable|null            $success
     * @param callable|null            $error
     *
     * @return RequestInterface
     */
    private function createRequest(InternalRequestInterface $internalRequest, $success = null, $error = null)
    {
        $request = $this->client->createRequest(
            $internalRequest->getMethod(),
            (string) $internalRequest->getUri(),
            $this->prepareHeaders($internalRequest),
            $this->prepareContent($internalRequest),
            [
                'exceptions'      => false,
                'allow_redirects' => false,
                'timeout'         => $this->getConfiguration()->getTimeout(),
                'connect_timeout' => $this->getConfiguration()->getTimeout(),
            ]
        );

        $request->setProtocolVersion($internalRequest->getProtocolVersion());

        if (is_callable($success)) {
            $messageFactory = $this->getConfiguration()->getMessageFactory();

            $request->getEventDispatcher()->addListener(
                'request.success',
                function (Event $event) use ($messageFactory, $success, $internalRequest) {
                    $response = $messageFactory->createResponse(
                        $event['response']->getStatusCode(),
                        $event['response']->getProtocolVersion(),
                        $event['response']->getHeaders()->toArray(),
                        BodyNormalizer::normalize(
                            function () use ($event) {
                                $resource = $event['response']->getBody()->getStream();
                                $event['response']->getBody()->detachStream();

                                return $resource;
                            },
                            $internalRequest->getMethod()
                        )
                    );

                    $response = $response->withParameter('request', $internalRequest);
                    call_user_func($success, $response);
                }
            );
        }

        if (is_callable($error)) {
            $httpAdapterName = $this->getName();

            $request->getEventDispatcher()->addListener(
                'request.exception',
                function (Event $event) use ($error, $internalRequest, $httpAdapterName) {
                    $exception = HttpAdapterException::cannotFetchUri(
                        $event['exception']->getRequest()->getUrl(),
                        $httpAdapterName,
                        $event['exception']->getMessage()
                    );

                    $exception->setRequest($internalRequest);
                    call_user_func($error, $exception);
                }
            );
        }

        return $request;
    }
}