Request - Code Metrics - Inspection of "refactor" - sinacms/MultiHttp - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( c5fc1e...fcfb9f )

by sunsky

created 2017-07-10 11:48 UTC

Request F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	401
Duplicated Lines	1.75 %

Coupling/Cohesion

Components	7
Dependencies	4

Test Coverage

Coverage

86.44%

Importance

Changes

Metric	Value
wmc	72
lcom	7
cbo	4
dl	7
loc	401
c	0
b	0
f	0
rs	2.5423
ccs	102
cts	118
cp	0.8644

38 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	create()	0	4	1
A	setLogger()	0	4	1
A	timeout()	0	5	1
A	noFollow()	0	4	1
A	follow()	0	6	1
A	endCallback()	0	4	1
A	hasEndCallback()	0	4	1
A	uri()	0	5	1
A	hasCert()	0	4	2
A	cert()	0	8	1
A	body()	0	9	1
A	mime()	0	9	3
A	addHeader()	0	5	1
A	addHeaders()	0	7	2
A	expectsType()	0	4	1
A	sendType()	0	4	1
A	expects()	0	6	2
A	getIni()	0	5	2
A	optionAlias()	0	10	4
A	addQuery()	0	13	4
A	post()	0	4	1
A	ini()	7	7	1
A	addOptions()	0	6	1
A	put()	0	4	1
A	patch()	0	4	1
A	get()	0	4	1
A	options()	0	4	1
A	head()	0	4	1
A	delete()	0	4	1
A	trace()	0	4	1
A	send()	0	11	3
A	applyOptions()	0	8	1
F	prepare()	0	59	15
A	onEnd()	0	9	2
A	filterAndRaw()	0	13	3
A	makeResponse()	0	13	3
A	log()	0	9	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Request often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Request, and based on these observations, apply Extract Interface, too.

<?php
/**
 *
 * @author  [email protected] [email protected]
 * Date: 2017/6/16
 * Time: 10:02
 * @version $Id: $
 * @since 1.0
 * @copyright Sina Corp.
 */

namespace MultiHttp;

use MultiHttp\Exception\InvalidArgumentException;

class Request extends Http
{
    const MAX_REDIRECTS_DEFAULT = 10;
    protected static $curlAlias = array(
        'url' => 'CURLOPT_URL',
        'uri' => 'CURLOPT_URL',
        'debug' => 'CURLOPT_VERBOSE',//for debug verbose
        'method' => 'CURLOPT_CUSTOMREQUEST',
        'data' => 'CURLOPT_POSTFIELDS', // array or string , file begin with '@'
        'ua' => 'CURLOPT_USERAGENT',
        'timeout' => 'CURLOPT_TIMEOUT', // (secs) 0 means indefinitely
        'connect_timeout' => 'CURLOPT_CONNECTTIMEOUT',
        'referer' => 'CURLOPT_REFERER',
        'binary' => 'CURLOPT_BINARYTRANSFER',
        'port' => 'CURLOPT_PORT',
        'header' => 'CURLOPT_HEADER', // TRUE:include header
        'headers' => 'CURLOPT_HTTPHEADER', // array
        'download' => 'CURLOPT_FILE', // writing file stream (using fopen()), default is STDOUT
        'upload' => 'CURLOPT_INFILE', // reading file stream
        'transfer' => 'CURLOPT_RETURNTRANSFER', // TRUE:return string; FALSE:output directly (curl_exec)
        'follow_location' => 'CURLOPT_FOLLOWLOCATION',
        'timeout_ms' => 'CURLOPT_TIMEOUT_MS', // milliseconds,  libcurl version > 7.36.0 ,
    );
    protected static $logger;
    public $curlHandle;
    public
        $uri,
class A {
    var $property;
}
        $timeout,
        $maxRedirects,
        $followRedirects;
    public $cert;
    public $key;
    public $passphrase;
    public $encoding;
    public $payload;
    protected $options = array(
        'CURLOPT_MAXREDIRS' => 10,
        'header' => true,
        'method' => self::GET,
        'transfer' => true,
        'follow_location' => true,
        'timeout' => 0);
    protected $endCallback;
    protected $withURIQuery;
    protected $hasInitialized = false;

    protected function __construct()
    {

    }

    public static function create()
    {
        return new self;
    }

    public static function setLogger($logger)
    {
        self::$logger = $logger;
    }

    /**
     * Specify   timeout
     * @param float|int $timeout seconds to timeout the HTTP call
     * @return Request
     */
    public function timeout($timeout)
    {
        $this->timeout = $timeout;
        return $this;
    }

    public function noFollow()
    {
        return $this->follow(0);
    }

    /**
     * If the response is a 301 or 302 redirect, automatically
     * send off another request to that location
     * @param int $follow follow or not to follow or maximal number of redirects
     * @return Request
     */
    public function follow(int $follow = self::MAX_REDIRECTS_DEFAULT)
    {
        $this->maxRedirects = abs($follow);
        $this->followRedirects = $follow > 0;
        return $this;
    }

    public function endCallback()
    {
        return $this->endCallback;
    }

    public function hasEndCallback()
    {
        return isset($this->endCallback);
    }

    public function uri($uri)
    {
        $this->uri = $uri;
        return $this;
    }

    public function hasCert()
    {
        return isset($this->cert) && isset($this->key);
    }

    /**
     * Use Client Side Cert Authentication
     * @param string $key file path to client key
     * @param string $cert file path to client cert
     * @param string $passphrase for client key
     * @param string $encoding default PEM
     * @return Request
     */
    public function cert($cert, $key, $passphrase = null, $encoding = 'PEM')
    {
        $this->cert = $cert;
        $this->key = $key;
        $this->passphrase = $passphrase;
        $this->encoding = $encoding;
        return $this;
    }

    public function body($payload, $mimeType = null)
    {
        $this->mime($mimeType);
        $this->payload = $payload;
        // Iserntentially don't call _serializePayload yet.  Wait until
        // we actually send off the request to convert payload to string.
        // At that time, the `serialized_payload` is set accordingly.
        return $this;
    }
    public function mime($mime)
    {
        if (empty($mime)) return $this;
        $this->content_type = $this->expected_type = Mime::getFullMime($mime);
class MyClass { }

$x = new MyClass();
$x->foo = true;
        if ($this->isUpload()) {

            $this->neverSerializePayload();

        }
        return $this;
    }
    public function addHeader($header_name, $value)
    {
        $this->headers[$header_name] = $value;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        return $this;
    }

    public function addHeaders(array $headers)
    {
        foreach ($headers as $header => $value) {
            $this->addHeader($header, $value);
        }
        return $this;
    }
    public function expectsType($mime)
    {
        return $this->expects($mime);
    }
    public function sendType($mime)
    {
        return $this->contentType = $mime;
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }
    public function expects($mime)
    {
        if (empty($mime)) return $this;
        $this->expected_type = Mime::getFullMime($mime);
        return $this;
    }
    /**
     * @param $field alias or field name
     * @return bool|mixed
     */
    public function getIni($field)
    {
        $alias = self::optionAlias($field);
        return isset($this->options[$alias]) ? $this->options[$alias] : false;
    }

    /**
     * @param $key
     * @return mixed
     */
    protected static function optionAlias($key)
    {
        $alias = false;
        if (isset(self::$curlAlias[$key])) {
            $alias = self::$curlAlias[$key];
        } elseif ((substr($key, 0, strlen('CURLOPT_')) == 'CURLOPT_') && defined($key)) {
            $alias = $key;
        }
        return $alias;
    }

    public function addQuery($data)
    {
        if (!empty($data)) {
            if (is_array($data)) {
                $this->withURIQuery = http_build_query($data);
            } else if (is_string($data)) {
                $this->withURIQuery = $data;
            } else {
                throw new InvalidArgumentException('data must be array or string');
            }
        }
        return $this;
    }

    public function post($uri, $payload = null, array $options = array())
    {
        return $this->ini(Http::POST, $uri, $payload, $options);
    }

    /*  no body  */

    protected function ini($method, $url,  $data , array $options = array())

    {
        $options = array('url' => $url, 'method' => $method, 'data' => $data) + $options;
        $this->addOptions($options);

        return $this;
    }

    public function addOptions(array $options = array())
    {
        $this->options = $options + $this->options;
        $this->uri = $this->options['url'];
        return $this;
    }

    function put($uri, $payload = null, array $options = array())

    {
        return $this->ini(Http::PUT, $uri, $payload, $options);
    }

    function patch($uri, $payload = null, array $options = array())

    {
        return $this->ini(Http::PATCH, $uri, $payload, $options);
    }

    public function get($uri, array $options = array())
    {
        return $this->ini(Http::GET, $uri, array(), $options);
    }

    function options($uri, array $options = array())

    {
        return $this->ini(Http::OPTIONS, $uri, array(), $options);
    }

    function head($uri, array $options = array())

    {
        return $this->ini(Http::HEAD, $uri, array('CURLOPT_NOBODY' => true), $options);
    }

    function delete($uri, array $options = array())

    {
        return $this->ini(Http::DELETE, $uri, array(), $options);
    }

    function trace($uri, array $options = array())

    {
        return $this->ini(Http::TRACE, $uri, array(), $options);
    }

    /**
     * @return Response
     */
    public function send()
    {
        if (!$this->hasInitialized)
            $this->applyOptions();
        $response = $this->makeResponse();
        if ($this->endCallback) {
            $func = $this->endCallback;
            $func($response);
        }
        return $response;
    }

    public function applyOptions()
    {
        $curl = curl_init();
        $this->curlHandle = $curl;
        $this->prepare();
        $this->hasInitialized = true;
        return $this;
    }

    protected function prepare()
    {
        if (empty($this->options['url'])) {
            throw new InvalidArgumentException('url can not empty');
        }

        if (isset($this->options['data'])) {
            $this->options['data'] = is_array($this->options['data']) ? http_build_query($this->options['data']) : $this->options['data'];//for better compatibility
        }
        if (isset($this->withURIQuery)) {
            $this->options['url'] .= strpos($this->options['url'], '?') === FALSE ? '?' : '&';
            $this->options['url'] .= $this->withURIQuery;
        }
        if (isset($this->options['callback'])) {
            $this->onEnd($this->options['callback']);
            unset($this->options['callback']);
        }
        //swap ip and host
        if (!empty($this->options['ip'])) {
            $matches = array();
            preg_match('/\/\/([^\/]+)/', $this->options['url'], $matches);
            $host = $matches[1];
            if (empty($this->options['headers']) || !is_array($this->options['headers'])) {
                $this->options['headers'] = array('Host: ' . $host);
            } else {
                $this->options['headers'][] = 'Host: ' . $host;
            }
            $this->options['url'] = preg_replace('/\/\/([^\/]+)/', '//' . $this->options['ip'], $this->options['url']);
            unset($this->options['ip']);
            unset($host);
        }
        //process version
        if (!empty($this->options['http_version'])) {
            $version = $this->options['http_version'];
            if ($version == '1.0') {
                $this->options['CURLOPT_HTTP_VERSION'] = CURLOPT_HTTP_VERSION_1_0;
            } elseif ($version == '1.1') {
                $this->options['CURLOPT_HTTP_VERSION'] = CURLOPT_HTTP_VERSION_1_1;
            }

            unset($version);
        }

        //convert secs to milliseconds
        if (defined('CURLOPT_TIMEOUT_MS')) {
            if (!isset($this->options['timeout_ms'])) {
                $this->options['timeout_ms'] = intval($this->options['timeout'] * 1000);
            } else {
                $this->options['timeout_ms'] = intval($this->options['timeout_ms']);
            }
        }


        $cURLOptions = self::filterAndRaw($this->options);

        curl_setopt_array($this->curlHandle, $cURLOptions);

        return $this;
    }

    public function onEnd(callable $callback)
    {
        if (!is_callable($callback)) {
            throw new InvalidArgumentException('callback not is callable :' . print_r($callback, 1));
        }

        $this->endCallback = $callback;
        return $this;
    }

    protected static function filterAndRaw(array &$options)
    {
        $opts = array();
        foreach ($options as $key => $val) {
            $alias = self::optionAlias($key);
            $options[$alias] = $val;
            if ($alias) {
                $opts[constant($alias)] = $val;
            }
            unset($options[$key]);
        }
        return $opts;
    }

    public function makeResponse($isMultiCurl = false)
    {
        $body = $isMultiCurl ? curl_multi_getcontent($this->curlHandle) : curl_exec($this->curlHandle);
        $info = curl_getinfo($this->curlHandle);
        $errno = curl_errno($this->curlHandle);
        $error = curl_error($this->curlHandle);
        $response = Response::create($this, $body, $info, $errno, $error);
        if (!is_null(self::$logger)) {
            self::log($response);
        }

        return $response;
    }

    private static function log(Response $response)
    {
        if ($response->hasErrors()) {
            self::$logger->error($response->request->getURI() . "\t" . $response->error, array(

                'response' => print_r($response, 1),
            ));
        }

    }
}


1			<?php
2			/**
3			*
4			* @author [email protected] [email protected]
5			* Date: 2017/6/16
6			* Time: 10:02
7			* @version $Id: $
8			* @since 1.0
9			* @copyright Sina Corp.
10			*/
11
12			namespace MultiHttp;
13
14			use MultiHttp\Exception\InvalidArgumentException;
15
16			class Request extends Http
17			{
18			const MAX_REDIRECTS_DEFAULT = 10;
19			protected static $curlAlias = array(
20			'url' => 'CURLOPT_URL',
21			'uri' => 'CURLOPT_URL',
22			'debug' => 'CURLOPT_VERBOSE',//for debug verbose
23			'method' => 'CURLOPT_CUSTOMREQUEST',
24			'data' => 'CURLOPT_POSTFIELDS', // array or string , file begin with '@'
25			'ua' => 'CURLOPT_USERAGENT',
26			'timeout' => 'CURLOPT_TIMEOUT', // (secs) 0 means indefinitely
27			'connect_timeout' => 'CURLOPT_CONNECTTIMEOUT',
28			'referer' => 'CURLOPT_REFERER',
29			'binary' => 'CURLOPT_BINARYTRANSFER',
30			'port' => 'CURLOPT_PORT',
31			'header' => 'CURLOPT_HEADER', // TRUE:include header
32			'headers' => 'CURLOPT_HTTPHEADER', // array
33			'download' => 'CURLOPT_FILE', // writing file stream (using fopen()), default is STDOUT
34			'upload' => 'CURLOPT_INFILE', // reading file stream
35			'transfer' => 'CURLOPT_RETURNTRANSFER', // TRUE:return string; FALSE:output directly (curl_exec)
36			'follow_location' => 'CURLOPT_FOLLOWLOCATION',
37			'timeout_ms' => 'CURLOPT_TIMEOUT_MS', // milliseconds, libcurl version > 7.36.0 ,
38			);
39			protected static $logger;
40			public $curlHandle;
41			public
42			$uri,
			0 ignored issues – show Coding Style introduced 2017-07-10 11:50 UTC by Report Bug Copy Issue Report It is generally advisable to only define one property per statement. Only declaring a single property per statement allows you to later on add doc comments more easily. It is also recommended by PSR2, so it is a common style that many people expect. Loading history... Coding Style introduced 2017-07-10 11:50 UTC by Report Bug Copy Issue Report The visibility should be declared for property `$uri`. The PSR-2 coding standard requires that all properties in a class have their visibility explicitly declared. If you declare a property using class A { var $property; } the property is implicitly global. To learn more about the PSR-2, please see the PHP-FIG site on the PSR-2. Loading history...
43			$timeout,
44			$maxRedirects,
45			$followRedirects;
46			public $cert;
47			public $key;
48			public $passphrase;
49	2		public $encoding;
50			public $payload;
51	2		protected $options = array(
52			'CURLOPT_MAXREDIRS' => 10,
53	2		'header' => true,
54	2		'method' => self::GET,
55			'transfer' => true,
56			'follow_location' => true,
57	1		'timeout' => 0);
58	1		protected $endCallback;
59			protected $withURIQuery;
60			protected $hasInitialized = false;
61	2
62	2		protected function __construct()
63			{
64
65	2		}
66	2
67			public static function create()
68			{
69	2		return new self;
70	2		}
71
72			public static function setLogger($logger)
73	2		{
74	2		self::$logger = $logger;
75			}
76
77			/**
78			* Specify timeout
79			* @param float\|int $timeout seconds to timeout the HTTP call
80			* @return Request
81	2		*/
82			public function timeout($timeout)
83			{
84	2		$this->timeout = $timeout;
85	2		return $this;
86			}
87
88	2		public function noFollow()
89			{
90			return $this->follow(0);
91			}
92
93			/**
94			* If the response is a 301 or 302 redirect, automatically
95	1		* send off another request to that location
96	1		* @param int $follow follow or not to follow or maximal number of redirects
97	1		* @return Request
98	1		*/
99	1		public function follow(int $follow = self::MAX_REDIRECTS_DEFAULT)
100	1		{
101			$this->maxRedirects = abs($follow);
102			$this->followRedirects = $follow > 0;
103			return $this;
104			}
105	1
106			public function endCallback()
107			{
108	1		return $this->endCallback;
109	1		}
110
111			public function hasEndCallback()
112	2		{
113	2		return isset($this->endCallback);
114	2		}
115
116	2		public function uri($uri)
117			{
118			$this->uri = $uri;
119	2		return $this;
120	2		}
121	2
122			public function hasCert()
123			{
124	2		return isset($this->cert) && isset($this->key);
125	2		}
126
127	2		/**
128	1		* Use Client Side Cert Authentication
129	1		* @param string $key file path to client key
130			* @param string $cert file path to client cert
131	2		* @param string $passphrase for client key
132	2		* @param string $encoding default PEM
133	2		* @return Request
134			*/
135			public function cert($cert, $key, $passphrase = null, $encoding = 'PEM')
136	2		{
137			$this->cert = $cert;
138			$this->key = $key;
139			$this->passphrase = $passphrase;
140			$this->encoding = $encoding;
141			return $this;
142			}
143
144			public function body($payload, $mimeType = null)
145			{
146			$this->mime($mimeType);
147			$this->payload = $payload;
148			// Iserntentially don't call _serializePayload yet. Wait until
149	1		// we actually send off the request to convert payload to string.
150	1		// At that time, the `serialized_payload` is set accordingly.
151			return $this;
152			}
153	1		public function mime($mime)
154	1		{
155			if (empty($mime)) return $this;
156			$this->content_type = $this->expected_type = Mime::getFullMime($mime);
			0 ignored issues – show Bug introduced 2017-07-10 11:50 UTC by Report Bug Copy Issue Report The property `content_type` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history... Bug introduced 2017-07-10 11:50 UTC by Report Bug Copy Issue Report The property `expected_type` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
157			if ($this->isUpload()) {
			0 ignored issues – show Bug introduced 2017-07-10 11:50 UTC by Report Bug Copy Issue Report The method `isUpload()` does not seem to exist on `object<MultiHttp\Request>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
158			$this->neverSerializePayload();
			0 ignored issues – show Bug introduced 2017-07-10 11:50 UTC by Report Bug Copy Issue Report The method `neverSerializePayload()` does not seem to exist on `object<MultiHttp\Request>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
159			}
160			return $this;
161			}
162			public function addHeader($header_name, $value)
163			{
164			$this->headers[$header_name] = $value;
			0 ignored issues – show Bug introduced 2017-07-10 11:50 UTC by Report Bug Copy Issue Report The property `headers` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
165	2		return $this;
166	2		}
167
168			public function addHeaders(array $headers)
169			{
170			foreach ($headers as $header => $value) {
171			$this->addHeader($header, $value);
172	1		}
173	1		return $this;
174	1		}
175	1		public function expectsType($mime)
176	1		{
177	1		return $this->expects($mime);
178			}
179	1		public function sendType($mime)
180			{
181			return $this->contentType = $mime;
			0 ignored issues – show Bug introduced 2017-07-10 11:50 UTC by Report Bug Copy Issue Report The property `contentType` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
182	2		}
183	2		public function expects($mime)
184	2		{
185	2		if (empty($mime)) return $this;
186	2		$this->expected_type = Mime::getFullMime($mime);
187			return $this;
188			}
189	2		/**
190			* @param $field alias or field name
191	2		* @return bool\|mixed
192	1		*/
193	1		public function getIni($field)
194	1		{
195	1		$alias = self::optionAlias($field);
196	1		return isset($this->options[$alias]) ? $this->options[$alias] : false;
197			}
198
199			/**
200	1		* @param $key
201	1		* @return mixed
202	1		*/
203			protected static function optionAlias($key)
204			{
205	2		$alias = false;
206			if (isset(self::$curlAlias[$key])) {
207			$alias = self::$curlAlias[$key];
208			} elseif ((substr($key, 0, strlen('CURLOPT_')) == 'CURLOPT_') && defined($key)) {
209			$alias = $key;
210			}
211			return $alias;
212			}
213
214			public function addQuery($data)
215	2		{
216	2		if (!empty($data)) {
217	2		if (is_array($data)) {
218			$this->withURIQuery = http_build_query($data);
219	1		} else if (is_string($data)) {
220			$this->withURIQuery = $data;
221			} else {
222			throw new InvalidArgumentException('data must be array or string');
223	2		}
224	2		}
225			return $this;
226	2		}
227
228			public function post($uri, $payload = null, array $options = array())
229	2		{
230			return $this->ini(Http::POST, $uri, $payload, $options);
231			}
232	2
233	2		/* no body */
234	2
235	2	View Code Duplication	protected function ini($method, $url, $data , array $options = array())
			0 ignored issues – show Duplication introduced 2017-07-10 11:50 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
236	2		{
237	2		$options = array('url' => $url, 'method' => $method, 'data' => $data) + $options;
238			$this->addOptions($options);
239
240	2		return $this;
241	2		}
242
243			public function addOptions(array $options = array())
244			{
245			$this->options = $options + $this->options;
246			$this->uri = $this->options['url'];
247	2		return $this;
248	2		}
249	2
250	2		function put($uri, $payload = null, array $options = array())
			0 ignored issues – show Best Practice introduced 2017-07-10 11:50 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
251	2		{
252	2		return $this->ini(Http::PUT, $uri, $payload, $options);
253			}
254	2
255			function patch($uri, $payload = null, array $options = array())
			0 ignored issues – show Best Practice introduced 2017-07-10 11:50 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
256	2		{
257	2		return $this->ini(Http::PATCH, $uri, $payload, $options);
258	2		}
259	2
260	2		public function get($uri, array $options = array())
261	2		{
262	2		return $this->ini(Http::GET, $uri, array(), $options);
263			}
264
265			function options($uri, array $options = array())
			0 ignored issues – show Best Practice introduced 2017-06-23 09:30 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
266			{
267			return $this->ini(Http::OPTIONS, $uri, array(), $options);
268			}
269
270			function head($uri, array $options = array())
			0 ignored issues – show Best Practice introduced 2017-06-23 09:30 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
271			{
272			return $this->ini(Http::HEAD, $uri, array('CURLOPT_NOBODY' => true), $options);
273			}
274
275			function delete($uri, array $options = array())
			0 ignored issues – show Best Practice introduced 2017-06-23 09:30 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
276			{
277			return $this->ini(Http::DELETE, $uri, array(), $options);
278			}
279
280			function trace($uri, array $options = array())
			0 ignored issues – show Best Practice introduced 2017-06-23 09:30 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
281			{
282			return $this->ini(Http::TRACE, $uri, array(), $options);
283			}
284
285			/**
286			* @return Response
287			*/
288			public function send()
289			{
290			if (!$this->hasInitialized)
291			$this->applyOptions();
292			$response = $this->makeResponse();
293			if ($this->endCallback) {
294			$func = $this->endCallback;
295			$func($response);
296			}
297			return $response;
298			}
299
300			public function applyOptions()
301			{
302			$curl = curl_init();
303			$this->curlHandle = $curl;
304			$this->prepare();
305			$this->hasInitialized = true;
306			return $this;
307			}
308
309			protected function prepare()
310			{
311			if (empty($this->options['url'])) {
312			throw new InvalidArgumentException('url can not empty');
313			}
314
315			if (isset($this->options['data'])) {
316			$this->options['data'] = is_array($this->options['data']) ? http_build_query($this->options['data']) : $this->options['data'];//for better compatibility
317			}
318			if (isset($this->withURIQuery)) {
319			$this->options['url'] .= strpos($this->options['url'], '?') === FALSE ? '?' : '&';
320			$this->options['url'] .= $this->withURIQuery;
321			}
322			if (isset($this->options['callback'])) {
323			$this->onEnd($this->options['callback']);
324			unset($this->options['callback']);
325			}
326			//swap ip and host
327			if (!empty($this->options['ip'])) {
328			$matches = array();
329			preg_match('/\/\/([^\/]+)/', $this->options['url'], $matches);
330			$host = $matches[1];
331			if (empty($this->options['headers']) \|\| !is_array($this->options['headers'])) {
332			$this->options['headers'] = array('Host: ' . $host);
333			} else {
334			$this->options['headers'][] = 'Host: ' . $host;
335			}
336			$this->options['url'] = preg_replace('/\/\/([^\/]+)/', '//' . $this->options['ip'], $this->options['url']);
337			unset($this->options['ip']);
338			unset($host);
339			}
340			//process version
341			if (!empty($this->options['http_version'])) {
342			$version = $this->options['http_version'];
343			if ($version == '1.0') {
344			$this->options['CURLOPT_HTTP_VERSION'] = CURLOPT_HTTP_VERSION_1_0;
345			} elseif ($version == '1.1') {
346			$this->options['CURLOPT_HTTP_VERSION'] = CURLOPT_HTTP_VERSION_1_1;
347			}
348
349			unset($version);
350			}
351
352			//convert secs to milliseconds
353			if (defined('CURLOPT_TIMEOUT_MS')) {
354			if (!isset($this->options['timeout_ms'])) {
355			$this->options['timeout_ms'] = intval($this->options['timeout'] * 1000);
356			} else {
357			$this->options['timeout_ms'] = intval($this->options['timeout_ms']);
358			}
359			}
360
361
362			$cURLOptions = self::filterAndRaw($this->options);
363
364			curl_setopt_array($this->curlHandle, $cURLOptions);
365
366			return $this;
367			}
368
369			public function onEnd(callable $callback)
370			{
371			if (!is_callable($callback)) {
372			throw new InvalidArgumentException('callback not is callable :' . print_r($callback, 1));
373			}
374
375			$this->endCallback = $callback;
376			return $this;
377			}
378
379			protected static function filterAndRaw(array &$options)
380			{
381			$opts = array();
382			foreach ($options as $key => $val) {
383			$alias = self::optionAlias($key);
384			$options[$alias] = $val;
385			if ($alias) {
386			$opts[constant($alias)] = $val;
387			}
388			unset($options[$key]);
389			}
390			return $opts;
391			}
392
393			public function makeResponse($isMultiCurl = false)
394			{
395			$body = $isMultiCurl ? curl_multi_getcontent($this->curlHandle) : curl_exec($this->curlHandle);
396			$info = curl_getinfo($this->curlHandle);
397			$errno = curl_errno($this->curlHandle);
398			$error = curl_error($this->curlHandle);
399			$response = Response::create($this, $body, $info, $errno, $error);
400			if (!is_null(self::$logger)) {
401			self::log($response);
402			}
403
404			return $response;
405			}
406
407			private static function log(Response $response)
408			{
409			if ($response->hasErrors()) {
410			self::$logger->error($response->request->getURI() . "\t" . $response->error, array(
			0 ignored issues – show Bug introduced 2017-07-10 11:50 UTC by Report Bug Copy Issue Report The method `getURI()` does not seem to exist on `object<MultiHttp\Request>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
411			'response' => print_r($response, 1),
412			));
413			}
414
415			}
416			}
417

sinacms / MultiHttp

GitHub Access Token became invalid