Collection::get() - Code Metrics - dirkgroenen/pinterest-api-php - Measure and Improve Code Quality continuously with Scrutinizer

Collection::get() A
last analyzed 2020-01-27 08:00 UTC

↳ Parent: Collection

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

<?php
/**
 * Copyright 2015 Dirk Groenen
 *
 * (c) Dirk Groenen <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace DirkGroenen\Pinterest\Models;

use DirkGroenen\Pinterest\Exceptions\PinterestException;

use \DirkGroenen\Pinterest\Pinterest;
use \DirkGroenen\Pinterest\Transport\Response;

class Collection implements \JsonSerializable, \ArrayAccess, \IteratorAggregate{

    /**
     * The items in the collection
     *
     * @var array
     */
    private $items = [];

    /**
     * The model of each collection item
     *
     * @var string
     */
    private $model;

    /**
     * Stores the pagination object
     *
     * @var array|boolean
     */
    public $pagination;

    /**
     * Instance of Pinterest master class
     *
     * @var Pinterest
     */
    private $master;

    /**
     * Response instance
     *
     * @var Response
     */
    private $response;

    /**
     * Construct
     *
     * @access public
     * @param  Pinterest            $master
     * @param  array|Response       $items
     * @param  string               $model
     * @throws InvalidModelException
     */
    public function __construct(Pinterest $master, $items, $model) {
        $this->master = $master;

        // Create class path
        $this->model = ucfirst(strtolower($model));

        if (!class_exists("\\DirkGroenen\\Pinterest\\Models\\" . $this->model)) {
            throw new InvalidModelException;
        }

        // Get items and response instance
        if (is_array($items)) {
            $this->response = null;
            $this->items = $items;
        } else if ($items instanceof \DirkGroenen\Pinterest\Transport\Response) {
            $this->response = $items;
            $this->items = $items->data;
        } else {
            throw new PinterestException("$items needs to be an instance of Transport\Response or an array.");
        }

        // Transform the raw collection data to models
        $this->items = $this->buildCollectionModels($this->items);

        // Add pagination object
        if (isset($this->response->page) && !empty($this->response->page['next'])) {
            $this->pagination = $this->response->page;
        } else {
            $this->pagination = false;
        }
    }

    /**
     * Get all items from the collection
     *
     * @access public
     * @return array
     */
    public function all()
    {
        return $this->items;
    }

    /**
     * Transform each raw item into a model
     *
     * @access private
     * @param array $items
     * @return array
     */
    private function buildCollectionModels(array $items)
    {
        $modelcollection = [];

        foreach ($items as $item) {
            $class = new \ReflectionClass("\\DirkGroenen\\Pinterest\\Models\\" . $this->model);
            $modelcollection[] = $class->newInstanceArgs([$this->master, $item]);
        }

        return $modelcollection;
    }

    /**
     * Check if their is a next page available
     *
     * @access public
     * @return boolean
     */
    public function hasNextPage()
    {
        return ($this->response != null && isset($this->response->page['next']));
    }

    /**
     * Return the item at the given index
     *
     * @access public
     * @param  int $index
     * @return Model
     */
    public function get($index)
    {
        return $this->items[$index];
    }

    /**
     * Convert the collection to an array
     *
     * @access public
     * @return array
     */
    public function toArray()
    {
        $items = [];

        foreach ($this->items as $item) {
            $items[] = $item->toArray();
        }

        return array(
            "data" => $items,
            "page"  => $this->pagination
        );
    }

    /**
     * Convert the collection to JSON
     *
     * @access public
     * @return string
     */
    public function toJson()
    {
        return json_encode($this->toArray(), true);
    }

    /**
     * Convert the object into something JSON serializable.
     *
     * @access public
     * @return array
     */
    public function jsonSerialize()
    {
        return $this->toArray();
    }

    /**
     * Convert the collection to its string representation
     *
     * @access public
     * @return string
     */
    public function __toString()
    {
        return $this->toJson();
    }

    /**
     * Determine if the given item exists.
     *
     * @access public
     * @param  mixed  $offset
     * @return bool
     */
    public function offsetExists($offset)
    {
        return isset($this->items[$offset]);
    }
    /**
     * Get the value for a given offset.
     *
     * @access public
     * @param  mixed  $offset
     * @return mixed
     */
    public function offsetGet($offset)
    {
        return $this->items[$offset];
    }
    /**
     * Set the value for a given offset.
     *
     * @access public
     * @param  mixed  $offset
     * @param  mixed  $value
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->items[$offset] = $value;
    }
    /**
     * Unset the value for a given offset.
     *
     * @access public
     * @param  mixed  $offset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->items[$offset]);
    }

    /**
     * Make the collection items iteratable
     *
     * @access public
     * @return ArrayIterator
     */
    public function getIterator() {
        return new \ArrayIterator($this->items);
    }

}

1		<?php
2		/**
3		* Copyright 2015 Dirk Groenen
4		*
5		* (c) Dirk Groenen <[email protected]>
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		*/
10
11		namespace DirkGroenen\Pinterest\Models;
12
13		use DirkGroenen\Pinterest\Exceptions\PinterestException;
14
15		use \DirkGroenen\Pinterest\Pinterest;
16		use \DirkGroenen\Pinterest\Transport\Response;
17
18		class Collection implements \JsonSerializable, \ArrayAccess, \IteratorAggregate{
19
20		/**
21		* The items in the collection
22		*
23		* @var array
24		*/
25		private $items = [];
26
27		/**
28		* The model of each collection item
29		*
30		* @var string
31		*/
32		private $model;
33
34		/**
35		* Stores the pagination object
36		*
37		* @var array\|boolean
38		*/
39		public $pagination;
40
41		/**
42		* Instance of Pinterest master class
43		*
44		* @var Pinterest
45		*/
46		private $master;
47
48		/**
49		* Response instance
50		*
51		* @var Response
52		*/
53		private $response;
54
55		/**
56		* Construct
57		*
58		* @access public
59		* @param Pinterest $master
60		* @param array\|Response $items
61		* @param string $model
62		* @throws InvalidModelException
63		*/
64	19	public function __construct(Pinterest $master, $items, $model) {
65	19	$this->master = $master;
66
67		// Create class path
68	19	$this->model = ucfirst(strtolower($model));
69
70	19	if (!class_exists("\\DirkGroenen\\Pinterest\\Models\\" . $this->model)) {
71		throw new InvalidModelException;
72		}
73
74		// Get items and response instance
75	19	if (is_array($items)) {
76	1	$this->response = null;
77	1	$this->items = $items;
78	18	} else if ($items instanceof \DirkGroenen\Pinterest\Transport\Response) {
79	18	$this->response = $items;
80	18	$this->items = $items->data;
81		} else {
82		throw new PinterestException("$items needs to be an instance of Transport\Response or an array.");
83		}
84
85		// Transform the raw collection data to models
86	19	$this->items = $this->buildCollectionModels($this->items);
87
88		// Add pagination object
89	19	if (isset($this->response->page) && !empty($this->response->page['next'])) {
90	9	$this->pagination = $this->response->page;
91		} else {
92	10	$this->pagination = false;
93		}
94	19	}
95
96		/**
97		* Get all items from the collection
98		*
99		* @access public
100		* @return array
101		*/
102	1	public function all()
103		{
104	1	return $this->items;
105		}
106
107		/**
108		* Transform each raw item into a model
109		*
110		* @access private
111		* @param array $items
112		* @return array
113		*/
114	19	private function buildCollectionModels(array $items)
115		{
116	19	$modelcollection = [];
117
118	19	foreach ($items as $item) {
119	19	$class = new \ReflectionClass("\\DirkGroenen\\Pinterest\\Models\\" . $this->model);
120	19	$modelcollection[] = $class->newInstanceArgs([$this->master, $item]);
121		}
122
123	19	return $modelcollection;
124		}
125
126		/**
127		* Check if their is a next page available
128		*
129		* @access public
130		* @return boolean
131		*/
132	1	public function hasNextPage()
133		{
134	1	return ($this->response != null && isset($this->response->page['next']));
135		}
136
137		/**
138		* Return the item at the given index
139		*
140		* @access public
141		* @param int $index
142		* @return Model
143		*/
144	15	public function get($index)
145		{
146	15	return $this->items[$index];
147		}
148
149		/**
150		* Convert the collection to an array
151		*
152		* @access public
153		* @return array
154		*/
155	2	public function toArray()
156		{
157	2	$items = [];
158
159	2	foreach ($this->items as $item) {
160	2	$items[] = $item->toArray();
161		}
162
163		return array(
164	2	"data" => $items,
165	2	"page" => $this->pagination
166		);
167		}
168
169		/**
170		* Convert the collection to JSON
171		*
172		* @access public
173		* @return string
174		*/
175	1	public function toJson()
176		{
177	1	return json_encode($this->toArray(), true);
178		}
179
180		/**
181		* Convert the object into something JSON serializable.
182		*
183		* @access public
184		* @return array
185		*/
186		public function jsonSerialize()
187		{
188		return $this->toArray();
189		}
190
191		/**
192		* Convert the collection to its string representation
193		*
194		* @access public
195		* @return string
196		*/
197		public function __toString()
198		{
199		return $this->toJson();
200		}
201
202		/**
203		* Determine if the given item exists.
204		*
205		* @access public
206		* @param mixed $offset
207		* @return bool
208		*/
209		public function offsetExists($offset)
210		{
211		return isset($this->items[$offset]);
212		}
213		/**
214		* Get the value for a given offset.
215		*
216		* @access public
217		* @param mixed $offset
218		* @return mixed
219		*/
220		public function offsetGet($offset)
221		{
222		return $this->items[$offset];
223		}
224		/**
225		* Set the value for a given offset.
226		*
227		* @access public
228		* @param mixed $offset
229		* @param mixed $value
230		* @return void
231		*/
232		public function offsetSet($offset, $value)
233		{
234		$this->items[$offset] = $value;
235		}
236		/**
237		* Unset the value for a given offset.
238		*
239		* @access public
240		* @param mixed $offset
241		* @return void
242		*/
243		public function offsetUnset($offset)
244		{
245		unset($this->items[$offset]);
246		}
247
248		/**
249		* Make the collection items iteratable
250		*
251		* @access public
252		* @return ArrayIterator
253		*/
254		public function getIterator() {
255		return new \ArrayIterator($this->items);
256		}
257
258		}

dirkgroenen / pinterest-api-php

GitHub Access Token became invalid

Collection::get() A last analyzed 2020-01-27 08:00 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Collection::get() A
last analyzed 2020-01-27 08:00 UTC