Issues in Client.php - New Issues - Inspection of "refs" - carono/rest-client - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a0c93c...320c17 )

by Aleksandr

created 2017-04-08 07:18 UTC

Client.php (2 issues)

Labels

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace carono\rest;

use function GuzzleHttp\Psr7\build_query;
use GuzzleHttp\Client as GuzzleClient;

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

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

    protected $protocol = 'https';
    protected $url = '';
    protected $type = 'json';
    protected $_guzzleOptions = [];
    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';
        }
    }

    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);
        }
        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;
    }

    /**
     * @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 : '');
        }
    }

    /**
     * @param $urlRequest
     * @param array $data
     * @return string
     */
    public function getContent($urlRequest, $data = [])
    {
        $options = [];
        $this->guzzleOptions();
        $url = $this->buildUrl($urlRequest);
        $client = $this->_guzzle;
        $data = $this->prepareData($data);
        if ($this->method == 'GET') {
            $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.
}
        } else {
            $options = [
                'body' => $data
            ];
        }
        $request = $client->request($this->method, $url, array_merge($options, $this->_guzzleOptions));
        return $this->unSerialize($request->getBody()->getContents());
    }

    /**
     * @param $data
     * @return mixed|null|\SimpleXMLElement
     */
    public function unSerialize($data)
    {
        if ($this->type == self::TYPE_JSON) {
            return \GuzzleHttp\json_decode($data);
        } elseif ($this->type == self::TYPE_XML) {
            return simplexml_load_string($data);
        }
        return null;
    }

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

    /**
     * @param $data
     * @return string|array
     * @throws \Exception
     */
    protected function prepareData(array $data)
    {
        $data = $this->filter($data);
        if (!$this->validate($data)) {
            throw new \Exception($this->getError());
        }
        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;
            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;
            default:
                throw new \Exception('Type is not supported');
        }
        if ($this->login || $this->password) {
            $options['auth'] = [$this->login, $this->password];
        }
        $this->_guzzleOptions = $options;
    }
}

1			<?php
2
3			namespace carono\rest;
4
5			use function GuzzleHttp\Psr7\build_query;
6			use GuzzleHttp\Client as GuzzleClient;
7
8			class Client
9			{
10			public $login;
11			public $password;
12			public $proxy;
13			public $method = 'GET';
14			public $postDataInBody = false;
15
16			const TYPE_JSON = 'json';
17			const TYPE_XML = 'xml';
18
19			protected $protocol = 'https';
20			protected $url = '';
21			protected $type = 'json';
22			protected $_guzzleOptions = [];
23			protected $_guzzle;
24			protected $_errors;
25
26			/**
27			* Client constructor.
28			* @param array $config
29			*/
30			public function __construct(array $config = [])
31			{
32			$this->_guzzle = new GuzzleClient();
33			foreach ($config as $prop => $value) {
34			$this->$prop = $value;
35			}
36			$this->init();
37			}
38
39			public function init()
40			{
41			$this->method = strtoupper($this->method);
42			if (!in_array($this->method, ['GET', 'POST'])) {
43			$this->method = 'GET';
44			}
45			}
46
47			public function getError($asString = true)
48			{
49			if (!$asString) {
50			return $this->_errors;
51			}
52			$error = ['Ошибка валидации параметров'];
53			foreach ($this->_errors as $param => $errors) {
54			$error[] = $param . ' - ' . join('; ', $errors);
55			}
56			return join("\n", $error);
57			}
58
59			public function validate(array $data)
60			{
61			foreach ($data as $param => $value) {
62			$this->validateParam($param, $value);
63			}
64			return !count($this->_errors);
65			}
66
67			/**
68			* @param array $data
69			* @return array
70			*/
71			public function filter(array $data)
72			{
73			$result = [];
74			foreach ($data as $param => $value) {
75			if (!is_null($filtered = $this->filterParam($param, $value))) {
76			$result[$param] = $filtered;
77			}
78			}
79			return $result;
80			}
81
82			/**
83			* @param $param
84			* @param $value
85			* @return mixed
86			*/
87			public function filterParam($param, $value)
88			{
89			return $value;
90			}
91
92			/**
93			* @param $param
94			* @param $value
95			* @return bool
96			*/
97			public function validateParam($param, $value)
98			{
99			return true;
100			}
101
102			/**
103			* @param $url
104			* @return string
105			*/
106			protected function buildUrl($url)
107			{
108			if (strpos($this->url, '://')) {
109			return $this->url . ($url ? '/' . $url : '');
110			} else {
111			return $this->protocol . '://' . $this->url . ($url ? '/' . $url : '');
112			}
113			}
114
115			/**
116			* @param $urlRequest
117			* @param array $data
118			* @return string
119			*/
120			public function getContent($urlRequest, $data = [])
121			{
122			$options = [];
123			$this->guzzleOptions();
124			$url = $this->buildUrl($urlRequest);
125			$client = $this->_guzzle;
126			$data = $this->prepareData($data);
127			if ($this->method == 'GET') {
128			$url = (strpos($url, '?') ? '&' : '?') . build_query($data);
			0 ignored issues – show Bug introduced 2017-04-08 07:20 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `$data` defined by `$this->prepareData($data)` on line `126` 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...
129			} else {
130			$options = [
131			'body' => $data
132			];
133			}
134			$request = $client->request($this->method, $url, array_merge($options, $this->_guzzleOptions));
135			return $this->unSerialize($request->getBody()->getContents());
136			}
137
138			/**
139			* @param $data
140			* @return mixed\|null\|\SimpleXMLElement
141			*/
142			public function unSerialize($data)
143			{
144			if ($this->type == self::TYPE_JSON) {
145			return \GuzzleHttp\json_decode($data);
146			} elseif ($this->type == self::TYPE_XML) {
147			return simplexml_load_string($data);
148			}
149			return null;
150			}
151
152			public function addError($param, $message)
153			{
154			$this->_errors[$param][] = $message;
155			}
156
157			/**
158			* @param $data
159			* @return string\|array
160			* @throws \Exception
161			*/
162			protected function prepareData(array $data)
163			{
164			$data = $this->filter($data);
165			if (!$this->validate($data)) {
166			throw new \Exception($this->getError());
167			}
168			switch ($this->type) {
169			case self::TYPE_JSON:
170			$data = \GuzzleHttp\json_encode($data);
171			break;
172			case self::TYPE_XML:
173			throw new \Exception('Xml type is not implemented yet');
174			break;
175			default:
176			throw new \Exception('Type is not supported');
177			break;
			0 ignored issues – show Unused Code introduced 2017-04-08 07:20 UTC by Report Bug Copy Issue Report Show Similar Issues like this `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...
178			}
179			return $data;
180			}
181
182			/**
183			* @throws \Exception
184			*/
185			public function guzzleOptions()
186			{
187			$options = [
188			'headers' => []
189			];
190			if ($this->proxy) {
191			$options['proxy'] = $this->proxy;
192			}
193			switch ($this->type) {
194			case self::TYPE_JSON:
195			$options['headers']['content-type'] = 'application/json';
196			break;
197			case self::TYPE_XML:
198			$options['headers']['content-type'] = 'application/xml';
199			break;
200			default:
201			throw new \Exception('Type is not supported');
202			}
203			if ($this->login \|\| $this->password) {
204			$options['auth'] = [$this->login, $this->password];
205			}
206			$this->_guzzleOptions = $options;
207			}
208			}

carono / rest-client

Push — master ( a0c93c...320c17 )

Client.php (2 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like