Client::get() - Code Metrics - Inspection of "fix client not found error" - syntaxerrors/Steam - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#37)

by Mahmoud

created 2016-06-30 19:24 UTC

Client::get() A

↳ Parent: Client

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	4
ccs	0
cts	2
cp	0
rs	10
cc	1
eloc	2
nc	1
nop	0
crap	2

<?php namespace Syntax\SteamApi;

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

/**
 * @method news()
 * @method player($steamId)
 * @method user($steamId)
 * @method userStats($steamId)
 * @method app()
 * @method group()
 */
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(['base_uri' => $this->url]);

        $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 = $this->client->get($steamUrl . '?' . $parameters);
        $response = $this->sendRequest($request);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

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

        // Send the request and get the results
        $request = $this->client->get($steamUrl . '?' . $parameters);
        $response = $this->sendRequest($request);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

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

    /**
     * @param \Guzzle\Http\Message\RequestInterface $request
     *
     * @throws ApiCallFailedException
     * @return stdClass
     */
    protected function sendRequest($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) {
                if (strpos($id, ':') !== false) {
                    // Convert the id to all types and grab the 64 bit version
                    $id = $this->convertToAll($id)->id64;
                }
            });
        } elseif (strpos(':', $this->steamId) !== false) {
            // Convert the id to all types and grab the 64 bit version
            $this->steamId = $this->convertToAll($this->steamId)->id64;
        }
    }
}


1		<?php namespace Syntax\SteamApi;
2
3		use Exception;
4		use Guzzle\Http\Exception\ClientErrorResponseException;
5		use Guzzle\Http\Exception\ServerErrorResponseException;
6		use GuzzleHttp\Client as GuzzleClient;
7		use stdClass;
8		use Syntax\SteamApi\Exceptions\ApiCallFailedException;
9		use Syntax\SteamApi\Exceptions\ClassNotFoundException;
10
11		/**
12		* @method news()
13		* @method player($steamId)
14		* @method user($steamId)
15		* @method userStats($steamId)
16		* @method app()
17		* @method group()
18		*/
19		class Client
20		{
21
22		use SteamId;
23
24		public $validFormats = ['json', 'xml', 'vdf'];
25
26		protected $url = 'http://api.steampowered.com/';
27
28		protected $client;
29
30		protected $interface;
31
32		protected $method;
33
34		protected $version = 'v0002';
35
36		protected $apiKey;
37
38		protected $apiFormat = 'json';
39
40		protected $steamId;
41
42		protected $isService = false;
43
44	41	public function __construct()
45		{
46	41	$apiKey = $this->getApiKey();
47
48	41	$this->client = new GuzzleClient(['base_uri' => $this->url]);
49
50	41	$this->apiKey = $apiKey;
51
52		// Set up the Ids
53	41	$this->setUpFormatted();
54	41	}
55
56		public function get()
57		{
58		return $this;
59		}
60
61	1	public function getSteamId()
62		{
63	1	return $this->steamId;
64		}
65
66		/**
67		* @param string $arguments
68		*
69		* @return string
70		*
71		* @throws ApiArgumentRequired
72		* @throws ApiCallFailedException
73		*/
74	10	protected function setUpService($arguments = null)
75		{
76		// Services have a different url syntax
77	10	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...
78		throw new ApiArgumentRequired;
79		}
80
81		$parameters = [
82	10	'key' => $this->apiKey,
83	10	'format' => $this->apiFormat,
84	10	'input_json' => $arguments,
85	10	];
86
87	10	$steamUrl = $this->buildUrl(true);
88
89		// Build the query string
90	10	$parameters = http_build_query($parameters);
91
92		// Send the request and get the results
93	10	$request = $this->client->get($steamUrl . '?' . $parameters);
94		$response = $this->sendRequest($request);
		0 ignored issues – show Documentation introduced 2016-06-30 19:32 UTC by Report Bug Copy Issue Report `$request` is of type `object<Psr\Http\Message\ResponseInterface>`, but the function expects a `object<Guzzle\Http\Message\RequestInterface>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
95
96		// Pass the results back
97		return $response->body;
98		}
99
100	17	protected function setUpClient(array $arguments = [])
101		{
102	17	$versionFlag = !is_null($this->version);
103	17	$steamUrl = $this->buildUrl($versionFlag);
104
105		$parameters = [
106	17	'key' => $this->apiKey,
107	17	'format' => $this->apiFormat
108	17	];
109
110	17	if (!empty($arguments)) {
111	16	$parameters = array_merge($arguments, $parameters);
112	16	}
113
114		// Build the query string
115	17	$parameters = http_build_query($parameters);
116
117		// Send the request and get the results
118	17	$request = $this->client->get($steamUrl . '?' . $parameters);
119	6	$response = $this->sendRequest($request);
		0 ignored issues – show Documentation introduced 2016-05-22 17:03 UTC by Report Bug Copy Issue Report `$request` is of type `object<Psr\Http\Message\ResponseInterface>`, but the function expects a `object<Guzzle\Http\Message\RequestInterface>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
120
121		// Pass the results back
122		return $response->body;
123		}
124
125	4	protected function setUpXml(array $arguments = [])
126		{
127	4	$steamUrl = $this->buildUrl();
128
129		// Build the query string
130	4	$parameters = http_build_query($arguments);
131
132		// Pass the results back
133	4	return simplexml_load_file($steamUrl . '?' . $parameters);
134		}
135
136		/**
137		* @param \Guzzle\Http\Message\RequestInterface $request
138		*
139		* @throws ApiCallFailedException
140		* @return stdClass
141		*/
142	6	protected function sendRequest($request)
143		{
144		// Try to get the result. Handle the possible exceptions that can arise
145		try {
146	6	$response = $this->client->send($request);
147
148		$result = new stdClass();
149		$result->code = $response->getStatusCode();
150		$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...
151
152	6	} catch (ClientErrorResponseException $e) {
		0 ignored issues – show Bug introduced 2015-12-23 10:46 UTC by Report Bug Copy Issue Report The class `Guzzle\Http\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...
153		throw new ApiCallFailedException($e->getMessage(), $e->getResponse()->getStatusCode(), $e);
154
155	6	} catch (ServerErrorResponseException $e) {
		0 ignored issues – show Bug introduced 2015-12-23 10:46 UTC by Report Bug Copy Issue Report The class `Guzzle\Http\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...
156		throw new ApiCallFailedException('Api call failed to complete due to a server error.',
157		$e->getResponse()->getStatusCode(), $e);
158
159	6	} catch (Exception $e) {
160	6	throw new ApiCallFailedException($e->getMessage(), $e->getCode(), $e);
161
162		}
163
164		// If all worked out, return the result
165		return $result;
166		}
167
168	30	private function buildUrl($version = false)
169		{
170		// Set up the basic url
171	30	$url = $this->url . $this->interface . '/' . $this->method . '/';
172
173		// If we have a version, add it
174	30	if ($version) {
175	25	return $url . $this->version . '/';
176		}
177
178	5	return $url;
179		}
180
181	33	public function __call($name, $arguments)
182		{
183		// Handle a steamId being passed
184	33	if (!empty($arguments) && count($arguments) == 1) {
185	27	$this->steamId = $arguments[0];
186
187	27	$this->convertSteamIdTo64();
188	27	}
189
190		// Inside the root steam directory
191	33	$class = ucfirst($name);
192	33	$steamClass = '\Syntax\SteamApi\Steam\\' . $class;
193
194	33	if (class_exists($steamClass)) {
195	28	return new $steamClass($this->steamId);
196		}
197
198		// Inside a nested directory
199	6	$class = implode('\\', preg_split('/(?=[A-Z])/', $class, -1, PREG_SPLIT_NO_EMPTY));
200	6	$steamClass = '\Syntax\SteamApi\Steam\\' . $class;
201
202	6	if (class_exists($steamClass)) {
203	6	return new $steamClass($this->steamId);
204		}
205
206		// Nothing found
207		throw new ClassNotFoundException($name);
208		}
209
210		/**
211		* @param Collection $objects
212		*
213		* @return $this
214		*/
215		protected function sortObjects($objects)
216		{
217		return $objects->sortBy(function ($object) {
218		return $object->name;
219		});
220		}
221
222		/**
223		* @param string $method
224		* @param string $version
225		*/
226	10	protected function setApiDetails($method, $version)
227		{
228	10	$this->method = $method;
229	10	$this->version = $version;
230	10	}
231
232	10	protected function getServiceResponse($arguments)
233		{
234	10	$arguments = json_encode($arguments);
235
236		// Get the client
237	10	$client = $this->setUpService($arguments)->response;
238
239		return $client;
240		}
241
242		/**
243		* @return string
244		* @throws Exceptions\InvalidApiKeyException
245		*/
246	41	protected function getApiKey()
247		{
248	41	$apiKey = \Config::get('steam-api.steamApiKey');
249
250	41	if ($apiKey == 'YOUR-API-KEY') {
251		throw new Exceptions\InvalidApiKeyException();
252		}
253	41	if (is_null($apiKey) \|\| $apiKey == '' \|\| $apiKey == []) {
254	41	$apiKey = getenv('apiKey');
255	41	}
256
257	41	return $apiKey;
258		}
259
260	27	private function convertSteamIdTo64()
261		{
262	27	if (is_array($this->steamId)) {
263	1	array_walk($this->steamId, function (&$id) {
264	1	if (strpos($id, ':') !== false) {
265		// Convert the id to all types and grab the 64 bit version
266	1	$id = $this->convertToAll($id)->id64;
267	1	}
268	1	});
269	27	} elseif (strpos(':', $this->steamId) !== false) {
270		// Convert the id to all types and grab the 64 bit version
271		$this->steamId = $this->convertToAll($this->steamId)->id64;
272		}
273	27	}
274		}
275

syntaxerrors / Steam

Pull Request — master (#37)

Client::get() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like