Client - Code Metrics - Inspection of "refactor" - carono/rest-client - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e76da6...3c4e89 )

by Aleksandr

created 2017-12-07 08:02 UTC

Client B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	276
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

Metric	Value
wmc	46
lcom	1
cbo	3
dl	0
loc	276
rs	8.3999
c	0
b	0
f	0

18 Methods

Rating	Name	Size	Complexity
A	__construct()	8	2
A	init()	7	2
A	getError()	11	3
A	validate()	7	2
A	filter()	10	3
A	filterParam()	4	1
A	validateParam()	4	1
A	setGuzzleOptions()	4	1
A	buildUrl()	8	4
A	getGuzzle()	4	1
A	getContent()	18	4
A	unSerializeJson()	4	1
A	unSerializeXml()	4	1
A	unSerialize()	14	4
A	addError()	4	1
A	beforePrepareData()	4	1
B	prepareData()	26	6
C	guzzleOptions()	27	8

How to fix Complexity

<?php

namespace carono\rest;

use function GuzzleHttp\Psr7\build_query;
use GuzzleHttp\Client as GuzzleClient;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\StreamInterface;

class Client
{
    public $login;
    public $password;
    public $proxy;
    public $method = 'GET';
    public $postDataInBody = false;
    public $useAuth = true;

    /**
     * @var ResponseInterface
     */
    public $request;

    const TYPE_JSON = 'json';
    const TYPE_XML = 'xml';
    const TYPE_FORM = 'form';

    protected $protocol = 'https';
    protected $url = '';
    protected $type = 'json';
    protected $output_type;
    protected $_guzzleOptions = [];
    protected $_custom_guzzle_options = [];
    protected $_guzzle;
    protected $_errors;

    /**
     * Client constructor.
     *
     * @param array $config
     */
    public function __construct(array $config = [])
    {
        $this->_guzzle = new GuzzleClient();
        foreach ($config as $prop => $value) {
            $this->$prop = $value;
        }
        $this->init();
    }

    public function init()
    {
        $this->method = strtoupper($this->method);
        if (!in_array($this->method, ['GET', 'POST'])) {
            $this->method = 'GET';
        }
    }

    /**
     * @param bool $asString
     * @return string
     */
    public function getError($asString = true)
    {
        if (!$asString) {
            return $this->_errors;
        }
        $error = ['Ошибка валидации параметров'];
        foreach ($this->_errors as $param => $errors) {
            $error[] = $param . ' - ' . join('; ', $errors);
        }
        return join("\n", $error);
    }

    public function validate(array $data)
    {
        foreach ($data as $param => $value) {
            $this->validateParam($param, $value);
class User
{
    private $email;

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

    public function setEmail($email)
    {
        $this->email = $email;
    }
}
        }
        return !count($this->_errors);
    }

    /**
     * @param array $data
     * @return array
     */
    public function filter(array $data)
    {
        $result = [];
        foreach ($data as $param => $value) {
            if (!is_null($filtered = $this->filterParam($param, $value))) {
                $result[$param] = $filtered;
            }
        }
        return $result;
    }

    /**
     * @param $param
     * @param $value
     * @return mixed
     */
    public function filterParam($param, $value)

    {
        return $value;
    }

    /**
     * @param $param
     * @param $value
     * @return bool
     */
    public function validateParam($param, $value)

    {
        return true;
    }

    public function setGuzzleOptions($array)
    {
        $this->_custom_guzzle_options = $array;
    }

    /**
     * @param $url
     * @return string
     */
    protected function buildUrl($url)
    {
        if (strpos($this->url, '://')) {
            return $this->url . ($url ? '/' . $url : '');
        } else {
            return $this->protocol . '://' . $this->url . ($url ? '/' . $url : '');
        }
    }

    /**
     * @return GuzzleClient
     */
    public function getGuzzle()
    {
        return $this->_guzzle;
    }

    /**
     * @param $urlRequest
     * @param array $data
     * @return string|\stdClass|\SimpleXMLElement
     */
    public function getContent($urlRequest, $data = [])
    {
        $options = [];
        $this->guzzleOptions();
        $url = $this->buildUrl($urlRequest);
        $client = $this->getGuzzle();
        $data = $this->prepareData($data);
        if ($this->method == 'GET') {
            $url = $url . (strpos($url, '?') ? '&' : '?') . build_query($data);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        } elseif ($this->postDataInBody) {
            $options = ['body' => $data];
        } else {
            $options = ['form_params' => $data];
        }
        $request = $client->request($this->method, $url, array_merge($options, $this->_guzzleOptions));
        $this->request = $request;
        return $this->unSerialize($request->getBody()->getContents());
    }

    /**
     * @param $data
     * @return mixed
     */
    protected function unSerializeJson($data)
    {
        return \GuzzleHttp\json_decode($data);
    }

    /**
     * @param $data
     * @return \SimpleXMLElement
     */
    protected function unSerializeXml($data)
    {
        return simplexml_load_string($data);
    }

    /**
     * @param $data
     * @return mixed|null|\SimpleXMLElement
     */
    public function unSerialize($data)
    {
        $type = $this->output_type ? $this->output_type : $this->type;

        switch ($type) {
            case self::TYPE_JSON:
                return $this->unSerializeJson($data);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case self::TYPE_XML:
                return $this->unSerializeXml($data);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
        }
        return $data;
    }

    /**
     * @param $param
     * @param $message
     */
    public function addError($param, $message)
    {
        $this->_errors[$param][] = $message;
    }

    /**
     * @param array $data
     * @return array
     */
    protected function beforePrepareData(array $data)
    {
        return $data;
    }

    /**
     * @param $data
     * @return string|array
     * @throws \Exception
     */
    protected function prepareData(array $data)
    {
        $data = $this->beforePrepareData($data);
        $data = $this->filter($data);

        if (!$this->validate($data)) {
            throw new \Exception($this->getError());
        }
        if ($this->method == 'GET') {
            return $data;
        }
        switch ($this->type) {
            case self::TYPE_JSON:
                $data = \GuzzleHttp\json_encode($data);
                break;
            case self::TYPE_XML:
                throw new \Exception('Xml type is not implemented yet');
                break;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
            case self::TYPE_FORM:
                break;
            default:
                throw new \Exception('Type is not supported');
                break;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
        }
        return $data;
    }

    /**
     * @throws \Exception
     */
    public function guzzleOptions()
    {
        $options = [
            'headers' => []
        ];
        if ($this->proxy) {
            $options['proxy'] = $this->proxy;
        }
        switch ($this->type) {
            case self::TYPE_JSON:
                $options['headers']['content-type'] = 'application/json';
                break;
            case self::TYPE_XML:
                $options['headers']['content-type'] = 'application/xml';
                break;
            case self::TYPE_FORM:
                $options['headers']['content-type'] = 'application/x-www-form-urlencoded';
                break;

            default:
                throw new \Exception('Type is not supported');
        }
        if (($this->login || $this->password) && $this->useAuth) {
            $options['auth'] = [$this->login, $this->password];
        }
        $this->_guzzleOptions = array_merge($options, $this->_custom_guzzle_options);
    }
}

1			<?php
2
3			namespace carono\rest;
4
5			use function GuzzleHttp\Psr7\build_query;
6			use GuzzleHttp\Client as GuzzleClient;
7			use Psr\Http\Message\ResponseInterface;
8			use Psr\Http\Message\StreamInterface;
9
10			class Client
11			{
12			public $login;
13			public $password;
14			public $proxy;
15			public $method = 'GET';
16			public $postDataInBody = false;
17			public $useAuth = true;
18
19			/**
20			* @var ResponseInterface
21			*/
22			public $request;
23
24			const TYPE_JSON = 'json';
25			const TYPE_XML = 'xml';
26			const TYPE_FORM = 'form';
27
28			protected $protocol = 'https';
29			protected $url = '';
30			protected $type = 'json';
31			protected $output_type;
32			protected $_guzzleOptions = [];
33			protected $_custom_guzzle_options = [];
34			protected $_guzzle;
35			protected $_errors;
36
37			/**
38			* Client constructor.
39			*
40			* @param array $config
41			*/
42			public function __construct(array $config = [])
43			{
44			$this->_guzzle = new GuzzleClient();
45			foreach ($config as $prop => $value) {
46			$this->$prop = $value;
47			}
48			$this->init();
49			}
50
51			public function init()
52			{
53			$this->method = strtoupper($this->method);
54			if (!in_array($this->method, ['GET', 'POST'])) {
55			$this->method = 'GET';
56			}
57			}
58
59			/**
60			* @param bool $asString
61			* @return string
62			*/
63			public function getError($asString = true)
64			{
65			if (!$asString) {
66			return $this->_errors;
67			}
68			$error = ['Ошибка валидации параметров'];
69			foreach ($this->_errors as $param => $errors) {
70			$error[] = $param . ' - ' . join('; ', $errors);
71			}
72			return join("\n", $error);
73			}
74
75			public function validate(array $data)
76			{
77			foreach ($data as $param => $value) {
78			$this->validateParam($param, $value);
			0 ignored issues – show Unused Code introduced 2017-04-08 07:12 UTC by Report Bug Copy Issue Report The call to the method `carono\rest\Client::validateParam()` seems un-needed as the method has no side-effects. PHP Analyzer performs a side-effects analysis of your code. A side-effect is basically anything that might be visible after the scope of the method is left. Let’s take a look at an example: class User { private $email; public function getEmail() { return $this->email; } public function setEmail($email) { $this->email = $email; } } If we look at the `getEmail()` method, we can see that it has no side-effect. Whether you call this method or not, no future calls to other methods are affected by this. As such code as the following is useless: $user = new User(); $user->getEmail(); // This line could safely be removed as it has no effect. On the hand, if we look at the `setEmail()`, this method _has_ side-effects. In the following case, we could not remove the method call: $user = new User(); $user->setEmail('email@domain'); // This line has a side-effect (it changes an // instance variable). Loading history...
79			}
80			return !count($this->_errors);
81			}
82
83			/**
84			* @param array $data
85			* @return array
86			*/
87			public function filter(array $data)
88			{
89			$result = [];
90			foreach ($data as $param => $value) {
91			if (!is_null($filtered = $this->filterParam($param, $value))) {
92			$result[$param] = $filtered;
93			}
94			}
95			return $result;
96			}
97
98			/**
99			* @param $param
100			* @param $value
101			* @return mixed
102			*/
103			public function filterParam($param, $value)
			0 ignored issues – show Unused Code introduced 2017-09-27 14:12 UTC by Report Bug Copy Issue Report The parameter `$param` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
104			{
105			return $value;
106			}
107
108			/**
109			* @param $param
110			* @param $value
111			* @return bool
112			*/
113			public function validateParam($param, $value)
			0 ignored issues – show Unused Code introduced 2017-09-27 14:12 UTC by Report Bug Copy Issue Report The parameter `$param` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2017-09-27 14:12 UTC by Report Bug Copy Issue Report The parameter `$value` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
114			{
115			return true;
116			}
117
118			public function setGuzzleOptions($array)
119			{
120			$this->_custom_guzzle_options = $array;
121			}
122
123			/**
124			* @param $url
125			* @return string
126			*/
127			protected function buildUrl($url)
128			{
129			if (strpos($this->url, '://')) {
130			return $this->url . ($url ? '/' . $url : '');
131			} else {
132			return $this->protocol . '://' . $this->url . ($url ? '/' . $url : '');
133			}
134			}
135
136			/**
137			* @return GuzzleClient
138			*/
139			public function getGuzzle()
140			{
141			return $this->_guzzle;
142			}
143
144			/**
145			* @param $urlRequest
146			* @param array $data
147			* @return string\|\stdClass\|\SimpleXMLElement
148			*/
149			public function getContent($urlRequest, $data = [])
150			{
151			$options = [];
152			$this->guzzleOptions();
153			$url = $this->buildUrl($urlRequest);
154			$client = $this->getGuzzle();
155			$data = $this->prepareData($data);
156			if ($this->method == 'GET') {
157			$url = $url . (strpos($url, '?') ? '&' : '?') . build_query($data);
			0 ignored issues – show Bug introduced 2017-04-08 07:20 UTC by Report Bug Copy Issue Report It seems like `$data` defined by `$this->prepareData($data)` on line `155` can also be of type `string`; however, `GuzzleHttp\Psr7\build_query()` does only seem to accept `array`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
158			} elseif ($this->postDataInBody) {
159			$options = ['body' => $data];
160			} else {
161			$options = ['form_params' => $data];
162			}
163			$request = $client->request($this->method, $url, array_merge($options, $this->_guzzleOptions));
164			$this->request = $request;
165			return $this->unSerialize($request->getBody()->getContents());
166			}
167
168			/**
169			* @param $data
170			* @return mixed
171			*/
172			protected function unSerializeJson($data)
173			{
174			return \GuzzleHttp\json_decode($data);
175			}
176
177			/**
178			* @param $data
179			* @return \SimpleXMLElement
180			*/
181			protected function unSerializeXml($data)
182			{
183			return simplexml_load_string($data);
184			}
185
186			/**
187			* @param $data
188			* @return mixed\|null\|\SimpleXMLElement
189			*/
190			public function unSerialize($data)
191			{
192			$type = $this->output_type ? $this->output_type : $this->type;
193
194			switch ($type) {
195			case self::TYPE_JSON:
196			return $this->unSerializeJson($data);
197			break;
			0 ignored issues – show Unused Code introduced 2017-12-07 08:04 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
198			case self::TYPE_XML:
199			return $this->unSerializeXml($data);
200			break;
			0 ignored issues – show Unused Code introduced 2017-12-07 08:04 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
201			}
202			return $data;
203			}
204
205			/**
206			* @param $param
207			* @param $message
208			*/
209			public function addError($param, $message)
210			{
211			$this->_errors[$param][] = $message;
212			}
213
214			/**
215			* @param array $data
216			* @return array
217			*/
218			protected function beforePrepareData(array $data)
219			{
220			return $data;
221			}
222
223			/**
224			* @param $data
225			* @return string\|array
226			* @throws \Exception
227			*/
228			protected function prepareData(array $data)
229			{
230			$data = $this->beforePrepareData($data);
231			$data = $this->filter($data);
232
233			if (!$this->validate($data)) {
234			throw new \Exception($this->getError());
235			}
236			if ($this->method == 'GET') {
237			return $data;
238			}
239			switch ($this->type) {
240			case self::TYPE_JSON:
241			$data = \GuzzleHttp\json_encode($data);
242			break;
243			case self::TYPE_XML:
244			throw new \Exception('Xml type is not implemented yet');
245			break;
			0 ignored issues – show Unused Code introduced 2017-04-08 07:12 UTC by Report Bug Copy Issue Report `break;` does not seem to be reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
246			case self::TYPE_FORM:
247			break;
248			default:
249			throw new \Exception('Type is not supported');
250			break;
			0 ignored issues – show Unused Code introduced 2017-04-08 07:20 UTC by Report Bug Copy Issue Report `break;` does not seem to be reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
251			}
252			return $data;
253			}
254
255			/**
256			* @throws \Exception
257			*/
258			public function guzzleOptions()
259			{
260			$options = [
261			'headers' => []
262			];
263			if ($this->proxy) {
264			$options['proxy'] = $this->proxy;
265			}
266			switch ($this->type) {
267			case self::TYPE_JSON:
268			$options['headers']['content-type'] = 'application/json';
269			break;
270			case self::TYPE_XML:
271			$options['headers']['content-type'] = 'application/xml';
272			break;
273			case self::TYPE_FORM:
274			$options['headers']['content-type'] = 'application/x-www-form-urlencoded';
275			break;
276
277			default:
278			throw new \Exception('Type is not supported');
279			}
280			if (($this->login \|\| $this->password) && $this->useAuth) {
281			$options['auth'] = [$this->login, $this->password];
282			}
283			$this->_guzzleOptions = array_merge($options, $this->_custom_guzzle_options);
284			}
285			}

carono / rest-client

Push — master ( e76da6...3c4e89 )

Client B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

18 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like