Artstorm\MonkeyLearn\HttpClient\HttpClient

Complexity

Total Complexity

17

Size/Duplication

Total Lines	183
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

80.7%

Importance

Changes	11
Bugs	1	Features	5

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	addConfigOption()	0	4	1
A	post()	0	4	1
A	request()	0	7	1
A	createRequest()	0	10	2
A	send()	0	18	2
A	headerCallback()	0	10	2
A	getRequestHeaders()	0	8	2
B	buildUri()	0	22	5

<?php

namespace Artstorm\MonkeyLearn\HttpClient;

class HttpClient implements HttpClientInterface
{
    /**
     * Client config.
     *
     * @var array
     */
    protected $config;

    /**
     * Headers returned in the response.
     *
     * @var array
     */
    protected $responseHeaders = [];

    /**
     * Assign dependencies.
     *
     * @param array $config
     */
    public function __construct(array $config = [])
    {
        $this->config = $config;
    }

    /**
     * Adds an option to config options array
     *
     * @param  string $option
     *
     * @return void
     */
    public function addConfigOption($option)
    {
        $this->config['options'][] = $option;
    }

    /**
     * Make a POST request.
     *
     * @param  string $path
     * @param  mixed  $body
     * @param  array  $headers
     *
     * @return Request
     */
    public function post($path, $body = null, array $headers = [])
    {
        return $this->request($path, $body, 'POST', $headers);
    }

    /**
     * Send request with HTTP client.
     *
     * @param  string $path
     * @param  mixed  $body
     * @param  string $method
     * @param  array  $headers
     *
     * @return Response
     */
    protected function request($path, $body = null, $method = 'GET', array $headers = [])
    {
        $request = $this->createRequest($method, $path, $body, $headers);
        $response = $this->send($request);

        return $response;
    }

    /**
     * Create request with HTTP client.
     *
     * @param  string $method
     * @param  string $path
     * @param  mixed  $body
     * @param  array  $headers
     *
     * @return Request
     */
    protected function createRequest($method, $path, $body = null, array $headers = [])
    {
        $defaultHeaders = isset($this->config['headers']) ? $this->config['headers'] : [];
        return new Request(
            $method,
            $path,
            array_merge($defaultHeaders, $headers),
            $body
        );
    }

    /**
     * Send the request.
     *
     * @param  Request $request
     *
     * @return Response
     */
    public function send(Request $request)
    {
        $client = new CurlClient;
        $client->setOption(CURLOPT_URL, $this->buildUri($request->getPath()));
        $client->setOption(CURLOPT_RETURNTRANSFER, true);
        $client->setOption(CURLOPT_HTTPHEADER, $this->getRequestHeaders($request));
        $client->setOption(CURLOPT_POST, true);
        $client->setOption(CURLOPT_POSTFIELDS, $request->getBody());
        $client->setOption(CURLOPT_HEADERFUNCTION, [&$this, 'headerCallback']);

        if (!$result = $client->execute()) {
            $result = 'cURL Error: '.$client->error();
        }

        $client->close();

        return new Response(200, $this->responseHeaders, $result);
    }

    /**
     * Callback to store response headers.
     *
     * @param  resource $curl
     * @param  string   $header
     *
     * @return int
     */
    public function headerCallback($curl, $header)
    {
        $pair = explode(': ', $header);
        // We're only interested in the headers that forms a pair
        if (count($pair) == 2) {
            $this->responseHeaders[reset($pair)] = end($pair);
        }

        return strlen($header);
    }

    /**
     * Prepare the request headers to be sent.
     *
     * @param  Request $request
     * @param  array   $headers
     *
     * @return array
     */
    protected function getRequestHeaders(Request $request, array $headers = [])
    {
        foreach ($request->getHeaders() as $key => $value) {
            array_push($headers, sprintf('%s: %s', $key, $value));
        }

        return $headers;
    }

    /**
     * Build uri with possible base uri.
     *
     * @param  string $uri
     *
     * @return string
     */
    private function buildUri($uri)
    {
        // Prepare any existing options
        if (array_key_exists('options', $this->config)) {
            $options = [];
            foreach ($this->config['options'] as $option) {
                $options[$option] = '1';
            }
        }

        // Add any existing options as a query string
        if (isset($options)) {
            $query = http_build_query($options);
            $uri = $uri.'?'.$query;
        }

        if (isset($this->config['base_uri'])) {
            return $this->config['base_uri'].$uri;
        }

        return $uri;
    }
}