AbstractProvider::addJobItemToCollection() - Code Metrics - Inspection of "Fixing bug in abstract provider" - jobapis/jobs-common - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1f4e1a...e35bf8 )

by Karl

created 2017-01-21 23:16 UTC

AbstractProvider::addJobItemToCollection() A

↳ Parent: AbstractProvider

Complexity

Conditions	2
Paths	2

Size

Total Lines	13
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	2

Importance

Changes

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

<?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($className) - 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;
    }

    /**
     * Adds a single job item to a collection (passed by reference)
     *
     * @param $collection Collection
     * @param $item array
     *
     * @return $collection

     */
    protected function addJobItemToCollection(&$collection, $item = []) {
        if ($item) {

            $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);
        }
        return $collection;
    }

    /**
     * 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) {
            $this->addJobItemToCollection($collection, $item);
        }, $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($className) - 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		* Adds a single job item to a collection (passed by reference)
195		*
196		* @param $collection Collection
197		* @param $item array
198		*
199		* @return $collection
		0 ignored issues – show Documentation introduced 2017-01-21 23:21 UTC by Report Bug Copy Issue Report The doc-type `$collection` could not be parsed: Unknown type name "$collection" at position 0. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
200		*/
201	4	protected function addJobItemToCollection(&$collection, $item = []) {
202	4	if ($item) {
		0 ignored issues – show Bug Best Practice introduced 2017-01-21 23:21 UTC by Report Bug Copy Issue Report The expression `$item` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
203	4	$item = static::parseAttributeDefaults(
204	4	$item,
205	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...
206	4	);
207	4	$job = $this->createJobObject($item);
208	4	$job->setQuery($this->query->getKeyword())
209	4	->setSource($this->getSource());
210	4	$collection->add($job);
211	4	}
212	4	return $collection;
213		}
214
215		/**
216		* Create and get collection of jobs from given listings
217		*
218		* @param array $listings
219		*
220		* @return Collection
221		*/
222	4	protected function getJobsCollectionFromListings(array $listings = [])
223		{
224	4	$collection = new Collection;
225
226	4	array_map(function ($item) use ($collection) {
227	4	$this->addJobItemToCollection($collection, $item);
228	4	}, $listings);
229
230	4	return $collection;
231		}
232
233		/**
234		* Get raw listings from payload
235		*
236		* @param array $payload
237		*
238		* @return array
239		*/
240	4	protected function getRawListings(array $payload = array())
241		{
242	4	$path = $this->getListingsPath();
243
244	4	if (!empty($path)) {
245	4	$index = explode('.', $path);
246
247	4	$listings = self::getValue($index, $payload);
248
249		// Listings should be returned as an array of arrays
250	4	if (reset($listings) && is_array(reset($listings))) {
251	2	return $listings;
252		}
253	2	return [0 => $listings];
254		}
255
256		return (array) $payload;
257		}
258
259		/**
260		* Navigate through a payload array looking for a particular index
261		*
262		* @param array $index The index sequence we are navigating down
263		* @param array $value The portion of the config array to process
264		*
265		* @return mixed
266		*/
267	4	protected static function getValue($index, $value)
268		{
269	4	$current_index = self::getValueCurrentIndex($index);
270
271	4	if (isset($value[$current_index])) {
272	4	$index_array = self::isArrayNotEmpty($index);
273	4	$value_array = self::isArrayNotEmpty($value[$current_index]);
274
275	4	if ($index_array && $value_array) {
276		return self::getValue($index, $value[$current_index]);
277		} else {
278	4	return $value[$current_index];
279		}
280		} else {
281		throw new \OutOfRangeException("Attempt to access missing variable: $current_index");
282		}
283		}
284
285		/**
286		* Attempt to parse string as given format
287		*
288		* @param string $string
289		* @param string $format
290		*
291		* @return array
292		*/
293	4	protected function parseAsFormat($string, $format)
294		{
295	4	$method = 'parseAs'.ucfirst(strtolower($format));
296
297	4	if (method_exists($this, $method)) {
298	4	return $this->$method($string);
299		}
300
301		return [];
302		}
303
304		/**
305		* Get value current index
306		*
307		* @param mixed $index
308		*
309		* @return array\|null
310		*/
311	4	private static function getValueCurrentIndex(&$index)
312		{
313	4	return is_array($index) && count($index) ? array_shift($index) : null;
314		}
315
316		/**
317		* Checks if given value is an array and that it has contents
318		*
319		* @param mixed $array
320		*
321		* @return boolean
322		*/
323	4	private static function isArrayNotEmpty($array)
324		{
325	4	return is_array($array) && count($array);
326		}
327
328		/**
329		* Attempt to parse as Json
330		*
331		* @param string $string
332		*
333		* @return array
334		*/
335	4	private function parseAsJson($string)
336		{
337		try {
338	4	$json = json_decode($string, true);
339
340	4	if (json_last_error() != JSON_ERROR_NONE) {
341		throw new \Exception;
342		}
343
344	4	return $json;
345		} catch (\Exception $e) {
346		// Ignore malformed json.
347		}
348
349		return [];
350		}
351
352		/**
353		* Attempt to parse as XML
354		*
355		* @param string $string
356		*
357		* @return array
358		*/
359		private function parseAsXml($string)
360		{
361		try {
362		return json_decode(
363		json_encode(
364		simplexml_load_string(
365		$string,
366		null,
367		LIBXML_NOCDATA
368		)
369		),
370		true
371		);
372		} catch (\Exception $e) {
373		// Ignore malformed xml.
374		}
375
376		return [];
377		}
378
379		/**
380		* Determine whether a string ends with another string
381		*
382		* @param $string
383		* @param $test
384		*
385		* @return bool
386		*/
387	6	private function stringEndsWith($string, $test)
388		{
389	6	$stringLen = strlen($string);
390	6	$testLen = strlen($test);
391	6	if ($testLen > $stringLen) {
392		return false;
393		}
394	6	return substr_compare($string, $test, $stringLen - $testLen, $testLen) === 0;
395		}
396		}
397

jobapis / jobs-common

Push — master ( 1f4e1a...e35bf8 )

AbstractProvider::addJobItemToCollection() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like