AbstractCollection::hasOriginal() - Code Metrics - Inspection of "Merge pull request #79 from zarathustra323/embedde..." - as3io/modlr - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e24a08...649c71 )

by Joshua

created 2016-04-19 14:14 UTC

AbstractCollection::hasOriginal() A

↳ Parent: AbstractCollection

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace As3\Modlr\Models\Collections;

use \Countable;
use \Iterator;
use As3\Modlr\Models\AbstractModel;
use As3\Modlr\Store\Store;

/**
 * Collection that contains record representations from a persistence (database) layer.
 * These representations can either be of first-order Models or fragmentted Embeds.
 *
 * @author Jacob Bare <[email protected]>
 */
abstract class AbstractCollection implements Iterator, Countable
{
    /**
     * Models added to this collection.
     * Tracks newly added models for rollback/change purposes.
     *
     * @var AbstractModel[]
     */
    protected $added = [];

    /**
     * Whether the collection has been loaded with data from the persistence layer
     *
     * @var bool
     */
    protected $loaded = true;

    /**
     * Current models assigned to this collection.
     * Needed for iteration, access, and count purposes.
     *
     * @var AbstractModel[]
     */
    protected $models = [];

    /**
     * Original models assigned to this collection.
     *
     * @var AbstractModel[]
     */
    protected $original = [];

    /**
     * The array position.
     *
     * @var int
     */
    protected $pos = 0;

    /**
     * Models removed from this collection.
     * Tracks removed models for rollback/change purposes.
     *
     * @var AbstractModel[]
     */
    protected $removed = [];

    /**
     * The store for handling storage operations.
     *
     * @var Store
     */
    protected $store;

    /**
     * Constructor.
     *
     * @param   Store           $store
     * @param   AbstractModel[] $models
     */
    public function __construct(Store $store, array $models = [])
    {
        $this->pos = 0;
        $this->store = $store;
        $this->setModels($models);
    }

    /**
     * Calculates the change set of this collection.
     *
     * @return  array
     */
    public function calculateChangeSet()
    {
        if (false === $this->isDirty()) {
            return [];
        }
        return [
            'old' => empty($this->original) ? null : $this->original,
            'new' => empty($this->models) ? null : $this->models,
        ];
    }

    /**
     * Clears/empties the collection.
     *
     * @return  self
     */
    public function clear()
    {
        $this->models = [];
        $this->added = [];
        $this->removed = $this->original;
        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function count()
    {
        return count($this->models);
    }

    /**
     * {@inheritDoc}
     */
    public function current()
    {
        return $this->models[$this->pos];
    }

    /**
     * Gets a single model result from the collection.
     *
     * @return  AbstractModel|null
     */
    public function getSingleResult()
    {
        if (0 === $this->count()) {
            return null;
        }
        $this->rewind();
        return $this->current();
    }

    /**
     * Gets the model collection type.
     *
     * @return  string
     */
    abstract public function getType();

    /**
     * Determines if the Model is included in the collection.
     *
     * @param   AbstractModel   $model  The model to check.
     * @return  bool
     */
    public function has(AbstractModel $model)
    {
        return -1 !== $this->indexOf('models', $model);
    }

    /**
     * Determines if any models in this collection are dirty (have changes).
     *
     * @return  bool
     */
    public function hasDirtyModels()
    {
        foreach ($this->models as $model) {
            if (true === $model->isDirty()) {
                return true;
            }
        }
        return false;
    }

    /**
     * Determines if the collection is dirty.
     *
     * @return  bool
     */
    public function isDirty()
    {
        return !empty($this->added) || !empty($this->removed);
    }

    /**
     * Determines if this collection is empty.
     *
     * @return  bool
     */
    public function isEmpty()
    {
        return 0 === $this->count();
    }

    /**
     * Determines if models in this collection have been loaded from the persistence layer.
     *
     * @return  bool
     */
    public function isLoaded()
    {
        return $this->loaded;
    }

    /**
     * {@inheritDoc}
     */
    public function key()
    {
        return $this->pos;
    }

    /**
     * {@inheritDoc}
     */
    public function next()
    {
        ++$this->pos;
    }

    /**
     * Pushes a Model into the collection.
     *
     * @param   AbstractModel   $model  The model to push.
     * @return  self
     */
    public function push(AbstractModel $model)

    {
        $this->validateAdd($model);
        if (true === $this->willAdd($model)) {
            return $this;
        }
        if (true === $this->willRemove($model)) {
            $this->evict('removed', $model);
            $this->set('models', $model);
            return $this;
        }
        if (true === $this->hasOriginal($model)) {
            return $this;
        }
        $this->set('added', $model);
        $this->set('models', $model);
        return $this;
    }

    /**
     * Removes a model from the collection.
     *
     * @param   AbstractModel   $model  The model to remove.
     * @return  self
     */
    public function remove(AbstractModel $model)

    {
        $this->validateAdd($model);
        if (true === $this->willRemove($model)) {
            return $this;
        }

        if (true === $this->willAdd($model)) {
            $this->evict('added', $model);
            $this->evict('models', $model);
            return $this;
        }

        if (true === $this->hasOriginal($model)) {
            $this->evict('models', $model);
            $this->set('removed', $model);
        }
        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function rewind()
    {
        $this->pos = 0;
    }

    /**
     * Rollsback the collection it it's original state.
     *
     * @return  self
     */
    public function rollback()
    {
        $this->models = $this->original;
        $this->added = [];
        $this->removed = [];
        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function valid()
    {
        return isset($this->models[$this->pos]);
    }

    /**
     * Determines if the model is scheduled for addition to the collection.
     *
     * @param   AbstractModel   $model  The model to check.
     * @return  bool
     */
    public function willAdd(AbstractModel $model)
    {
        return -1 !== $this->indexOf('added', $model);
    }

    /**
     * Determines if the model is scheduled for removal from the collection.
     *
     * @param   AbstractModel   $model  The model to check.
     * @return  bool
     */
    public function willRemove(AbstractModel $model)
    {
        return -1 !== $this->indexOf('removed', $model);
    }

    /**
     * Adds an model to this collection.
     * Is used during initial collection construction.
     *
     * @param   AbstractModel   $model
     * @return  self
     */
    protected function add(AbstractModel $model)
    {
        if (true === $this->has($model)) {
            return $this;
        }
        $this->validateAdd($model);
        if (true === $model->getState()->is('empty')) {
            $this->loaded = false;
        }
        $this->models[] = $model;
        if (false === $this->hasOriginal($model)) {
            $this->original[] = $model;
        }
        return $this;
    }

    /**
     * Evicts a model from a collection property (original, added, removed, models).
     *
     * @param   string          $property   The property key
     * @param   AbstractModel   $model      The model to set.
     * @return  self
     */
    protected function evict($property, AbstractModel $model)
    {
        $index = $this->indexOf($property, $model);
        $models = $this->$property;
        unset($models[$index]);
        $this->$property = array_values($models);
        return $this;
    }

    /**
     * Determines if the model is included in the original set.
     *
     * @param   AbstractModel   $model  The model to check.
     * @return  bool
     */
    protected function hasOriginal(AbstractModel $model)
    {
        return -1 !== $this->indexOf('original', $model);
    }

    /**
     * Gets the Model array index from a collection property (original, added, removed, models).
     * Will return -1 if the model was not found.
     *
     * @param   string          $property   The property key
     * @param   AbstractModel   $model      The model to check.
     * @return  int
     */
    protected function indexOf($property, AbstractModel $model)
    {
        $this->validateModelClass($model);

        // @todo For performance, can we create a map using the model's composite key to avoid these loops?
        foreach ($this->$property as $index => $loaded) {
            if (true === $this->modelsMatch($model, $loaded)) {
                return $index;
            }
        }
        return -1;
    }

    /**
     * Determines if the provided models match.
     *
     * @param   AbstractModel   $model
     * @param   AbstractModel   $loaded
     * @return  bool
     */
    abstract protected function modelsMatch(AbstractModel $model, AbstractModel $loaded);

    /**
     * Sets a model to a collection property (original, added, removed, models).
     *
     * @param   string          $property   The property key
     * @param   AbstractModel   $model      The model to set.
     * @return  self
     */
    protected function set($property, AbstractModel $model)
    {
        $models = $this->$property;
        $models[] = $model;
        $this->$property = $models;
        return $this;
    }

    /**
     * Sets an array of models to the collection.
     *
     * @param   AbstractModel[]     $models
     * @return  self
     */
    protected function setModels(array $models)
    {
        foreach ($models as $model) {
            $this->add($model);
        }
        return $this;
    }

    /**
     * Validates that the collection supports the incoming model.
     *
     * @param   AbstractModel   $model  The model to validate.
     * @throws  \InvalidArgumentException
     */
    abstract protected function validateAdd(AbstractModel $model);
}


1		<?php
2
3		namespace As3\Modlr\Models\Collections;
4
5		use \Countable;
6		use \Iterator;
7		use As3\Modlr\Models\AbstractModel;
8		use As3\Modlr\Store\Store;
9
10		/**
11		* Collection that contains record representations from a persistence (database) layer.
12		* These representations can either be of first-order Models or fragmentted Embeds.
13		*
14		* @author Jacob Bare <[email protected]>
15		*/
16		abstract class AbstractCollection implements Iterator, Countable
17		{
18		/**
19		* Models added to this collection.
20		* Tracks newly added models for rollback/change purposes.
21		*
22		* @var AbstractModel[]
23		*/
24		protected $added = [];
25
26		/**
27		* Whether the collection has been loaded with data from the persistence layer
28		*
29		* @var bool
30		*/
31		protected $loaded = true;
32
33		/**
34		* Current models assigned to this collection.
35		* Needed for iteration, access, and count purposes.
36		*
37		* @var AbstractModel[]
38		*/
39		protected $models = [];
40
41		/**
42		* Original models assigned to this collection.
43		*
44		* @var AbstractModel[]
45		*/
46		protected $original = [];
47
48		/**
49		* The array position.
50		*
51		* @var int
52		*/
53		protected $pos = 0;
54
55		/**
56		* Models removed from this collection.
57		* Tracks removed models for rollback/change purposes.
58		*
59		* @var AbstractModel[]
60		*/
61		protected $removed = [];
62
63		/**
64		* The store for handling storage operations.
65		*
66		* @var Store
67		*/
68		protected $store;
69
70		/**
71		* Constructor.
72		*
73		* @param Store $store
74		* @param AbstractModel[] $models
75		*/
76		public function __construct(Store $store, array $models = [])
77		{
78		$this->pos = 0;
79		$this->store = $store;
80		$this->setModels($models);
81		}
82
83		/**
84		* Calculates the change set of this collection.
85		*
86		* @return array
87		*/
88		public function calculateChangeSet()
89		{
90		if (false === $this->isDirty()) {
91		return [];
92		}
93		return [
94		'old' => empty($this->original) ? null : $this->original,
95		'new' => empty($this->models) ? null : $this->models,
96		];
97		}
98
99		/**
100		* Clears/empties the collection.
101		*
102		* @return self
103		*/
104		public function clear()
105		{
106		$this->models = [];
107		$this->added = [];
108		$this->removed = $this->original;
109		return $this;
110		}
111
112		/**
113		* {@inheritDoc}
114		*/
115		public function count()
116		{
117		return count($this->models);
118		}
119
120		/**
121		* {@inheritDoc}
122		*/
123		public function current()
124		{
125		return $this->models[$this->pos];
126		}
127
128		/**
129		* Gets a single model result from the collection.
130		*
131		* @return AbstractModel\|null
132		*/
133		public function getSingleResult()
134		{
135		if (0 === $this->count()) {
136		return null;
137		}
138		$this->rewind();
139		return $this->current();
140		}
141
142		/**
143		* Gets the model collection type.
144		*
145		* @return string
146		*/
147		abstract public function getType();
148
149		/**
150		* Determines if the Model is included in the collection.
151		*
152		* @param AbstractModel $model The model to check.
153		* @return bool
154		*/
155		public function has(AbstractModel $model)
156		{
157		return -1 !== $this->indexOf('models', $model);
158		}
159
160		/**
161		* Determines if any models in this collection are dirty (have changes).
162		*
163		* @return bool
164		*/
165		public function hasDirtyModels()
166		{
167		foreach ($this->models as $model) {
168		if (true === $model->isDirty()) {
169		return true;
170		}
171		}
172		return false;
173		}
174
175		/**
176		* Determines if the collection is dirty.
177		*
178		* @return bool
179		*/
180		public function isDirty()
181		{
182		return !empty($this->added) \|\| !empty($this->removed);
183		}
184
185		/**
186		* Determines if this collection is empty.
187		*
188		* @return bool
189		*/
190		public function isEmpty()
191		{
192		return 0 === $this->count();
193		}
194
195		/**
196		* Determines if models in this collection have been loaded from the persistence layer.
197		*
198		* @return bool
199		*/
200		public function isLoaded()
201		{
202		return $this->loaded;
203		}
204
205		/**
206		* {@inheritDoc}
207		*/
208		public function key()
209		{
210		return $this->pos;
211		}
212
213		/**
214		* {@inheritDoc}
215		*/
216		public function next()
217		{
218		++$this->pos;
219		}
220
221		/**
222		* Pushes a Model into the collection.
223		*
224		* @param AbstractModel $model The model to push.
225		* @return self
226		*/
227	View Code Duplication	public function push(AbstractModel $model)
		0 ignored issues – show Duplication introduced 2016-04-19 04:25 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...
228		{
229		$this->validateAdd($model);
230		if (true === $this->willAdd($model)) {
231		return $this;
232		}
233		if (true === $this->willRemove($model)) {
234		$this->evict('removed', $model);
235		$this->set('models', $model);
236		return $this;
237		}
238		if (true === $this->hasOriginal($model)) {
239		return $this;
240		}
241		$this->set('added', $model);
242		$this->set('models', $model);
243		return $this;
244		}
245
246		/**
247		* Removes a model from the collection.
248		*
249		* @param AbstractModel $model The model to remove.
250		* @return self
251		*/
252	View Code Duplication	public function remove(AbstractModel $model)
		0 ignored issues – show Duplication introduced 2016-04-19 04:25 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...
253		{
254		$this->validateAdd($model);
255		if (true === $this->willRemove($model)) {
256		return $this;
257		}
258
259		if (true === $this->willAdd($model)) {
260		$this->evict('added', $model);
261		$this->evict('models', $model);
262		return $this;
263		}
264
265		if (true === $this->hasOriginal($model)) {
266		$this->evict('models', $model);
267		$this->set('removed', $model);
268		}
269		return $this;
270		}
271
272		/**
273		* {@inheritDoc}
274		*/
275		public function rewind()
276		{
277		$this->pos = 0;
278		}
279
280		/**
281		* Rollsback the collection it it's original state.
282		*
283		* @return self
284		*/
285		public function rollback()
286		{
287		$this->models = $this->original;
288		$this->added = [];
289		$this->removed = [];
290		return $this;
291		}
292
293		/**
294		* {@inheritDoc}
295		*/
296		public function valid()
297		{
298		return isset($this->models[$this->pos]);
299		}
300
301		/**
302		* Determines if the model is scheduled for addition to the collection.
303		*
304		* @param AbstractModel $model The model to check.
305		* @return bool
306		*/
307		public function willAdd(AbstractModel $model)
308		{
309		return -1 !== $this->indexOf('added', $model);
310		}
311
312		/**
313		* Determines if the model is scheduled for removal from the collection.
314		*
315		* @param AbstractModel $model The model to check.
316		* @return bool
317		*/
318		public function willRemove(AbstractModel $model)
319		{
320		return -1 !== $this->indexOf('removed', $model);
321		}
322
323		/**
324		* Adds an model to this collection.
325		* Is used during initial collection construction.
326		*
327		* @param AbstractModel $model
328		* @return self
329		*/
330		protected function add(AbstractModel $model)
331		{
332		if (true === $this->has($model)) {
333		return $this;
334		}
335		$this->validateAdd($model);
336		if (true === $model->getState()->is('empty')) {
337		$this->loaded = false;
338		}
339		$this->models[] = $model;
340		if (false === $this->hasOriginal($model)) {
341		$this->original[] = $model;
342		}
343		return $this;
344		}
345
346		/**
347		* Evicts a model from a collection property (original, added, removed, models).
348		*
349		* @param string $property The property key
350		* @param AbstractModel $model The model to set.
351		* @return self
352		*/
353		protected function evict($property, AbstractModel $model)
354		{
355		$index = $this->indexOf($property, $model);
356		$models = $this->$property;
357		unset($models[$index]);
358		$this->$property = array_values($models);
359		return $this;
360		}
361
362		/**
363		* Determines if the model is included in the original set.
364		*
365		* @param AbstractModel $model The model to check.
366		* @return bool
367		*/
368		protected function hasOriginal(AbstractModel $model)
369		{
370		return -1 !== $this->indexOf('original', $model);
371		}
372
373		/**
374		* Gets the Model array index from a collection property (original, added, removed, models).
375		* Will return -1 if the model was not found.
376		*
377		* @param string $property The property key
378		* @param AbstractModel $model The model to check.
379		* @return int
380		*/
381		protected function indexOf($property, AbstractModel $model)
382		{
383		$this->validateModelClass($model);
384
385		// @todo For performance, can we create a map using the model's composite key to avoid these loops?
386		foreach ($this->$property as $index => $loaded) {
387		if (true === $this->modelsMatch($model, $loaded)) {
388		return $index;
389		}
390		}
391		return -1;
392		}
393
394		/**
395		* Determines if the provided models match.
396		*
397		* @param AbstractModel $model
398		* @param AbstractModel $loaded
399		* @return bool
400		*/
401		abstract protected function modelsMatch(AbstractModel $model, AbstractModel $loaded);
402
403		/**
404		* Sets a model to a collection property (original, added, removed, models).
405		*
406		* @param string $property The property key
407		* @param AbstractModel $model The model to set.
408		* @return self
409		*/
410		protected function set($property, AbstractModel $model)
411		{
412		$models = $this->$property;
413		$models[] = $model;
414		$this->$property = $models;
415		return $this;
416		}
417
418		/**
419		* Sets an array of models to the collection.
420		*
421		* @param AbstractModel[] $models
422		* @return self
423		*/
424		protected function setModels(array $models)
425		{
426		foreach ($models as $model) {
427		$this->add($model);
428		}
429		return $this;
430		}
431
432		/**
433		* Validates that the collection supports the incoming model.
434		*
435		* @param AbstractModel $model The model to validate.
436		* @throws \InvalidArgumentException
437		*/
438		abstract protected function validateAdd(AbstractModel $model);
439		}
440

as3io / modlr

Push — master ( e24a08...649c71 )

AbstractCollection::hasOriginal() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like