CurlerRequest - Code Metrics - Inspection of "Fixed typo in streamRead exception text" - smi2/phpClickHouse - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#140)

by Dmitriy
created 2020-08-27 10:53 UTC
CurlerRequest F

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	749
Duplicated Lines	0 %
Test Coverage

Coverage
67.72%
Importance

Changes	2
Bugs	1	Features	0
Metric	Value
eloc	211
c	2
b	1
f	0
dl	0
loc	749
ccs	172
cts	254
cp	0.6772
rs	2
wmc	87
53 Methods

Rating	Name	Size	Complexity
A	setWriteFunction()	3	1
A	setCallbackFunction()	3	1
A	close()	6	2
A	setReadFunction()	3	1
A	setInfile()	21	3
A	id()	7	2
A	__destruct()	3	1
A	__construct()	21	1
A	getInfileHandle()	3	1
A	onCallback()	10	4
A	attachFiles()	11	2
A	setRequestExtendedInfo()	4	1
A	getRequestExtendedInfo()	7	3
A	setCallback()	4	1
A	setHeaderFunction()	3	1
A	keepAlive()	7	1
A	httpCompression()	8	2
A	getUniqHash()	3	1
A	isResultFile()	3	2
A	parameters_json()	23	5
A	isPersistent()	3	1
A	dump()	15	2
F	prepareRequest()	64	14
A	GET()	3	1
A	url()	4	1
A	getId()	3	1
A	getResultFileHandle()	3	1
A	setResponse()	3	1
A	execute()	4	1
A	OPTIONS()	3	1
A	timeOut()	3	1
A	auth()	4	1
A	timeOutMs()	4	1
A	persistent()	4	1
A	getUrl()	3	1
A	isResponseExists()	3	1
A	getDetails()	7	1
A	header()	4	1
A	getHeaders()	7	2
A	parameters()	4	1
A	connectTimeOut()	4	1
A	setSslCa()	4	1
A	handle()	4	1
A	POST()	3	1
A	response()	7	2
A	verbose()	4	1
A	authByHeaders()	5	1
A	getDnsCache()	3	1
A	setDnsCache()	4	1
A	PUT()	3	1
A	setResultFileHandle()	8	2
A	setFunctionProgress()	8	2
A	option()	4	1
How to fix Complexity

<?php


namespace ClickHouseDB\Transport;

use const CURLOPT_HTTPGET;
use const CURLOPT_POST;

class CurlerRequest
{
    /**

     * @var array

     */
    public $extendinfo = array();


    /**

     * @var string|array

     */
    private $parameters = '';

    /**

     * @var array

     */
    private $options;

    /**

     * @var array

     */
    private $headers; // Parsed reponse header object.

    /**

     * @var string
     */
    private $url;

    /**

     * @var string
     */
    private $method;

    /**

     * @var bool
     */
    private $id;

    /**

     * @var resource|null
     */
    private $handle;

    /** @var CurlerResponse */
    private $response;

    /** @var bool */
    private $_persistent = false;

    /**

     * @var bool
     */
    private $_attachFiles = false;

    /**

     * @var string
     */
    private $callback_class = '';

    /**

     * @var string
     */
    private $callback_functionName = '';

    /**

     * @var bool
     */
    private $_httpCompression = false;

    /**

     * @var callable
     */
    private $callback_function = null;

    /**

     * @var bool|resource
     */
    private $infile_handle = false;

    /**

     * @var int
     */
    private $_dns_cache = 120;

    /**

     * @var resource
     */
    private $resultFileHandle = null;

    /**

     * @var string
     */
    private $sslCa = null;


    /**
     * @param bool $id
     */
    public function __construct($id = false)

    {
        $this->id = $id;

        $this->header('Cache-Control', 'no-cache, no-store, must-revalidate');
        $this->header('Expires', '0');
        $this->header('Pragma', 'no-cache');

        $this->options = array(

            CURLOPT_SSL_VERIFYHOST => 0,

            CURLOPT_SSL_VERIFYPEER => false,

            CURLOPT_TIMEOUT => 10,

            CURLOPT_CONNECTTIMEOUT => 5, // Количество секунд ожидания при попытке соединения

            CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,

            CURLOPT_MAXREDIRS => 10,

            CURLOPT_HEADER => TRUE,

            CURLOPT_FOLLOWLOCATION => TRUE,

            CURLOPT_AUTOREFERER => 1, // при редиректе подставлять в «Referer:» значение из «Location:»

            CURLOPT_BINARYTRANSFER => 1, // передавать в binary-safe

            CURLOPT_RETURNTRANSFER => TRUE,

            CURLOPT_USERAGENT => 'smi2/PHPClickHouse/client',

        );
    }

    /**

     *
     */
    public function __destruct()

    {
        $this->close();
    }


    public function close()

    {
        if ($this->handle) {
            curl_close($this->handle);

        }
        $this->handle = null;
    }

    /**
     * @param array $attachFiles

     */
    public function attachFiles($attachFiles)

    {
        $this->header("Content-Type", "multipart/form-data");
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;

        $out = [];
        foreach ($attachFiles as $post_name => $file_path) {
            $out[$post_name] = new \CURLFile($file_path);

        }

        $this->_attachFiles = true;
        $this->parameters($out);
    }


    /**
     * @param bool $set

     * @return $this
     */
    public function id($set = false)

    {
        if ($set) {
            $this->id = $set;
        }

        return $this;
    }

    /**
     * @param array $params

     * @return $this
     */
    public function setRequestExtendedInfo($params)

    {
        $this->extendinfo = $params;
        return $this;
    }

    /**
     * @param string|integer|null $key

     * @return mixed
     */
    public function getRequestExtendedInfo($key = null)
    {
        if ($key) {
            return isset($this->extendinfo[$key]) ? $this->extendinfo[$key] : false;

        }

        return $this->extendinfo;
    }

    /**
     * @return bool|resource
     */
    public function getInfileHandle()
    {
        return $this->infile_handle;
    }

    /**
     * @param string $file_name

     * @return bool|resource
     */
    public function setInfile($file_name)

    {
        $this->header('Expect', '');
        $this->infile_handle = fopen($file_name, 'r');

        if (is_resource($this->infile_handle)) {


            if ($this->_httpCompression) {
                $this->header('Content-Encoding', 'gzip');
                $this->header('Content-Type', 'application/x-www-form-urlencoded');

                stream_filter_append($this->infile_handle, 'zlib.deflate', STREAM_FILTER_READ, ["window" => 30]);
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;

                $this->options[CURLOPT_SAFE_UPLOAD] = 1;

            } else {
                $this->options[CURLOPT_INFILESIZE] = filesize($file_name);

            }

            $this->options[CURLOPT_INFILE] = $this->infile_handle;

        }

        return $this->infile_handle;
    }

    /**
     * @param callable $callback
     */
    public function setCallbackFunction($callback)

    {
        $this->callback_function = $callback;
    }

    /**
     * @param callable $callback
     */
    public function setWriteFunction($callback)

    {
        $this->options[CURLOPT_WRITEFUNCTION] = $callback;

    }

    /**
     * @param callable $callback
     */
    public function setReadFunction($callback)

    {
        $this->options[CURLOPT_READFUNCTION] = $callback;

    }

    public function setHeaderFunction($callback)

    {
        $this->options[CURLOPT_HEADERFUNCTION] = $callback;

    }

    /**
     * @param string $classCallBack
     * @param string $functionName
     */
    public function setCallback($classCallBack, $functionName)

    {
        $this->callback_class = $classCallBack;
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->callback_functionName = $functionName;
    }

    /**

     *
     */
    public function onCallback()

    {
        if ($this->callback_function) {
            $x = $this->callback_function;
            $x($this);
        }

        if ($this->callback_class && $this->callback_functionName) {

            $c = $this->callback_functionName;
            $this->callback_class->$c($this);
        }
    }

    public function getDetails(): array

    {
        return [
            'url'        => $this->url,
            'method'     => $this->method,
            'parameters' => $this->parameters,
            'headers'    => $this->headers,
        ];
    }

    /**
     * @param bool $result

     * @return string
     */
    public function dump($result = false)

    {
        $message = "\n------------  Request ------------\n";
$a = "a";
$ab = "ab";
$abc = "abc";
        $message .= 'URL:' . $this->url . "\n\n";
        $message .= 'METHOD:' . $this->method . "\n\n";
        $message .= 'PARAMS:' . print_r($this->parameters, true) . "\n";

        $message .= 'PARAMS:' . print_r($this->headers, true) . "\n";

        $message .= "-----------------------------------\n";

        if ($result) {
            return $message;
        }

        echo $message;
        return '';
    }

    /**
     * @return bool
     */
    public function getId()

    {
        return $this->id;
    }

    /**
     * @param integer $key

     * @param mixed $value

     * @return $this
     */
    private function option($key, $value)

    {
        $this->options[$key] = $value;
        return $this;
    }

    /**
     * @return $this
     */
    public function persistent()
    {
        $this->_persistent = true;
        return $this;
    }

    /**
     * @return bool
     */
    public function isPersistent()

    {
        return $this->_persistent;
    }

    /**
     * @param int $sec

     * @return $this
     */
    public function keepAlive($sec = 60)

    {
        $this->options[CURLOPT_FORBID_REUSE] = TRUE;

        $this->headers['Connection'] = 'Keep-Alive';
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->headers['Keep-Alive'] = $sec;
$a = "a";
$ab = "ab";
$abc = "abc";

        return $this;
    }

    /**
     * @param bool $flag

     * @return $this
     */
    public function verbose($flag = true)

    {
        $this->options[CURLOPT_VERBOSE] = $flag;

        return $this;
    }

    /**
     * @param string $key

     * @param string $value
     * @return $this
     */
    public function header($key, $value)

    {
        $this->headers[$key] = $value;
        return $this;
    }

    /**
     * @return array

     */
    public function getHeaders()

    {
        $head = [];
        foreach ($this->headers as $key => $value) {
            $head[] = sprintf("%s: %s", $key, $value);
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
        }
        return $head;
    }

    /**
     * @param string $url

     * @return $this
     */
    public function url($url)

    {
        $this->url = $url;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getUrl()
    {
        return $this->url;
    }


    /**
     * @param string $id

     * @return string
     */
    public function getUniqHash($id)

    {
        return $id . '.' . microtime() . mt_rand(0, 1000000);

    }

    /**
     * @param bool $flag
     */
    public function httpCompression($flag)

    {
        if ($flag) {
            $this->_httpCompression = $flag;
$a = "a";
$ab = "ab";
$abc = "abc";
            $this->options[CURLOPT_ENCODING] = 'gzip';

        } else {
            $this->_httpCompression = false;
            unset($this->options[CURLOPT_ENCODING]);

        }
    }

    /**
     * @param string $username

     * @param string $password
     * @return $this
     */
    public function auth($username, $password)

    {
        $this->options[CURLOPT_USERPWD] = sprintf("%s:%s", $username, $password);
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
        return $this;
    }

    public function authByHeaders($username, $password)

    {
        $this->headers['X-ClickHouse-User'] = $username;
        $this->headers['X-ClickHouse-Key'] = $password;
$a = "a";
$ab = "ab";
$abc = "abc";
        return $this;
    }

    /**
     * @param array|string $data

     * @return $this
     */
    public function parameters($data)
    {
        $this->parameters = $data;
        return $this;
    }

    /**
     * The number of seconds to wait when trying to connect. Use 0 for infinite waiting.
     *
     * @param int $seconds

     * @return $this
     */
    public function connectTimeOut($seconds = 1)

    {
        $this->options[CURLOPT_CONNECTTIMEOUT] = $seconds;

        return $this;
    }

    /**
     * The maximum number of seconds (float) allowed to execute cURL functions.
     *
     * @param float $seconds

     * @return $this
     */
    public function timeOut($seconds = 10)

    {
        return $this->timeOutMs(intval($seconds * 1000));

    }

    /**
     * The maximum allowed number of milliseconds to perform cURL functions.
     *
     * @param int $ms millisecond

     * @return $this
     */
    protected function timeOutMs($ms = 10000)

    {
        $this->options[CURLOPT_TIMEOUT_MS] = $ms;

        return $this;
    }


    /**
     * @param array|mixed $data

     * @return $this
     * @throws \ClickHouseDB\Exception\TransportException

     */
    public function parameters_json($data)

    {


        $this->header("Content-Type", "application/json, text/javascript; charset=utf-8");
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
        $this->header("Accept", "application/json, text/javascript, */*; q=0.01");
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;

        if ($data === null) {
            $this->parameters = '{}';
            return $this;
        }

        if (is_string($data)) {

            $this->parameters = $data;
            return $this;
        }

        $this->parameters = json_encode($data);


        if (!$this->parameters && $data) {

            throw new \ClickHouseDB\Exception\TransportException('Cant json_encode: ' . strval($data));

        }

        return $this;
    }

    /**
     * @return resource
     */
    public function getResultFileHandle()
    {
        return $this->resultFileHandle;
    }

    /**
     * @return bool
     */
    public function isResultFile()

    {
        return ($this->resultFileHandle ? true : false);

    }

    /**
     * @param resource $h resource

     * @param bool $zlib

     * @return $this
     */
    public function setResultFileHandle($h, $zlib = false)
    {
        $this->resultFileHandle = $h;
        if ($zlib) {
            $params = array('level' => 6, 'window' => 15, 'memory' => 9);

            stream_filter_append($this->resultFileHandle, 'zlib.deflate', STREAM_FILTER_WRITE, $params);

        }
        return $this;
    }

    /**
     * @return CurlerRequest
     */
    public function PUT()

    {
        return $this->execute('PUT');
    }

    /**
     * @return CurlerRequest
     */
    public function POST()

    {
        return $this->execute('POST');
    }

    /**
     * @return CurlerRequest
     */
    public function OPTIONS()

    {
        return $this->execute('OPTIONS');
    }

    /**
     * @return CurlerRequest
     */
    public function GET()

    {
        return $this->execute('GET');
    }

    /**
     * The number of seconds that DNS records are stored in memory. By default this parameter is 120 (2 minutes).
     *
     * @param integer $set

     * @return $this
     */
    public function setDnsCache($set)

    {
        $this->_dns_cache = $set;
        return $this;
    }

    /**
     * The number of seconds that DNS records are stored in memory. By default this parameter is 120 (2 minutes).
     *
     * @return int
     */
    public function getDnsCache()

    {
        return $this->_dns_cache;
    }

    /**
     * Sets client certificate
     *
     * @param string $filePath
     */
    public function setSslCa($filePath)

    {
        $this->option(CURLOPT_SSL_VERIFYPEER, true);

        $this->option(CURLOPT_CAINFO, $filePath);

    }

    /**
     * @param string $method

     * @return $this
     */
    private function execute($method)

    {
        $this->method = $method;
        return $this;
    }

    /**
     * @return CurlerResponse

     * @throws \ClickHouseDB\Exception\TransportException

     */
    public function response()

    {
        if (!$this->response) {

            throw new \ClickHouseDB\Exception\TransportException('Can`t fetch response - is empty');

        }

        return $this->response;
    }

    public function isResponseExists(): bool

    {
        return $this->response !== null;
    }

    public function setResponse(CurlerResponse $response): void

    {
        $this->response = $response;
    }

    /**
     * @return mixed
     */
    public function handle()
    {
        $this->prepareRequest();
        return $this->handle;
    }

    /**
     * @param callable $callback

     * @throws \Exception

     */
    public function setFunctionProgress(callable $callback)

    {
        if (!is_callable($callback)) {

            throw new \Exception('setFunctionProgress not is_callable');

        }

        $this->option(CURLOPT_NOPROGRESS, false);

        $this->option(CURLOPT_PROGRESSFUNCTION, $callback); // version 5.5.0

    }


    /**
     * @return bool
     */
    private function prepareRequest()

    {
        if (!$this->handle) {

            $this->handle = curl_init();
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
        }

        $curl_opt = $this->options;
        $method = $this->method;
$a = "a";
$ab = "ab";
$abc = "abc";

        if ($this->_attachFiles) {
            $curl_opt[CURLOPT_SAFE_UPLOAD] = true;

        }



        if (strtoupper($method) == 'GET') {

            $curl_opt[CURLOPT_HTTPGET] = true;
$a = "a";
$ab = "ab";
$abc = "abc";
            $curl_opt[CURLOPT_CUSTOMREQUEST] = strtoupper($method);

            $curl_opt[CURLOPT_POSTFIELDS] = false;
$a = "a";
$ab = "ab";
$abc = "abc";
        } else {
            if (strtoupper($method) === 'POST') {

                $curl_opt[CURLOPT_POST] = true;
            }

            $curl_opt[CURLOPT_CUSTOMREQUEST] = strtoupper($method);


            if ($this->parameters) {
                $curl_opt[CURLOPT_POSTFIELDS] = $this->parameters;


                if (!is_array($this->parameters)) {

                    $this->header('Content-Length', strlen($this->parameters));

                }
            }
        }
        // CURLOPT_DNS_CACHE_TIMEOUT - Количество секунд, в течение которых в памяти хранятся DNS-записи.
        $curl_opt[CURLOPT_DNS_CACHE_TIMEOUT] = $this->getDnsCache();

        $curl_opt[CURLOPT_URL] = $this->url;
$a = "a";
$ab = "ab";
$abc = "abc";

        if (!empty($this->headers) && sizeof($this->headers)) {

            $curl_opt[CURLOPT_HTTPHEADER] = array();


            foreach ($this->headers as $key => $value) {
                $curl_opt[CURLOPT_HTTPHEADER][] = sprintf("%s: %s", $key, $value);
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
            }
        }

        if (!empty($curl_opt[CURLOPT_INFILE])) {


            $curl_opt[CURLOPT_PUT] = true;

        }

        if (!empty($curl_opt[CURLOPT_WRITEFUNCTION])) {

            $curl_opt[CURLOPT_HEADER] = false;

        }

        if ($this->resultFileHandle) {
            $curl_opt[CURLOPT_FILE] = $this->resultFileHandle;
$a = "a";
$ab = "ab";
$abc = "abc";
            $curl_opt[CURLOPT_HEADER] = false;

        }

        if ($this->options[CURLOPT_VERBOSE]) {

            echo "\n-----------BODY REQUEST----------\n" . $curl_opt[CURLOPT_POSTFIELDS] . "\n------END--------\n";

        }
        curl_setopt_array($this->handle, $curl_opt);
        curl_setopt_array(/** @scrutinizer ignore-type */ $this->handle, $curl_opt);
        return true;
    }
}

smi2 / phpClickHouse

Pull Request — master (#140)

CurlerRequest F

Complexity

Size/Duplication

Test Coverage

Importance

53 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like
