Soheilrt\AdobeConnectClient\Client\Connection\Curl\Connection

Complexity

Total Complexity

24

Size/Duplication

Total Lines	230
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	extractHeader()	0	23	4
A	fileInfo()	0	20	5
A	convertFileParams()	0	12	3
A	makeCurlRequest()	0	14	2
A	getFullURL()	0	5	2
A	setHost()	0	8	3
A	prepareCurl()	0	8	1
A	setConfig()	0	17	1
A	__construct()	0	4	1
A	get()	0	4	1
A	post()	0	6	1

<?php

namespace Soheilrt\AdobeConnectClient\Client\Connection\Curl;

use CURLFile;
use InvalidArgumentException;
use Soheilrt\AdobeConnectClient\Client\Connection\ConnectionInterface;
use Soheilrt\AdobeConnectClient\Client\Connection\ResponseInterface;
use SplFileInfo;
use UnexpectedValueException;

/**
 * Connection using cURL.
 */
class Connection implements ConnectionInterface
{
    /**
     * @var array Associative array of Options
     */
    protected $config = [];

    /**
     * @var string The host URL
     */
    protected $host = '';

    /**
     * @var array [string => string[]] Simplify headers generation in cURL call
     */
    protected $headers = [];

    /**
     * Create the instance using a host URL and config.
     *
     * @param string $host   The Host URL
     * @param array  $config An array to config cURL. Use CURLOPT_* as index
     *
     * @throws InvalidArgumentException if $host is not a valid URL with scheme
     */
    public function __construct($host, array $config = [])
    {
        $this->setHost($host);
        $this->setConfig($config);
    }

    /**
     * Set the Host URL.
     *
     * @param string $host The Host URL
     *
     * @throws InvalidArgumentException if $host is not a valid URL with scheme
     */
    public function setHost($host): void
    {
        $host = filter_var(trim($host, " ?/\n\t"), FILTER_SANITIZE_URL);

        if (!filter_var($host, FILTER_VALIDATE_URL)) {
            throw new InvalidArgumentException('Connection Host must be a valid URL with scheme');
        }
        $this->host = strpos($host, '/api/xml') === false ? $host . '/api/xml' : $host;
    }

    /**
     * Set the cURL config.
     *
     * @param array $config Associative array. Items as Option => Value
     */
    protected function setConfig(array $config): void
    {
        //get default configuration value and merge them with user given values in case that user
        //if any of given values are missing from below were absent it'll use default config as given below
        $defaults = [
            CURLOPT_CONNECTTIMEOUT => 120,
            CURLOPT_TIMEOUT        => 120,
            CURLOPT_MAXREDIRS      => 10,
            CURLOPT_SSL_VERIFYPEER => true,
            CURLOPT_SSL_VERIFYHOST => 2,
        ];
        $this->config = $config + $defaults;

        // Always need this configurations
        $this->config[CURLOPT_RETURNTRANSFER] = true;
        $this->config[CURLOPT_FOLLOWLOCATION] = true;
        $this->config[CURLOPT_HEADERFUNCTION] = [$this, 'extractHeader'];
    }

    /**
     * {@inheritdoc}
     */
    public function get(array $queryParams = []): ResponseInterface
    {
        $curl_resource = $this->prepareCurl($queryParams);
        return $this->makeCurlRequest($curl_resource);
    }

    /**
     * Reset the temporary headers and prepare the cURL.
     *
     * @param array $queryParams Associative array to add params in URL
     *
     * @return resource A cURL resource
     */
    protected function prepareCurl(array $queryParams = [])
    {
        $this->headers = [];

        $ch = curl_init($this->getFullURL($queryParams));
        curl_setopt_array($ch, $this->config);

It seems like $ch can also be of type false; however, parameter $ch of curl_setopt_array() does only seem to accept resource, maybe add an additional type check?

        return $ch;

The expression return $ch could also return false which is incompatible with the documented return type resource. Did you maybe forget to handle an error condition?

    }

    /**
     * Get the full URL with query parameters.
     *
     * @param array $queryParams Associative array to add params in URL
     *
     * @return string
     */
    protected function getFullURL(array $queryParams): string
    {
        return empty($queryParams)
            ? $this->host
            : $this->host . '?' . http_build_query($queryParams, '', '&');
    }

    /**
     * @param $ch
     *
     * @return \Soheilrt\AdobeConnectClient\Client\Connection\Curl\Response
     */
    protected function makeCurlRequest($ch): Response
    {
        $body = curl_exec($ch);
        $statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if ($body === false) {
            $exception = new UnexpectedValueException(curl_error($ch), curl_errno($ch));
            curl_close($ch);

            throw $exception;
        }
        curl_close($ch);

        return new Response($statusCode, $this->headers, new Stream($body));

It seems like $body can also be of type true; however, parameter $content of Soheilrt\AdobeConnectClient\Client\Connection\Curl\Stream::__construct() does only seem to accept string, maybe add an additional type check?

    }

    /**
     * {@inheritdoc}
     */
    public function post(array $postParams, array $queryParams = []): ResponseInterface
    {
        $ch = $this->prepareCurl($queryParams);
        curl_setopt($ch, CURLOPT_POST, 1);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $this->convertFileParams($postParams));
        return $this->makeCurlRequest($ch);
    }

    /**
     * Convert stream file and SplFileInfo in CURLFile.
     *
     * @param array $params Associative array of parameters
     *
     * @return array
     */
    protected function convertFileParams(array $params): array
    {
        foreach ($params as $param => $value) {
            $fileInfo = $this->fileInfo($value);

            if (empty($fileInfo)) {
                continue;
            }
            $params[$param] = new CURLFile($fileInfo['path'], $fileInfo['mime']);
        }

        return $params;
    }

    /**
     * Get the filepath and mime-type from a file.
     *
     * If it's a stream file or \SplFileInfo returns an object with path and mime.
     *
     * @param resource|SplFileInfo $item A stream file or SplFileInfo object
     *
     * @return array|null Returns null if it's not a valid stream file or SplFileInfo
     */
    protected function fileInfo($item): ?array
    {
        if (is_resource($item)) {
            $streamMeta = stream_get_meta_data($item);

            if ($streamMeta['wrapper_type'] !== 'plainfile') {
                return null;
            }
            $path = $streamMeta['uri'];
            $mime = mime_content_type($path);
        } elseif ($item instanceof SplFileInfo and $item->getType() === 'file') {
            $path = $item->getPathname();
            $mime = mime_content_type($path);
        } else {
            return null;
        }

        return [
            'path' => $path,
            'mime' => $mime,
        ];
    }

    /**
     * Extract header line and store it to posterior use.
     *
     * This method is called by option CURLOPT_HEADERFUNCTION.
     *
     * @param resource $curlResource
     * @param string   $headerLine
     *
     * @return int The size of header line
     */
    protected function extractHeader($curlResource, $headerLine): int
    {
        $headerSize = strlen($headerLine);
        $headerLine = trim($headerLine, " \t\n");

        if (empty($headerLine)) {
            return $headerSize;
        }

        $pos = strpos($headerLine, ':');

        if ($pos === false) {
            return $headerSize;
        }

        $header = trim(substr($headerLine, 0, $pos));

        if (!in_array($header, ['Set-Cookie', 'Content-Type'])) {
            return $headerSize;
        }
        $this->headers[$header] = [trim(substr($headerLine, $pos + 1))];

        return $headerSize;
    }
}