EntityCollection - Code Metrics - Inspection of "Merge pull request #151 from analogueorm/analysis-..." - analogueorm/analogue - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (901ac8)

by Rémi

created 2017-02-06 15:22 UTC

EntityCollection B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	448
Duplicated Lines	13.17 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	59
loc	448
rs	8.2769
wmc	41
lcom	1
cbo	7

26 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	find()	0	10	2
A	add()	0	6	1
A	remove()	0	6	1
A	push()	0	4	1
A	put()	0	4	1
A	offsetSet()	0	8	2
A	fetch()	0	4	1
A	getEntityHashes()	13	13	1
A	getSubsetByHashes()	0	18	3
A	merge()	0	10	2
A	diff()	14	14	3
A	intersect()	14	14	3
A	only()	0	6	1
A	except()	0	6	1
A	getDictionary()	0	12	3
A	getEntityKeys()	0	4	1
A	getEntityKey()	0	8	1
A	max()	9	9	3
A	min()	9	9	3
A	pluck()	0	4	1
A	lists()	0	4	1
A	unique()	0	6	1
A	toBase()	0	4	1
A	toArray()	0	4	1
A	toJson()	0	6	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like EntityCollection often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use EntityCollection, and based on these observations, apply Extract Interface, too.

<?php

namespace Analogue\ORM;

use Analogue\ORM\Exceptions\MappingException;
use Analogue\ORM\System\Manager;
use Analogue\ORM\System\Wrappers\Factory;
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;

class EntityCollection extends Collection
{
    /**
     * Wrapper Factory.
     *
     * @var \Analogue\ORM\System\Wrappers\Factory
     */
    protected $factory;

    /**
     * EntityCollection constructor.
     *
     * @param array|null $entities
     */
    public function __construct(array $entities = null)
    {
        $this->factory = new Factory();

        parent::__construct($entities);
    }

    /**
     * Find an entity in the collection by key.
     *
     * @param mixed $key
     * @param mixed $default
     *
     * @throws MappingException
     *
     * @return \Analogue\ORM\Entity
     */
    public function find($key, $default = null)
    {
        if ($key instanceof Mappable) {
            $key = $this->getEntityKey($key);
        }

        return array_first($this->items, function ($entity, $itemKey) use ($key) {

            return $this->getEntityKey($entity) == $key;
        }, $default);
    }

    /**
     * Add an entity to the collection.
     *
     * @param Mappable $entity
     *
     * @return $this
     */
    public function add($entity)
    {
        $this->push($entity);

        return $this;
    }

    /**
     * Remove an entity from the collection.
     *
     * @param $entity
     *
     * @throws MappingException
     *
     * @return mixed
     */
    public function remove($entity)
    {
        $key = $this->getEntityKey($entity);

        return $this->pull($key);
    }

    /**
     * Push an item onto the end of the collection.
     *
     * @param mixed $value
     *
     * @return void
     */
    public function push($value)
    {
        $this->offsetSet(null, $value);
    }

    /**
     * Put an item in the collection by key.
     *
     * @param mixed $key
     * @param mixed $value
     *
     * @return void
     */
    public function put($key, $value)
    {
        $this->offsetSet($key, $value);
    }

    /**
     * Set the item at a given offset.
     *
     * @param mixed $key
     * @param mixed $value
     *
     * @return void
     */
    public function offsetSet($key, $value)
    {
        if (is_null($key)) {
            $this->items[] = $value;
        } else {
            $this->items[$key] = $value;
        }
    }

    /**
     * Determine if a key exists in the collection.
     *
     * @param mixed      $key
     * @param mixed|null $value
     *
     * @return bool
     */
    // public function contains($key, $value = null)

    // {
    //     if (func_num_args() == 2) {

    //         return !$this->where($key, $value)->isEmpty();

    //     }

    //     if ($this->useAsCallable($key)) {

    //         return !is_null($this->first($key));

    //     }

    //     return !is_null($this->find($key));

    // }

    /**
     * Fetch a nested element of the collection.
     *
     * @param string $key
     *
     * @return self
     */
    public function fetch($key)
    {
        return new static(array_fetch($this->toArray(), $key));
    }

    /**
     * Generic function for returning class.key value pairs.
     *
     * @throws MappingException
     *
     * @return string
     */
    public function getEntityHashes()

    {
        return array_map(function ($entity) {
            $class = get_class($entity);

            $mapper = Manager::getMapper($class);

            $keyName = $mapper->getEntityMap()->getKeyName();

            return $class.'.'.$entity->getEntityAttribute($keyName);
        },
        $this->items);
    }

    /**
     * Get a subset of the collection from entity hashes.
     *
     * @param array $hashes
     *
     * @throws MappingException
     *
     * @return array
     */
    public function getSubsetByHashes(array $hashes)
    {
        $subset = [];

        foreach ($this->items as $item) {
            $class = get_class($item);

            $mapper = Manager::getMapper($class);

            $keyName = $mapper->getEntityMap()->getKeyName();

            if (in_array($class.'.'.$item->$keyName, $hashes)) {
                $subset[] = $item;
            }
        }

        return $subset;
    }

    /**
     * Merge the collection with the given items.
     *
     * @param array $items
     *
     * @throws MappingException
     *
     * @return self
     */
    public function merge($items)
    {
        $dictionary = $this->getDictionary();

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

        return new static(array_values($dictionary));
    }

    /**
     * Diff the collection with the given items.
     *
     * @param \ArrayAccess|array $items
     *
     * @return self
     */
    public function diff($items)

    {
        $diff = new static();

        $dictionary = $this->getDictionary($items);

        foreach ($this->items as $item) {
            if (!isset($dictionary[$this->getEntityKey($item)])) {
                $diff->add($item);
            }
        }

        return $diff;
    }

    /**
     * Intersect the collection with the given items.
     *
     * @param \ArrayAccess|array $items
     *
     * @throws MappingException
     *
     * @return self
     */
    public function intersect($items)

    {
        $intersect = new static();

        $dictionary = $this->getDictionary($items);

        foreach ($this->items as $item) {
            if (isset($dictionary[$this->getEntityKey($item)])) {
                $intersect->add($item);
            }
        }

        return $intersect;
    }

    /**
     * Returns only the models from the collection with the specified keys.
     *
     * @param mixed $keys
     *
     * @return self
     */
    public function only($keys)
    {
        $dictionary = array_only($this->getDictionary(), $keys);

        return new static(array_values($dictionary));
    }

    /**
     * Returns all models in the collection except the models with specified keys.
     *
     * @param mixed $keys
     *
     * @return self
     */
    public function except($keys)
    {
        $dictionary = array_except($this->getDictionary(), $keys);

        return new static(array_values($dictionary));
    }

    /**
     * Get a dictionary keyed by primary keys.
     *
     * @param \ArrayAccess|array $items
     *
     * @throws MappingException
     *
     * @return array
     */
    public function getDictionary($items = null)
    {
        $items = is_null($items) ? $this->items : $items;

        $dictionary = [];

        foreach ($items as $value) {
            $dictionary[$this->getEntityKey($value)] = $value;
        }

        return $dictionary;
    }

    /**
     * @throws MappingException
     *
     * @return array
     */
    public function getEntityKeys()
    {
        return array_keys($this->getDictionary());
    }

    /**
     * @param $entity
     *
     * @throws MappingException
     *
     * @return mixed
     */
    protected function getEntityKey($entity)
    {
        $keyName = Manager::getMapper($entity)->getEntityMap()->getKeyName();

        $wrapper = $this->factory->make($entity);

        return $wrapper->getEntityAttribute($keyName);
    }

    /**
     * Get the max value of a given key.
     *
     * @param string|null $key
     *
     * @throws MappingException
     *
     * @return mixed
     */
    public function max($key = null)

    {
        return $this->reduce(function ($result, $item) use ($key) {
            $wrapper = $this->factory->make($item);

            return (is_null($result) || $wrapper->getEntityAttribute($key) > $result) ?
                $wrapper->getEntityAttribute($key) : $result;
        });
    }

    /**
     * Get the min value of a given key.
     *
     * @param string|null $key
     *
     * @throws MappingException
     *
     * @return mixed
     */
    public function min($key = null)

    {
        return $this->reduce(function ($result, $item) use ($key) {
            $wrapper = $this->factory->make($item);

            return (is_null($result) || $wrapper->getEntityAttribute($key) < $result)
                ? $wrapper->getEntityAttribute($key) : $result;
        });
    }

    /**
     * Get an array with the values of a given key.
     *
     * @param string      $value
     * @param string|null $key
     *
     * @return self
     */
    public function pluck($value, $key = null)
    {
        return new Collection(Arr::pluck($this->items, $value, $key));
    }

    /**
     * Alias for the "pluck" method.
     *
     * @param string      $value
     * @param string|null $key
     *
     * @return self
     */
    public function lists($value, $key = null)
    {
        return $this->pluck($value, $key);
    }

    /**
     * Return only unique items from the collection.
     *
     * @param string|null $key
     * @param bool        $strict
     *
     * @throws MappingException
     *
     * @return self
     */
    public function unique($key = null, $strict = false)
    {
        $dictionary = $this->getDictionary();

        return new static(array_values($dictionary));
    }

    /**
     * Get a base Support collection instance from this collection.
     *
     * @return \Illuminate\Support\Collection
     */
    public function toBase()
    {
        return new Collection($this->items);
    }

    public function toArray()
    {
        return array_values(parent::toArray());
    }

    /**
     * Get the collection of items as JSON.
     *
     * @param int $options
     *
     * @return string
     */
    public function toJson($options = 0)
    {
        $collection = new Collection(array_values($this->items));

        return $collection->toJson($options);
    }
}


1		<?php
2
3		namespace Analogue\ORM;
4
5		use Analogue\ORM\Exceptions\MappingException;
6		use Analogue\ORM\System\Manager;
7		use Analogue\ORM\System\Wrappers\Factory;
8		use Illuminate\Support\Arr;
9		use Illuminate\Support\Collection;
10
11		class EntityCollection extends Collection
12		{
13		/**
14		* Wrapper Factory.
15		*
16		* @var \Analogue\ORM\System\Wrappers\Factory
17		*/
18		protected $factory;
19
20		/**
21		* EntityCollection constructor.
22		*
23		* @param array\|null $entities
24		*/
25		public function __construct(array $entities = null)
26		{
27		$this->factory = new Factory();
28
29		parent::__construct($entities);
30		}
31
32		/**
33		* Find an entity in the collection by key.
34		*
35		* @param mixed $key
36		* @param mixed $default
37		*
38		* @throws MappingException
39		*
40		* @return \Analogue\ORM\Entity
41		*/
42		public function find($key, $default = null)
43		{
44		if ($key instanceof Mappable) {
45		$key = $this->getEntityKey($key);
46		}
47
48		return array_first($this->items, function ($entity, $itemKey) use ($key) {
		0 ignored issues – show Unused Code introduced 2016-10-24 06:50 UTC by Report Bug Copy Issue Report The parameter `$itemKey` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
49		return $this->getEntityKey($entity) == $key;
50		}, $default);
51		}
52
53		/**
54		* Add an entity to the collection.
55		*
56		* @param Mappable $entity
57		*
58		* @return $this
59		*/
60		public function add($entity)
61		{
62		$this->push($entity);
63
64		return $this;
65		}
66
67		/**
68		* Remove an entity from the collection.
69		*
70		* @param $entity
71		*
72		* @throws MappingException
73		*
74		* @return mixed
75		*/
76		public function remove($entity)
77		{
78		$key = $this->getEntityKey($entity);
79
80		return $this->pull($key);
81		}
82
83		/**
84		* Push an item onto the end of the collection.
85		*
86		* @param mixed $value
87		*
88		* @return void
89		*/
90		public function push($value)
91		{
92		$this->offsetSet(null, $value);
93		}
94
95		/**
96		* Put an item in the collection by key.
97		*
98		* @param mixed $key
99		* @param mixed $value
100		*
101		* @return void
102		*/
103		public function put($key, $value)
104		{
105		$this->offsetSet($key, $value);
106		}
107
108		/**
109		* Set the item at a given offset.
110		*
111		* @param mixed $key
112		* @param mixed $value
113		*
114		* @return void
115		*/
116		public function offsetSet($key, $value)
117		{
118		if (is_null($key)) {
119		$this->items[] = $value;
120		} else {
121		$this->items[$key] = $value;
122		}
123		}
124
125		/**
126		* Determine if a key exists in the collection.
127		*
128		* @param mixed $key
129		* @param mixed\|null $value
130		*
131		* @return bool
132		*/
133		// public function contains($key, $value = null)
		0 ignored issues – show Unused Code Comprehensibility introduced 2017-02-06 15:33 UTC by Report Bug Copy Issue Report `50%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
134		// {
135		// if (func_num_args() == 2) {
		0 ignored issues – show Unused Code Comprehensibility introduced 2017-02-06 15:33 UTC by Report Bug Copy Issue Report `50%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
136		// return !$this->where($key, $value)->isEmpty();
		0 ignored issues – show Unused Code Comprehensibility introduced 2017-02-06 15:33 UTC by Report Bug Copy Issue Report `73%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
137		// }
138
139		// if ($this->useAsCallable($key)) {
		0 ignored issues – show Unused Code Comprehensibility introduced 2017-02-06 15:33 UTC by Report Bug Copy Issue Report `70%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
140		// return !is_null($this->first($key));
		0 ignored issues – show Unused Code Comprehensibility introduced 2017-02-06 15:33 UTC by Report Bug Copy Issue Report `72%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
141		// }
142
143		// return !is_null($this->find($key));
		0 ignored issues – show Unused Code Comprehensibility introduced 2017-02-06 15:33 UTC by Report Bug Copy Issue Report `72%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
144		// }
145
146		/**
147		* Fetch a nested element of the collection.
148		*
149		* @param string $key
150		*
151		* @return self
152		*/
153		public function fetch($key)
154		{
155		return new static(array_fetch($this->toArray(), $key));
156		}
157
158		/**
159		* Generic function for returning class.key value pairs.
160		*
161		* @throws MappingException
162		*
163		* @return string
164		*/
165	View Code Duplication	public function getEntityHashes()
		0 ignored issues – show Duplication introduced 2015-12-17 17:19 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
166		{
167		return array_map(function ($entity) {
168		$class = get_class($entity);
169
170		$mapper = Manager::getMapper($class);
171
172		$keyName = $mapper->getEntityMap()->getKeyName();
173
174		return $class.'.'.$entity->getEntityAttribute($keyName);
175		},
176		$this->items);
177		}
178
179		/**
180		* Get a subset of the collection from entity hashes.
181		*
182		* @param array $hashes
183		*
184		* @throws MappingException
185		*
186		* @return array
187		*/
188		public function getSubsetByHashes(array $hashes)
189		{
190		$subset = [];
191
192		foreach ($this->items as $item) {
193		$class = get_class($item);
194
195		$mapper = Manager::getMapper($class);
196
197		$keyName = $mapper->getEntityMap()->getKeyName();
198
199		if (in_array($class.'.'.$item->$keyName, $hashes)) {
200		$subset[] = $item;
201		}
202		}
203
204		return $subset;
205		}
206
207		/**
208		* Merge the collection with the given items.
209		*
210		* @param array $items
211		*
212		* @throws MappingException
213		*
214		* @return self
215		*/
216		public function merge($items)
217		{
218		$dictionary = $this->getDictionary();
219
220		foreach ($items as $item) {
221		$dictionary[$this->getEntityKey($item)] = $item;
222		}
223
224		return new static(array_values($dictionary));
225		}
226
227		/**
228		* Diff the collection with the given items.
229		*
230		* @param \ArrayAccess\|array $items
231		*
232		* @return self
233		*/
234	View Code Duplication	public function diff($items)
		0 ignored issues – show Duplication introduced 2015-12-17 17:19 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
235		{
236		$diff = new static();
237
238		$dictionary = $this->getDictionary($items);
239
240		foreach ($this->items as $item) {
241		if (!isset($dictionary[$this->getEntityKey($item)])) {
242		$diff->add($item);
243		}
244		}
245
246		return $diff;
247		}
248
249		/**
250		* Intersect the collection with the given items.
251		*
252		* @param \ArrayAccess\|array $items
253		*
254		* @throws MappingException
255		*
256		* @return self
257		*/
258	View Code Duplication	public function intersect($items)
		0 ignored issues – show Duplication introduced 2015-12-17 17:19 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
259		{
260		$intersect = new static();
261
262		$dictionary = $this->getDictionary($items);
263
264		foreach ($this->items as $item) {
265		if (isset($dictionary[$this->getEntityKey($item)])) {
266		$intersect->add($item);
267		}
268		}
269
270		return $intersect;
271		}
272
273		/**
274		* Returns only the models from the collection with the specified keys.
275		*
276		* @param mixed $keys
277		*
278		* @return self
279		*/
280		public function only($keys)
281		{
282		$dictionary = array_only($this->getDictionary(), $keys);
283
284		return new static(array_values($dictionary));
285		}
286
287		/**
288		* Returns all models in the collection except the models with specified keys.
289		*
290		* @param mixed $keys
291		*
292		* @return self
293		*/
294		public function except($keys)
295		{
296		$dictionary = array_except($this->getDictionary(), $keys);
297
298		return new static(array_values($dictionary));
299		}
300
301		/**
302		* Get a dictionary keyed by primary keys.
303		*
304		* @param \ArrayAccess\|array $items
305		*
306		* @throws MappingException
307		*
308		* @return array
309		*/
310		public function getDictionary($items = null)
311		{
312		$items = is_null($items) ? $this->items : $items;
313
314		$dictionary = [];
315
316		foreach ($items as $value) {
317		$dictionary[$this->getEntityKey($value)] = $value;
318		}
319
320		return $dictionary;
321		}
322
323		/**
324		* @throws MappingException
325		*
326		* @return array
327		*/
328		public function getEntityKeys()
329		{
330		return array_keys($this->getDictionary());
331		}
332
333		/**
334		* @param $entity
335		*
336		* @throws MappingException
337		*
338		* @return mixed
339		*/
340		protected function getEntityKey($entity)
341		{
342		$keyName = Manager::getMapper($entity)->getEntityMap()->getKeyName();
343
344		$wrapper = $this->factory->make($entity);
345
346		return $wrapper->getEntityAttribute($keyName);
347		}
348
349		/**
350		* Get the max value of a given key.
351		*
352		* @param string\|null $key
353		*
354		* @throws MappingException
355		*
356		* @return mixed
357		*/
358	View Code Duplication	public function max($key = null)
		0 ignored issues – show Duplication introduced 2015-12-17 17:19 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
359		{
360		return $this->reduce(function ($result, $item) use ($key) {
361		$wrapper = $this->factory->make($item);
362
363		return (is_null($result) \|\| $wrapper->getEntityAttribute($key) > $result) ?
364		$wrapper->getEntityAttribute($key) : $result;
365		});
366		}
367
368		/**
369		* Get the min value of a given key.
370		*
371		* @param string\|null $key
372		*
373		* @throws MappingException
374		*
375		* @return mixed
376		*/
377	View Code Duplication	public function min($key = null)
		0 ignored issues – show Duplication introduced 2015-12-17 17:19 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
378		{
379		return $this->reduce(function ($result, $item) use ($key) {
380		$wrapper = $this->factory->make($item);
381
382		return (is_null($result) \|\| $wrapper->getEntityAttribute($key) < $result)
383		? $wrapper->getEntityAttribute($key) : $result;
384		});
385		}
386
387		/**
388		* Get an array with the values of a given key.
389		*
390		* @param string $value
391		* @param string\|null $key
392		*
393		* @return self
394		*/
395		public function pluck($value, $key = null)
396		{
397		return new Collection(Arr::pluck($this->items, $value, $key));
398		}
399
400		/**
401		* Alias for the "pluck" method.
402		*
403		* @param string $value
404		* @param string\|null $key
405		*
406		* @return self
407		*/
408		public function lists($value, $key = null)
409		{
410		return $this->pluck($value, $key);
411		}
412
413		/**
414		* Return only unique items from the collection.
415		*
416		* @param string\|null $key
417		* @param bool $strict
418		*
419		* @throws MappingException
420		*
421		* @return self
422		*/
423		public function unique($key = null, $strict = false)
424		{
425		$dictionary = $this->getDictionary();
426
427		return new static(array_values($dictionary));
428		}
429
430		/**
431		* Get a base Support collection instance from this collection.
432		*
433		* @return \Illuminate\Support\Collection
434		*/
435		public function toBase()
436		{
437		return new Collection($this->items);
438		}
439
440		public function toArray()
441		{
442		return array_values(parent::toArray());
443		}
444
445		/**
446		* Get the collection of items as JSON.
447		*
448		* @param int $options
449		*
450		* @return string
451		*/
452		public function toJson($options = 0)
453		{
454		$collection = new Collection(array_values($this->items));
455
456		return $collection->toJson($options);
457		}
458		}
459

analogueorm / analogue