Client::__call() - Code Metrics - Inspection of "Fix it_gets_the_user_stats tests breaking" - syntaxerrors/Steam - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0a2d54...99fa2d )

unknown

created 2019-10-10 04:44 UTC

Client::__call() A

↳ Parent: Client

Complexity

Conditions	5
Paths	6

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	5.0113

Importance

Changes

Metric	Value
dl	0
loc	28
ccs	12
cts	13
cp	0.9231
rs	9.1608
c	0
b	0
f	0
cc	5
nc	6
nop	2
crap	5.0113

<?php

namespace Syntax\SteamApi;

use stdClass;
use GuzzleHttp\Client as GuzzleClient;
use GuzzleHttp\Psr7\Request;
use Exception;
use GuzzleHttp\Exception\ClientErrorResponseException;
use GuzzleHttp\Exception\ServerErrorResponseException;
use Syntax\SteamApi\Exceptions\ApiCallFailedException;
use Syntax\SteamApi\Exceptions\ClassNotFoundException;

/**
 * @method \Syntax\SteamApi\Steam\News       news()
 * @method \Syntax\SteamApi\Steam\Player     player($steamId)
 * @method \Syntax\SteamApi\Steam\User       user($steamId)
 * @method \Syntax\SteamApi\Steam\User\Stats userStats($steamId)
 * @method \Syntax\SteamApi\Steam\App        app()
 * @method \Syntax\Steamapi\Steam\Package    package()
 * @method \Syntax\SteamApi\Steam\Group      group()
 * @method \Syntax\SteamApi\Steam\Item       item($appId)
 */
class Client
{
    use SteamId;

    public $validFormats = ['json', 'xml', 'vdf'];

    protected $url = 'http://api.steampowered.com/';

    protected $client;

    protected $interface;

    protected $method;

    protected $version = 'v0002';

    protected $apiKey;

    protected $apiFormat = 'json';

    protected $steamId;

    protected $isService = false;

    public function __construct()
    {
        $apiKey = $this->getApiKey();

        $this->client = new GuzzleClient();
        $this->apiKey = $apiKey;

        // Set up the Ids
        $this->setUpFormatted();
    }

    public function get()
    {
        return $this;
    }

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

    /**
     * @param string $arguments
     *
     * @return string
     *
     * @throws ApiArgumentRequired
     * @throws ApiCallFailedException
     */
    protected function setUpService($arguments = null)
    {
        // Services have a different url syntax
        if ($arguments == null) {

            throw new ApiArgumentRequired;
        }

        $parameters = [
            'key'        => $this->apiKey,
            'format'     => $this->apiFormat,
            'input_json' => $arguments,
        ];

        $steamUrl = $this->buildUrl(true);

        // Build the query string
        $parameters = http_build_query($parameters);

        // Send the request and get the results
        $request  = new Request('GET', $steamUrl . '?' . $parameters);
        $response = $this->sendRequest($request);

        // Pass the results back
        return $response->body;
    }

    protected function setUpClient(array $arguments = [])
    {
        $versionFlag = ! is_null($this->version);
        $steamUrl    = $this->buildUrl($versionFlag);

        $parameters = [
            'key'    => $this->apiKey,
            'format' => $this->apiFormat,
        ];

        if (! empty($arguments)) {
            $parameters = array_merge($arguments, $parameters);
        }

        // Build the query string
        $parameters = http_build_query($parameters);

        $headers = [];
        if (array_key_exists('l', $arguments)) {
            $headers = [
                'Accept-Language' => $arguments['l'],
            ];
        }

        // Send the request and get the results
        $request  = new Request('GET', $steamUrl . '?' . $parameters, $headers);
        $response = $this->sendRequest($request);

        // Pass the results back
        return $response->body;
    }

    protected function setUpXml(array $arguments = [])
    {
        $steamUrl = $this->buildUrl();

        // Build the query string
        $parameters = http_build_query($arguments);

        // Pass the results back
        return simplexml_load_file($steamUrl . '?' . $parameters);
        libxml_use_internal_errors(true);
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
        $result = simplexml_load_file($steamUrl . '?' . $parameters);

        if (! $result) {
            return null;
        }

        return $result;
    }

    public function getRedirectUrl()
    {
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $this->url);
        curl_setopt($ch, CURLOPT_HEADER, true);
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        curl_exec($ch);
        $this->url = curl_getinfo($ch, CURLINFO_EFFECTIVE_URL);
        curl_close($ch);
    }

    /**
     * @param \GuzzleHttp\Psr7\Request $request
     *
     * @return \stdClass
     * @throws \Syntax\SteamApi\Exceptions\ApiCallFailedException
     */
    protected function sendRequest(Request $request)
    {
        // Try to get the result.  Handle the possible exceptions that can arise
        try {
            $response = $this->client->send($request);

            $result       = new stdClass();
            $result->code = $response->getStatusCode();
            $result->body = json_decode($response->getBody(true));

        } catch (ClientErrorResponseException $e) {

            throw new ApiCallFailedException($e->getMessage(), $e->getResponse()->getStatusCode(), $e);
        } catch (ServerErrorResponseException $e) {

            throw new ApiCallFailedException('Api call failed to complete due to a server error.', $e->getResponse()->getStatusCode(), $e);
        } catch (Exception $e) {
            throw new ApiCallFailedException($e->getMessage(), $e->getCode(), $e);
        }

        // If all worked out, return the result
        return $result;
    }

    private function buildUrl($version = false)
    {
        // Set up the basic url
        $url = $this->url . $this->interface . '/' . $this->method . '/';

        // If we have a version, add it
        if ($version) {
            return $url . $this->version . '/';
        }

        return $url;
    }

    public function __call($name, $arguments)
    {
        // Handle a steamId being passed
        if (! empty($arguments) && count($arguments) == 1) {
            $this->steamId = $arguments[0];

            $this->convertSteamIdTo64();
        }

        // Inside the root steam directory
        $class      = ucfirst($name);
        $steamClass = '\Syntax\SteamApi\Steam\\' . $class;

        if (class_exists($steamClass)) {
            return new $steamClass($this->steamId);
        }

        // Inside a nested directory
        $class      = implode('\\', preg_split('/(?=[A-Z])/', $class, -1, PREG_SPLIT_NO_EMPTY));
        $steamClass = '\Syntax\SteamApi\Steam\\' . $class;

        if (class_exists($steamClass)) {
            return new $steamClass($this->steamId);
        }

        // Nothing found
        throw new ClassNotFoundException($name);
    }

    /**
     * @param Collection $objects
     *
     * @return $this
     */
    protected function sortObjects($objects)
    {
        return $objects->sortBy(function ($object) {
            return $object->name;
        });
    }

    /**
     * @param string $method
     * @param string $version
     */
    protected function setApiDetails($method, $version)
    {
        $this->method  = $method;
        $this->version = $version;
    }

    protected function getServiceResponse($arguments)
    {
        $arguments = json_encode($arguments);

        // Get the client
        $client = $this->setUpService($arguments)->response;

        return $client;
    }

    /**
     * @return string
     * @throws Exceptions\InvalidApiKeyException
     */
    protected function getApiKey()
    {
        $apiKey = \Config::get('steam-api.steamApiKey');

        if ($apiKey == 'YOUR-API-KEY') {
            throw new Exceptions\InvalidApiKeyException();
        }
        if (is_null($apiKey) || $apiKey == '' || $apiKey == []) {
            $apiKey = getenv('apiKey');
        }

        return $apiKey;
    }

    private function convertSteamIdTo64()
    {
        if (is_array($this->steamId)) {
            array_walk($this->steamId, function (&$id) {
                // Convert the id to all types and grab the 64 bit version
                $id = $this->convertToAll($id)->id64;
            });
        } else {
            // Convert the id to all types and grab the 64 bit version
            $this->steamId = $this->convertToAll($this->steamId)->id64;
        }
    }
}


1		<?php
2
3		namespace Syntax\SteamApi;
4
5		use stdClass;
6		use GuzzleHttp\Client as GuzzleClient;
7		use GuzzleHttp\Psr7\Request;
8		use Exception;
9		use GuzzleHttp\Exception\ClientErrorResponseException;
10		use GuzzleHttp\Exception\ServerErrorResponseException;
11		use Syntax\SteamApi\Exceptions\ApiCallFailedException;
12		use Syntax\SteamApi\Exceptions\ClassNotFoundException;
13
14		/**
15		* @method \Syntax\SteamApi\Steam\News news()
16		* @method \Syntax\SteamApi\Steam\Player player($steamId)
17		* @method \Syntax\SteamApi\Steam\User user($steamId)
18		* @method \Syntax\SteamApi\Steam\User\Stats userStats($steamId)
19		* @method \Syntax\SteamApi\Steam\App app()
20		* @method \Syntax\Steamapi\Steam\Package package()
21		* @method \Syntax\SteamApi\Steam\Group group()
22		* @method \Syntax\SteamApi\Steam\Item item($appId)
23		*/
24		class Client
25		{
26		use SteamId;
27
28		public $validFormats = ['json', 'xml', 'vdf'];
29
30		protected $url = 'http://api.steampowered.com/';
31
32		protected $client;
33
34		protected $interface;
35
36		protected $method;
37
38		protected $version = 'v0002';
39
40		protected $apiKey;
41
42		protected $apiFormat = 'json';
43
44		protected $steamId;
45
46		protected $isService = false;
47
48	37	public function __construct()
49		{
50	37	$apiKey = $this->getApiKey();
51
52	37	$this->client = new GuzzleClient();
53	37	$this->apiKey = $apiKey;
54
55		// Set up the Ids
56	37	$this->setUpFormatted();
57	37	}
58
59		public function get()
60		{
61		return $this;
62		}
63
64	1	public function getSteamId()
65		{
66	1	return $this->steamId;
67		}
68
69		/**
70		* @param string $arguments
71		*
72		* @return string
73		*
74		* @throws ApiArgumentRequired
75		* @throws ApiCallFailedException
76		*/
77	3	protected function setUpService($arguments = null)
78		{
79		// Services have a different url syntax
80	3	if ($arguments == null) {
		0 ignored issues – show Bug introduced 2015-12-23 10:46 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing `$arguments` of type `string\|null` against `null`; this is ambiguous if the string can be empty. Consider using a strict comparison `===` instead. Loading history...
81		throw new ApiArgumentRequired;
82		}
83
84		$parameters = [
85	3	'key' => $this->apiKey,
86	3	'format' => $this->apiFormat,
87	3	'input_json' => $arguments,
88		];
89
90	3	$steamUrl = $this->buildUrl(true);
91
92		// Build the query string
93	3	$parameters = http_build_query($parameters);
94
95		// Send the request and get the results
96	3	$request = new Request('GET', $steamUrl . '?' . $parameters);
97	3	$response = $this->sendRequest($request);
98
99		// Pass the results back
100	3	return $response->body;
101		}
102
103	15	protected function setUpClient(array $arguments = [])
104		{
105	15	$versionFlag = ! is_null($this->version);
106	15	$steamUrl = $this->buildUrl($versionFlag);
107
108		$parameters = [
109	15	'key' => $this->apiKey,
110	15	'format' => $this->apiFormat,
111		];
112
113	15	if (! empty($arguments)) {
114	14	$parameters = array_merge($arguments, $parameters);
115		}
116
117		// Build the query string
118	15	$parameters = http_build_query($parameters);
119
120	15	$headers = [];
121	15	if (array_key_exists('l', $arguments)) {
122		$headers = [
123	6	'Accept-Language' => $arguments['l'],
124		];
125		}
126
127		// Send the request and get the results
128	15	$request = new Request('GET', $steamUrl . '?' . $parameters, $headers);
129	15	$response = $this->sendRequest($request);
130
131		// Pass the results back
132	13	return $response->body;
133		}
134
135	4	protected function setUpXml(array $arguments = [])
136		{
137	4	$steamUrl = $this->buildUrl();
138
139		// Build the query string
140	4	$parameters = http_build_query($arguments);
141
142		// Pass the results back
143	4	return simplexml_load_file($steamUrl . '?' . $parameters);
144		libxml_use_internal_errors(true);
		0 ignored issues – show Unused Code introduced 2017-02-03 15:51 UTC by Report Bug Copy Issue Report `libxml_use_internal_errors(true);` 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...
145		$result = simplexml_load_file($steamUrl . '?' . $parameters);
146
147		if (! $result) {
148		return null;
149		}
150
151		return $result;
152		}
153
154	1	public function getRedirectUrl()
155		{
156	1	$ch = curl_init();
157	1	curl_setopt($ch, CURLOPT_URL, $this->url);
158	1	curl_setopt($ch, CURLOPT_HEADER, true);
159	1	curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
160	1	curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
161
162	1	curl_exec($ch);
163	1	$this->url = curl_getinfo($ch, CURLINFO_EFFECTIVE_URL);
164	1	curl_close($ch);
165	1	}
166
167		/**
168		* @param \GuzzleHttp\Psr7\Request $request
169		*
170		* @return \stdClass
171		* @throws \Syntax\SteamApi\Exceptions\ApiCallFailedException
172		*/
173	18	protected function sendRequest(Request $request)
174		{
175		// Try to get the result. Handle the possible exceptions that can arise
176		try {
177	18	$response = $this->client->send($request);
178
179	16	$result = new stdClass();
180	16	$result->code = $response->getStatusCode();
181	16	$result->body = json_decode($response->getBody(true));
		0 ignored issues – show Unused Code introduced 2016-05-22 17:03 UTC by Report Bug Copy Issue Report The call to `ResponseInterface::getBody()` has too many arguments starting with `true`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
182	2	} catch (ClientErrorResponseException $e) {
		0 ignored issues – show Bug introduced 2016-05-22 17:03 UTC by Report Bug Copy Issue Report The class `GuzzleHttp\Exception\ClientErrorResponseException` does not exist. Did you forget a USE statement, or did you not list all dependencies? Scrutinizer analyzes your `composer.json`/`composer.lock` file if available to determine the classes, and functions that are defined by your dependencies. It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis. Loading history...
183		throw new ApiCallFailedException($e->getMessage(), $e->getResponse()->getStatusCode(), $e);
184	2	} catch (ServerErrorResponseException $e) {
		0 ignored issues – show Bug introduced 2016-05-22 17:03 UTC by Report Bug Copy Issue Report The class `GuzzleHttp\Exception\ServerErrorResponseException` does not exist. Did you forget a USE statement, or did you not list all dependencies? Scrutinizer analyzes your `composer.json`/`composer.lock` file if available to determine the classes, and functions that are defined by your dependencies. It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis. Loading history...
185		throw new ApiCallFailedException('Api call failed to complete due to a server error.', $e->getResponse()->getStatusCode(), $e);
186	2	} catch (Exception $e) {
187	2	throw new ApiCallFailedException($e->getMessage(), $e->getCode(), $e);
188		}
189
190		// If all worked out, return the result
191	16	return $result;
192		}
193
194	22	private function buildUrl($version = false)
195		{
196		// Set up the basic url
197	22	$url = $this->url . $this->interface . '/' . $this->method . '/';
198
199		// If we have a version, add it
200	22	if ($version) {
201	16	return $url . $this->version . '/';
202		}
203
204	6	return $url;
205		}
206
207	25	public function __call($name, $arguments)
208		{
209		// Handle a steamId being passed
210	25	if (! empty($arguments) && count($arguments) == 1) {
211	18	$this->steamId = $arguments[0];
212
213	18	$this->convertSteamIdTo64();
214		}
215
216		// Inside the root steam directory
217	25	$class = ucfirst($name);
218	25	$steamClass = '\Syntax\SteamApi\Steam\\' . $class;
219
220	25	if (class_exists($steamClass)) {
221	19	return new $steamClass($this->steamId);
222		}
223
224		// Inside a nested directory
225	6	$class = implode('\\', preg_split('/(?=[A-Z])/', $class, -1, PREG_SPLIT_NO_EMPTY));
226	6	$steamClass = '\Syntax\SteamApi\Steam\\' . $class;
227
228	6	if (class_exists($steamClass)) {
229	6	return new $steamClass($this->steamId);
230		}
231
232		// Nothing found
233		throw new ClassNotFoundException($name);
234		}
235
236		/**
237		* @param Collection $objects
238		*
239		* @return $this
240		*/
241	3	protected function sortObjects($objects)
242		{
243		return $objects->sortBy(function ($object) {
244	3	return $object->name;
245	3	});
246		}
247
248		/**
249		* @param string $method
250		* @param string $version
251		*/
252	3	protected function setApiDetails($method, $version)
253		{
254	3	$this->method = $method;
255	3	$this->version = $version;
256	3	}
257
258	3	protected function getServiceResponse($arguments)
259		{
260	3	$arguments = json_encode($arguments);
261
262		// Get the client
263	3	$client = $this->setUpService($arguments)->response;
264
265	3	return $client;
266		}
267
268		/**
269		* @return string
270		* @throws Exceptions\InvalidApiKeyException
271		*/
272	37	protected function getApiKey()
273		{
274	37	$apiKey = \Config::get('steam-api.steamApiKey');
275
276	37	if ($apiKey == 'YOUR-API-KEY') {
277		throw new Exceptions\InvalidApiKeyException();
278		}
279	37	if (is_null($apiKey) \|\| $apiKey == '' \|\| $apiKey == []) {
280	37	$apiKey = getenv('apiKey');
281		}
282
283	37	return $apiKey;
284		}
285
286	18	private function convertSteamIdTo64()
287		{
288	18	if (is_array($this->steamId)) {
289		array_walk($this->steamId, function (&$id) {
290		// Convert the id to all types and grab the 64 bit version
291	1	$id = $this->convertToAll($id)->id64;
292	1	});
293		} else {
294		// Convert the id to all types and grab the 64 bit version
295	17	$this->steamId = $this->convertToAll($this->steamId)->id64;
296		}
297	18	}
298		}
299

syntaxerrors / Steam

Push — master ( 0a2d54...99fa2d )

Client::__call() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like