Client - Code Metrics - Inspection of "phpdoc, add beforePrepareData" - carono/rest-client - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 868567...3a1bf5 )

by Aleksandr

created 2017-10-25 06:44 UTC

Client B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	256
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

Metric	Value
wmc	43
lcom	1
cbo	3
dl	0
loc	256
rs	8.3157
c	0
b	0
f	0

16 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	unSerialize()	14	4
A	addError()	4	1
A	beforePrepareData()	4	1
B	prepareData()	26	6
C	guzzleOptions()	27	7

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;
    /**
     * @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|null|\SimpleXMLElement
     */
    public function unSerialize($data)
    {
        $type = $this->output_type ? $this->output_type : $this->type;

        switch ($type) {
            case self::TYPE_JSON:
                return \GuzzleHttp\json_decode($data);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case self::TYPE_XML:
                return simplexml_load_string($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) {
            $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			/**
18			* @var ResponseInterface
19			*/
20			public $request;
21
22			const TYPE_JSON = 'json';
23			const TYPE_XML = 'xml';
24			const TYPE_FORM = 'form';
25
26			protected $protocol = 'https';
27			protected $url = '';
28			protected $type = 'json';
29			protected $output_type;
30			protected $_guzzleOptions = [];
31			protected $_custom_guzzle_options = [];
32			protected $_guzzle;
33			protected $_errors;
34
35			/**
36			* Client constructor.
37			*
38			* @param array $config
39			*/
40			public function __construct(array $config = [])
41			{
42			$this->_guzzle = new GuzzleClient();
43			foreach ($config as $prop => $value) {
44			$this->$prop = $value;
45			}
46			$this->init();
47			}
48
49			public function init()
50			{
51			$this->method = strtoupper($this->method);
52			if (!in_array($this->method, ['GET', 'POST'])) {
53			$this->method = 'GET';
54			}
55			}
56
57			/**
58			* @param bool $asString
59			* @return string
60			*/
61			public function getError($asString = true)
62			{
63			if (!$asString) {
64			return $this->_errors;
65			}
66			$error = ['Ошибка валидации параметров'];
67			foreach ($this->_errors as $param => $errors) {
68			$error[] = $param . ' - ' . join('; ', $errors);
69			}
70			return join("\n", $error);
71			}
72
73			public function validate(array $data)
74			{
75			foreach ($data as $param => $value) {
76			$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...
77			}
78			return !count($this->_errors);
79			}
80
81			/**
82			* @param array $data
83			* @return array
84			*/
85			public function filter(array $data)
86			{
87			$result = [];
88			foreach ($data as $param => $value) {
89			if (!is_null($filtered = $this->filterParam($param, $value))) {
90			$result[$param] = $filtered;
91			}
92			}
93			return $result;
94			}
95
96			/**
97			* @param $param
98			* @param $value
99			* @return mixed
100			*/
101			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...
102			{
103			return $value;
104			}
105
106			/**
107			* @param $param
108			* @param $value
109			* @return bool
110			*/
111			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...
112			{
113			return true;
114			}
115
116			public function setGuzzleOptions($array)
117			{
118			$this->_custom_guzzle_options = $array;
119			}
120
121			/**
122			* @param $url
123			* @return string
124			*/
125			protected function buildUrl($url)
126			{
127			if (strpos($this->url, '://')) {
128			return $this->url . ($url ? '/' . $url : '');
129			} else {
130			return $this->protocol . '://' . $this->url . ($url ? '/' . $url : '');
131			}
132			}
133
134			/**
135			* @return GuzzleClient
136			*/
137			public function getGuzzle()
138			{
139			return $this->_guzzle;
140			}
141
142			/**
143			* @param $urlRequest
144			* @param array $data
145			* @return string\|\stdClass\|\SimpleXMLElement
146			*/
147			public function getContent($urlRequest, $data = [])
148			{
149			$options = [];
150			$this->guzzleOptions();
151			$url = $this->buildUrl($urlRequest);
152			$client = $this->getGuzzle();
153			$data = $this->prepareData($data);
154			if ($this->method == 'GET') {
155			$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 `153` 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...
156			} elseif ($this->postDataInBody) {
157			$options = ['body' => $data];
158			} else {
159			$options = ['form_params' => $data];
160			}
161			$request = $client->request($this->method, $url, array_merge($options, $this->_guzzleOptions));
162			$this->request = $request;
163			return $this->unSerialize($request->getBody()->getContents());
164			}
165
166			/**
167			* @param $data
168			* @return mixed\|null\|\SimpleXMLElement
169			*/
170			public function unSerialize($data)
171			{
172			$type = $this->output_type ? $this->output_type : $this->type;
173
174			switch ($type) {
175			case self::TYPE_JSON:
176			return \GuzzleHttp\json_decode($data);
177			break;
			0 ignored issues – show Unused Code introduced 2017-05-02 07:20 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...
178			case self::TYPE_XML:
179			return simplexml_load_string($data);
180			break;
			0 ignored issues – show Unused Code introduced 2017-05-02 07:20 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...
181			}
182			return $data;
183			}
184
185			/**
186			* @param $param
187			* @param $message
188			*/
189			public function addError($param, $message)
190			{
191			$this->_errors[$param][] = $message;
192			}
193
194			/**
195			* @param array $data
196			* @return array
197			*/
198			protected function beforePrepareData(array $data)
199			{
200			return $data;
201			}
202
203			/**
204			* @param $data
205			* @return string\|array
206			* @throws \Exception
207			*/
208			protected function prepareData(array $data)
209			{
210			$data = $this->beforePrepareData($data);
211			$data = $this->filter($data);
212
213			if (!$this->validate($data)) {
214			throw new \Exception($this->getError());
215			}
216			if ($this->method == 'GET') {
217			return $data;
218			}
219			switch ($this->type) {
220			case self::TYPE_JSON:
221			$data = \GuzzleHttp\json_encode($data);
222			break;
223			case self::TYPE_XML:
224			throw new \Exception('Xml type is not implemented yet');
225			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...
226			case self::TYPE_FORM:
227			break;
228			default:
229			throw new \Exception('Type is not supported');
230			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...
231			}
232			return $data;
233			}
234
235			/**
236			* @throws \Exception
237			*/
238			public function guzzleOptions()
239			{
240			$options = [
241			'headers' => []
242			];
243			if ($this->proxy) {
244			$options['proxy'] = $this->proxy;
245			}
246			switch ($this->type) {
247			case self::TYPE_JSON:
248			$options['headers']['content-type'] = 'application/json';
249			break;
250			case self::TYPE_XML:
251			$options['headers']['content-type'] = 'application/xml';
252			break;
253			case self::TYPE_FORM:
254			$options['headers']['content-type'] = 'application/x-www-form-urlencoded';
255			break;
256
257			default:
258			throw new \Exception('Type is not supported');
259			}
260			if ($this->login \|\| $this->password) {
261			$options['auth'] = [$this->login, $this->password];
262			}
263			$this->_guzzleOptions = array_merge($options, $this->_custom_guzzle_options);
264			}
265			}

carono / rest-client

Push — master ( 868567...3a1bf5 )

Client B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

16 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like