Stevenmaguire\Yelp\Tool\HttpTrait

Complexity

Total Complexity

19

Size/Duplication

Total Lines	168
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	appendParametersToUrl()	0	14	3
A	getHttpClient()	0	4	1
A	getRequest()	0	21	3
A	getResponse()	0	10	2
C	prepareQueryParams()	0	25	8
A	processRequest()	0	6	1
A	setHttpClient()	0	6	1

<?php

namespace Stevenmaguire\Yelp\Tool;

use \Exception;
use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\Exception\BadResponseException;
use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Uri;
use Psr\Http\Message\RequestInterface;
use Stevenmaguire\Yelp\Exception\ClientConfigurationException;
use Stevenmaguire\Yelp\Exception\HttpException;

trait HttpTrait
{
    /**
     * API host url
     *
     * @var string
     */
    protected $apiHost;

    /**
     * HTTP client
     *
     * @var GuzzleHttp\Client
     */
    protected $httpClient;

    /**
     * Prepares and appends parameters, if provided, to the given url.
     *
     * @param  string  $url
     * @param  array   $parameters
     * @param  array   $options
     *
     * @return string
     */
    protected function appendParametersToUrl($url, array $parameters = array(), array $options = array())
    {
        $url = rtrim($url, '?');
        $queryString = $this->prepareQueryParams($parameters, $options);

        if ($queryString) {

The expression $queryString 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.

            $uri = new Uri($url);
            $existingQuery = $uri->getQuery();
            $updatedQuery = empty($existingQuery) ? $queryString : $existingQuery . '&' . $queryString;
            $url = (string) $uri->withQuery($updatedQuery);
        }

        return $url;
    }

    /**
     * Returns the yelp client's http client to the given http client. Client.
     *
     * @return  GuzzleHttp\Client|null
     */
    public function getHttpClient()
    {
        return $this->httpClient;
    }

    /**
     * Creates a PSR-7 Request instance.
     *
     * @param  null|string $method HTTP method for the request.
     * @param  null|string $uri URI for the request.
     * @param  array $headers Headers for the message.
     * @param  string|resource|StreamInterface $body Message body.
     * @param  string $version HTTP protocol version.
     *
     * @return GuzzleHttp\Psr7\Request
     */
    public function getRequest(
        $method,
        $uri,
        array $headers = [],
        $body = null,
        $version = '1.1'
    ) {
        $uriComponents = parse_url($uri);

        if (!isset($uriComponents['host'])) {
            $uriComponents['host'] = $this->apiHost;
        }

        if (!isset($uriComponents['scheme'])) {
            $uriComponents['scheme'] = 'https';
        }

        $uri = (string) Uri::fromParts($uriComponents);

It seems like $uriComponents defined by parse_url($uri) on line 82 can also be of type false; however, GuzzleHttp\Psr7\Uri::fromParts() does only seem to accept array, did you maybe forget to handle an error condition?

        return new Request($method, $uri, $headers, $body, $version);
    }

    /**
     * Sends a request instance and returns a response instance.
     *
     * WARNING: This method does not attempt to catch exceptions caused by HTTP
     * errors! It is recommended to wrap this method in a try/catch block.
     *
     * @param  RequestInterface $request
     * @return ResponseInterface
     * @throws Stevenmaguire\Yelp\Exception\HttpException
     */
    public function getResponse(RequestInterface $request)
    {
        try {
            return $this->getHttpClient()->send($request);
        } catch (BadResponseException $e) {
            $exception = new HttpException($e->getMessage());

            throw $exception->setResponseBody($e->getResponse()->getBody());
        }
    }

    /**
     * Updates query params array to apply yelp specific formatting rules.
     *
     * @param  array   $params
     * @param  array   $options
     *
     * @return string|null
     */
    protected function prepareQueryParams($params = [], $options = [])
    {
        array_walk($params, function ($value, $key) use (&$params, $options) {
            if (is_bool($value)) {
                $params[$key] = $value ? 'true' : 'false';
            }
            if (isset($options['to_csv'])) {
                if (!is_array($options['to_csv'])) {
                     $options['to_csv'] = explode(',', $options['to_csv']);
                }

                if (in_array($key, $options['to_csv']) && is_array($value)) {
                    $params[$key] = implode(',', $value);
                }
            }
        });

        $queryString = http_build_query($params);

        if (strlen($queryString)) {
            return $queryString;
        }

        return null;
    }

    /**
     * Makes a request to the Yelp API and returns the response
     *
     * @param    string $path    The path of the APi after the domain

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

     *
     * @return   stdClass The JSON response from the request
     * @throws   Stevenmaguire\Yelp\Exception\ClientConfigurationException
     * @throws   Stevenmaguire\Yelp\Exception\HttpException
     */
    protected function processRequest(RequestInterface $request)
    {
        $response = $this->getResponse($request);

        return json_decode($response->getBody());
    }

    /**
     * Updates the yelp client's http client to the given http client. Client.
     *
     * @param GuzzleHttp\Client  $client
     *
     * @return  mixed
     */
    public function setHttpClient(HttpClient $client)
    {
        $this->httpClient = $client;

It seems like $client of type object<GuzzleHttp\Client> is incompatible with the declared type object<Stevenmaguire\Yelp\Tool\GuzzleHttp\Client> of property $httpClient.

        return $this;
    }
}