AbstractProvider::parseAsFormat() - Code Metrics - Inspection of "Collection upgrade, updating getSource method" - jobapis/jobs-common - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#28)

by Karl

created 2016-12-01 13:28 UTC

AbstractProvider::parseAsFormat() A

↳ Parent: AbstractProvider

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2.032

Importance

Changes

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

<?php namespace JobApis\Jobs\Client\Providers;

use GuzzleHttp\Client as HttpClient;
use JobApis\Jobs\Client\Collection;
use JobApis\Jobs\Client\Exceptions\MissingParameterException;
use JobApis\Jobs\Client\Queries\AbstractQuery;

abstract class AbstractProvider
{
    /**
     * HTTP Client
     *
     * @var HttpClient
     */
    protected $client;

    /**
     * Query params
     *
     * @var AbstractQuery
     */
    protected $query;

    /**
     * Create new client
     *
     * @param array $parameters
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     */
    public function __construct(AbstractQuery $query)
    {
        $this->setQuery($query)
            ->setClient(new HttpClient);
    }

    /**
     * Returns the standardized job object
     *
     * @param array|object $payload
     *
     * @return \JobApis\Jobs\Client\Job
     */
    abstract public function createJobObject($payload);

    /**
     * Job response object default keys that should be set
     *
     * @return  string
     */
    abstract public function getDefaultResponseFields();

    /**
     * Get listings path
     *
     * @return  string
     */
    abstract public function getListingsPath();

    /**
     * Uses the Query to make a call to the client
     *
     * @return \Psr\Http\Message\ResponseInterface
     */
    public function getClientResponse()
    {
        // Create a local copy of the client object
        $client = $this->client;

        // GET or POST request
        $verb = strtolower($this->query->getVerb());

        // The URL string
        $url = $this->query->getUrl();

        // HTTP method options
        $options = $this->query->getHttpMethodOptions();

        // Get the response
        return $client->{$verb}($url, $options);
    }

    /**
     * Get format
     *
     * @return  string Currently only 'json' and 'xml' supported
     */
    public function getFormat()
    {
        return 'json';
    }

    /**
     * Makes the api call and returns a collection of job objects
     *
     * @return  \JobApis\Jobs\Client\Collection
     * @throws MissingParameterException
     */
    public function getJobs()
    {
        // Verify that all required query vars are set
        if ($this->query->isValid()) {
            // Get the response from the client using the query
            $response = $this->getClientResponse();
            // Get the response body as a string
            $body = (string) $response->getBody();
            // Parse the string
            $payload = $this->parseAsFormat($body, $this->getFormat());
            // Gets listings if they're nested
            $listings = is_array($payload) ? $this->getRawListings($payload) : [];
            // Return a job collection
            return $this->getJobsCollectionFromListings($listings);
        } else {
            throw new MissingParameterException("All Required parameters for this provider must be set");
        }
    }

    /**
     * Get source attribution
     *
     * @return string
     */
    public function getSource()
    {
        $classSuffix = "Provider";

        $className = (new \ReflectionClass(get_class($this)))->getShortName();

        // Strip off the suffix from the provider
        if ($this->stringEndsWith($className, $classSuffix)) {
            $className = substr($className, 0, strlen($classSuffix));
        }

        return $className;
    }

    /**
     * Parse job attributes against defaults
     *
     * @param  array $attributes
     * @param  array $defaults
     *
     * @return array
     */
    public static function parseAttributeDefaults(array $attributes, array $defaults = array())
    {
        array_map(function ($attribute) use (&$attributes) {
            if (!isset($attributes[$attribute])) {
                $attributes[$attribute] = null;
            }
        }, $defaults);
        return $attributes;
    }

    /**
     * Parse location string into components.
     *
     * @param string $location
     *
     * @return  array
     **/
    public static function parseLocation($location, $separator = ', ')
    {
        return explode($separator, $location);
    }

    /**
     * Sets http client
     *
     * @param HttpClient $client
     *
     * @return  AbstractProvider
     */
    public function setClient(HttpClient $client)
    {
        $this->client = $client;

        return $this;
    }

    /**
     * Sets query object
     *
     * @param AbstractQuery $query
     *
     * @return  AbstractProvider
     */
    public function setQuery(AbstractQuery $query)
    {
        $this->query = $query;

        return $this;
    }

    /**
     * Create and get collection of jobs from given listings
     *
     * @param  array $listings
     *
     * @return Collection
     */
    protected function getJobsCollectionFromListings(array $listings = [])
    {
        $collection = new Collection;

        array_map(function ($item) use ($collection) {
            $item = static::parseAttributeDefaults(
                $item,
                $this->getDefaultResponseFields()
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            );
            $job = $this->createJobObject($item);
            $job->setQuery($this->query->getKeyword())
                ->setSource($this->getSource());
            $collection->add($job);
        }, $listings);

        return $collection;
    }

    /**
     * Get raw listings from payload
     *
     * @param  array $payload
     *
     * @return array
     */
    protected function getRawListings(array $payload = array())
    {
        $path = $this->getListingsPath();

        if (!empty($path)) {
            $index = explode('.', $path);

            $listings = self::getValue($index, $payload);

            // Listings should be returned as an array of arrays
            if (reset($listings) && is_array(reset($listings))) {
                return $listings;
            }
            return [0 => $listings];
        }

        return (array) $payload;
    }

    /**
     * Navigate through a payload array looking for a particular index
     *
     * @param array $index The index sequence we are navigating down
     * @param array $value The portion of the config array to process
     *
     * @return mixed
     */
    protected static function getValue($index, $value)
    {
        $current_index = self::getValueCurrentIndex($index);

        if (isset($value[$current_index])) {
            $index_array = self::isArrayNotEmpty($index);
            $value_array = self::isArrayNotEmpty($value[$current_index]);

            if ($index_array && $value_array) {
                return self::getValue($index, $value[$current_index]);
            } else {
                return $value[$current_index];
            }
        } else {
            throw new \OutOfRangeException("Attempt to access missing variable: $current_index");
        }
    }

    /**
     * Attempt to parse string as given format
     *
     * @param  string  $string
     * @param  string  $format
     *
     * @return array
     */
    protected function parseAsFormat($string, $format)
    {
        $method = 'parseAs'.ucfirst(strtolower($format));

        if (method_exists($this, $method)) {
            return $this->$method($string);
        }

        return [];
    }

    /**
     * Get value current index
     *
     * @param  mixed $index
     *
     * @return array|null
     */
    private static function getValueCurrentIndex(&$index)
    {
        return is_array($index) && count($index) ? array_shift($index) : null;
    }

    /**
     * Checks if given value is an array and that it has contents
     *
     * @param  mixed $array
     *
     * @return boolean
     */
    private static function isArrayNotEmpty($array)
    {
        return is_array($array) && count($array);
    }

    /**
     * Attempt to parse as Json
     *
     * @param  string $string
     *
     * @return array
     */
    private function parseAsJson($string)
    {
        try {
            $json = json_decode($string, true);

            if (json_last_error() != JSON_ERROR_NONE) {
                throw new \Exception;
            }

            return $json;
        } catch (\Exception $e) {
            // Ignore malformed json.
        }

        return [];
    }

    /**
     * Attempt to parse as XML
     *
     * @param  string $string
     *
     * @return array
     */
    private function parseAsXml($string)
    {
        try {
            return json_decode(
                json_encode(
                    simplexml_load_string(
                        $string,
                        null,
                        LIBXML_NOCDATA
                    )
                ),
                true
            );
        } catch (\Exception $e) {
            // Ignore malformed xml.
        }

        return [];
    }

    /**
     * Determine whether a string ends with another string
     *
     * @param $string
     * @param $test
     *
     * @return bool
     */
    private function stringEndsWith($string, $test)
    {
        $stringLen = strlen($string);
        $testLen = strlen($test);
        if ($testLen > $stringLen) {
            return false;
        }
        return substr_compare($string, $test, $stringLen - $testLen, $testLen) === 0;
    }
}


1		<?php namespace JobApis\Jobs\Client\Providers;
2
3		use GuzzleHttp\Client as HttpClient;
4		use JobApis\Jobs\Client\Collection;
5		use JobApis\Jobs\Client\Exceptions\MissingParameterException;
6		use JobApis\Jobs\Client\Queries\AbstractQuery;
7
8		abstract class AbstractProvider
9		{
10		/**
11		* HTTP Client
12		*
13		* @var HttpClient
14		*/
15		protected $client;
16
17		/**
18		* Query params
19		*
20		* @var AbstractQuery
21		*/
22		protected $query;
23
24		/**
25		* Create new client
26		*
27		* @param array $parameters
		0 ignored issues – show Bug introduced 2016-09-03 15:03 UTC by Report Bug Copy Issue Report There is no parameter named `$parameters`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
28		*/
29	16	public function __construct(AbstractQuery $query)
30		{
31	16	$this->setQuery($query)
32	16	->setClient(new HttpClient);
33	16	}
34
35		/**
36		* Returns the standardized job object
37		*
38		* @param array\|object $payload
39		*
40		* @return \JobApis\Jobs\Client\Job
41		*/
42		abstract public function createJobObject($payload);
43
44		/**
45		* Job response object default keys that should be set
46		*
47		* @return string
48		*/
49		abstract public function getDefaultResponseFields();
50
51		/**
52		* Get listings path
53		*
54		* @return string
55		*/
56		abstract public function getListingsPath();
57
58		/**
59		* Uses the Query to make a call to the client
60		*
61		* @return \Psr\Http\Message\ResponseInterface
62		*/
63	6	public function getClientResponse()
64		{
65		// Create a local copy of the client object
66	6	$client = $this->client;
67
68		// GET or POST request
69	6	$verb = strtolower($this->query->getVerb());
70
71		// The URL string
72	6	$url = $this->query->getUrl();
73
74		// HTTP method options
75	6	$options = $this->query->getHttpMethodOptions();
76
77		// Get the response
78	6	return $client->{$verb}($url, $options);
79		}
80
81		/**
82		* Get format
83		*
84		* @return string Currently only 'json' and 'xml' supported
85		*/
86	6	public function getFormat()
87		{
88	6	return 'json';
89		}
90
91		/**
92		* Makes the api call and returns a collection of job objects
93		*
94		* @return \JobApis\Jobs\Client\Collection
95		* @throws MissingParameterException
96		*/
97	6	public function getJobs()
98		{
99		// Verify that all required query vars are set
100	6	if ($this->query->isValid()) {
101		// Get the response from the client using the query
102	4	$response = $this->getClientResponse();
103		// Get the response body as a string
104	4	$body = (string) $response->getBody();
105		// Parse the string
106	4	$payload = $this->parseAsFormat($body, $this->getFormat());
107		// Gets listings if they're nested
108	4	$listings = is_array($payload) ? $this->getRawListings($payload) : [];
109		// Return a job collection
110	4	return $this->getJobsCollectionFromListings($listings);
111		} else {
112	2	throw new MissingParameterException("All Required parameters for this provider must be set");
113		}
114		}
115
116		/**
117		* Get source attribution
118		*
119		* @return string
120		*/
121	6	public function getSource()
122		{
123	6	$classSuffix = "Provider";
124
125	6	$className = (new \ReflectionClass(get_class($this)))->getShortName();
126
127		// Strip off the suffix from the provider
128	6	if ($this->stringEndsWith($className, $classSuffix)) {
129	6	$className = substr($className, 0, strlen($classSuffix));
130	6	}
131
132	6	return $className;
133		}
134
135		/**
136		* Parse job attributes against defaults
137		*
138		* @param array $attributes
139		* @param array $defaults
140		*
141		* @return array
142		*/
143	6	public static function parseAttributeDefaults(array $attributes, array $defaults = array())
144		{
145		array_map(function ($attribute) use (&$attributes) {
146	6	if (!isset($attributes[$attribute])) {
147	6	$attributes[$attribute] = null;
148	6	}
149	6	}, $defaults);
150	6	return $attributes;
151		}
152
153		/**
154		* Parse location string into components.
155		*
156		* @param string $location
157		*
158		* @return array
159		**/
160	2	public static function parseLocation($location, $separator = ', ')
161		{
162	2	return explode($separator, $location);
163		}
164
165		/**
166		* Sets http client
167		*
168		* @param HttpClient $client
169		*
170		* @return AbstractProvider
171		*/
172	16	public function setClient(HttpClient $client)
173		{
174	16	$this->client = $client;
175
176	16	return $this;
177		}
178
179		/**
180		* Sets query object
181		*
182		* @param AbstractQuery $query
183		*
184		* @return AbstractProvider
185		*/
186	16	public function setQuery(AbstractQuery $query)
187		{
188	16	$this->query = $query;
189
190	16	return $this;
191		}
192
193		/**
194		* Create and get collection of jobs from given listings
195		*
196		* @param array $listings
197		*
198		* @return Collection
199		*/
200	4	protected function getJobsCollectionFromListings(array $listings = [])
201		{
202	4	$collection = new Collection;
203
204	4	array_map(function ($item) use ($collection) {
205	4	$item = static::parseAttributeDefaults(
206	4	$item,
207	4	$this->getDefaultResponseFields()
		0 ignored issues – show Documentation introduced 2016-09-03 15:03 UTC by Report Bug Copy Issue Report `$this->getDefaultResponseFields()` is of type `string`, but the function expects a `array`. 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...
208	4	);
209	4	$job = $this->createJobObject($item);
210	4	$job->setQuery($this->query->getKeyword())
211	4	->setSource($this->getSource());
212	4	$collection->add($job);
213	4	}, $listings);
214
215	4	return $collection;
216		}
217
218		/**
219		* Get raw listings from payload
220		*
221		* @param array $payload
222		*
223		* @return array
224		*/
225	4	protected function getRawListings(array $payload = array())
226		{
227	4	$path = $this->getListingsPath();
228
229	4	if (!empty($path)) {
230	4	$index = explode('.', $path);
231
232	4	$listings = self::getValue($index, $payload);
233
234		// Listings should be returned as an array of arrays
235	4	if (reset($listings) && is_array(reset($listings))) {
236	2	return $listings;
237		}
238	2	return [0 => $listings];
239		}
240
241		return (array) $payload;
242		}
243
244		/**
245		* Navigate through a payload array looking for a particular index
246		*
247		* @param array $index The index sequence we are navigating down
248		* @param array $value The portion of the config array to process
249		*
250		* @return mixed
251		*/
252	4	protected static function getValue($index, $value)
253		{
254	4	$current_index = self::getValueCurrentIndex($index);
255
256	4	if (isset($value[$current_index])) {
257	4	$index_array = self::isArrayNotEmpty($index);
258	4	$value_array = self::isArrayNotEmpty($value[$current_index]);
259
260	4	if ($index_array && $value_array) {
261		return self::getValue($index, $value[$current_index]);
262		} else {
263	4	return $value[$current_index];
264		}
265		} else {
266		throw new \OutOfRangeException("Attempt to access missing variable: $current_index");
267		}
268		}
269
270		/**
271		* Attempt to parse string as given format
272		*
273		* @param string $string
274		* @param string $format
275		*
276		* @return array
277		*/
278	4	protected function parseAsFormat($string, $format)
279		{
280	4	$method = 'parseAs'.ucfirst(strtolower($format));
281
282	4	if (method_exists($this, $method)) {
283	4	return $this->$method($string);
284		}
285
286		return [];
287		}
288
289		/**
290		* Get value current index
291		*
292		* @param mixed $index
293		*
294		* @return array\|null
295		*/
296	4	private static function getValueCurrentIndex(&$index)
297		{
298	4	return is_array($index) && count($index) ? array_shift($index) : null;
299		}
300
301		/**
302		* Checks if given value is an array and that it has contents
303		*
304		* @param mixed $array
305		*
306		* @return boolean
307		*/
308	4	private static function isArrayNotEmpty($array)
309		{
310	4	return is_array($array) && count($array);
311		}
312
313		/**
314		* Attempt to parse as Json
315		*
316		* @param string $string
317		*
318		* @return array
319		*/
320	4	private function parseAsJson($string)
321		{
322		try {
323	4	$json = json_decode($string, true);
324
325	4	if (json_last_error() != JSON_ERROR_NONE) {
326		throw new \Exception;
327		}
328
329	4	return $json;
330		} catch (\Exception $e) {
331		// Ignore malformed json.
332		}
333
334		return [];
335		}
336
337		/**
338		* Attempt to parse as XML
339		*
340		* @param string $string
341		*
342		* @return array
343		*/
344		private function parseAsXml($string)
345		{
346		try {
347		return json_decode(
348		json_encode(
349		simplexml_load_string(
350		$string,
351		null,
352		LIBXML_NOCDATA
353		)
354		),
355		true
356		);
357		} catch (\Exception $e) {
358		// Ignore malformed xml.
359		}
360
361		return [];
362		}
363
364		/**
365		* Determine whether a string ends with another string
366		*
367		* @param $string
368		* @param $test
369		*
370		* @return bool
371		*/
372	6	private function stringEndsWith($string, $test)
373		{
374	6	$stringLen = strlen($string);
375	6	$testLen = strlen($test);
376	6	if ($testLen > $stringLen) {
377		return false;
378		}
379	6	return substr_compare($string, $test, $stringLen - $testLen, $testLen) === 0;
380		}
381		}
382

jobapis / jobs-common

Pull Request — master (#28)

AbstractProvider::parseAsFormat() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like