TreeHouse\IoBundle\Scrape\Crawler\Client\GuzzleClient

Complexity

Total Complexity

9

Size/Duplication

Total Lines	90
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

69.23%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setEffectiveUri()	0	4	1
A	fetch()	0	21	3
A	getRequestOptions()	0	14	2
A	transformResponse()	0	7	2

<?php

namespace TreeHouse\IoBundle\Scrape\Crawler\Client;

use GuzzleHttp\ClientInterface as GuzzleClientInterface;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\RequestOptions;
use GuzzleHttp\TransferStats;
use Psr\Http\Message\ResponseInterface;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use TreeHouse\IoBundle\Scrape\Exception\CrawlException;

class GuzzleClient implements ClientInterface, LoggerAwareInterface
{
    use LoggerAwareTrait;

    /**
     * @var GuzzleClientInterface
     */
    protected $guzzle;

    /**
     * @var string[]
     */
    protected $effectiveUrls = [];

    /**
     * @param GuzzleClientInterface $guzzle
     */
    public function __construct(GuzzleClientInterface $guzzle)
    {
        $this->guzzle = $guzzle;
    }

    /**
     * @inheritdoc
     */
    public function fetch($uri, $userAgent = null)
    {
        $this->setEffectiveUri($uri, $uri);

        try {
            $response = $this->guzzle->request('GET', $uri, $this->getRequestOptions($userAgent));

            return $this->transformResponse($uri, $response);
        } catch (RequestException $e) {
            $this->logger->error(
                sprintf('Error crawling: %s', $e->getMessage()),
                ['url' => (string) $e->getRequest()->getUri()]
            );

            if ($response = $e->getResponse()) {
                return $this->transformResponse($uri, $response);
            }

            throw new CrawlException($uri, sprintf('Error crawling url: %s', $e->getMessage()), $e->getCode(), $e);
        }
    }

    /**
     * @param string $uri
     * @param string $effectiveUri
     */
    public function setEffectiveUri($uri, $effectiveUri)
    {
        $this->effectiveUrls[$uri] = $effectiveUri;
    }

    /**
     * @param string $userAgent
     *
     * @return array
     */
    protected function getRequestOptions($userAgent = null)
    {
        $options = [
            RequestOptions::ON_STATS => function (TransferStats $stats) {
                $this->setEffectiveUri($stats->getRequest(), $stats->getEffectiveUri());

$stats->getRequest() is of type object<Psr\Http\Message\RequestInterface>, but the function expects a string.

            },
        ];

        if ($userAgent) {

The expression $userAgent of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $options[RequestOptions::HEADERS]['User-Agent'] = $userAgent;
        }

        return $options;
    }

    /**
     * @param string            $uri
     * @param ResponseInterface $response
     *
     * @return array
     */
    protected function transformResponse($uri, ResponseInterface $response)
    {
        return [
            isset($this->effectiveUrls[$uri]) ? $this->effectiveUrls[$uri] : $uri,
            $response,
        ];
    }
}