AbstractArray::push() - Code Metrics - Inspection of "sources" - spiral/components - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — feature/pre-split (6ce9be)

by Anton

created 2016-12-26 14:21 UTC

AbstractArray::push() A

↳ Parent: AbstractArray

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	7
nc	2
nop	1
dl	0
loc	12
rs	9.4285
c	0
b	0
f	0

<?php
/**
 * components
 *
 * @author    Wolfy-J
 */
namespace Spiral\ODM\Accessors;

use Spiral\Models\Traits\SolidableTrait;
use Spiral\ODM\CompositableInterface;

/**
 * Provides ability to perform scalar operations on arrays.
 *
 * Attention, array will be saved as one big $set operation in case when multiple atomic
 * operations applied to it (not supported by Mongo).
 */
abstract class AbstractArray implements CompositableInterface, \Countable, \IteratorAggregate
{
    use SolidableTrait;

    /**
     * @var array
     */
    protected $values = [];

    /**
     * Low level atomic operations.
     *
     * @var array
     */
    protected $atomics = [];

    /**
     * @param mixed $values
     */
    public function __construct($values)
    {
        if (!is_array($values)) {
            //Since we have to overwrite non array field
            $this->solidState = true;
        }

        $this->addValues($values);
    }

    /**
     * Check if value presented in array.
     *
     * @param mixed $needle
     * @param bool  $strict
     *
     * @return bool
     */
    public function has($needle, bool $strict = true): bool
    {
        foreach ($this->values as $value) {
            if ($strict && $value === $needle) {
                return true;
            }

            if ($strict && $value == $needle) {
                return true;
            }
        }

        return false;
    }

    /**
     * Alias for atomic operation $push. Only values passed type filter will be added.
     *
     * @param mixed $value
     *
     * @return self|$this
     */
    public function push($value): AbstractArray
    {
        $value = $this->filterValue($value);
        if (is_null($value)) {
            return $this;
        }

        array_push($this->values, $value);
        $this->atomics['$push']['$each'][] = $value;

        return $this;
    }

    /**
     * Alias for atomic operation $addToSet. Only values passed type filter will be added.
     *
     * @param mixed $value
     *
     * @return self|$this
     */
    public function add($value): AbstractArray

    {
        $value = $this->filterValue($value);
        if (is_null($value)) {
            return $this;
        }

        if (!in_array($value, $this->values)) {
            array_push($this->values, $value);
        }

        $this->atomics['$addToSet']['$each'][] = $value;

        return $this;
    }

    /**
     * Alias for atomic operation $pull. Only values passed type filter will be added.
     *
     * @param mixed $value
     *
     * @return self|$this
     */
    public function pull($value): AbstractArray

    {
        $value = $this->filterValue($value);
        if (is_null($value)) {
            return $this;
        }

        //Removing values from array (non strict)
        $this->values = array_filter($this->values, function ($item) use ($value) {
            return $item != $value;
        });

        $this->atomics['$pull']['$in'][] = $value;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function stateValue($data)
    {
        //Manually altered arrays must always end in solid state
        $this->solidState = true;

        //Flushing existed values
        $this->values = [];

        //Pushing filtered values in array
        $this->addValues($data);
    }

    /**
     * {@inheritdoc}
     */
    public function hasUpdates(): bool
    {
        return !empty($this->atomics);
    }

    /**
     * {@inheritdoc}
     */
    public function flushUpdates()
    {
        $this->atomics = [];
    }

    /**
     * {@inheritdoc}
     */
    public function buildAtomics(string $container = ''): array
    {
        if (!$this->hasUpdates()) {
            return [];
        }

        //Mongo does not support multiple operations for one field, switching to $set (make sure it's
        //reasonable)
        if ($this->solidState || count($this->atomics) > 1) {

            //We don't care about atomics in solid state
            return ['$set' => [$container => $this->packValue()]];
        }

        $atomics = [];
        foreach ($this->atomics as $operation => $values) {
            $atomics[$operation] = [$container => $values];
        }

        return $atomics;
    }

    /**
     * @return array
     */
    public function packValue(): array
    {
        return $this->values;
    }

    /**
     * @return int
     */
    public function count(): int
    {
        return count($this->values);
    }

    /**
     * @return \ArrayIterator
     */
    public function getIterator()
    {
        return new \ArrayIterator($this->values);
    }

    /**
     * Clone accessor and ensure that it state is updated.
     */
    public function __clone()
    {
        $this->solidState = true;
        $this->atomics = [];
    }

    /**
     * @return array
     */
    public function __debugInfo()
    {
        return [
            'values'  => $this->packValue(),
            'atomics' => $this->buildAtomics('@scalarArray'),
        ];
    }

    /**
     * @return array
     */
    public function jsonSerialize()
    {
        return $this->packValue();
    }

    /**
     * Add values matched with filter.
     *
     * @param mixed $values
     */
    protected function addValues($values)
    {
        if (!is_array($values) && !$values instanceof \Traversable) {
            //Unable to process values
            return;
        }

        foreach ($values as $value) {
            //Passing every value thought the filter
            $value = $this->filterValue($value);
            if (!is_null($value)) {
                $this->values[] = $value;
            }
        }
    }

    /**
     * Filter value, MUST return null if value is invalid.
     *
     * @param mixed $value
     *
     * @return mixed|null
     */
    abstract protected function filterValue($value);
}

1		<?php
2		/**
3		* components
4		*
5		* @author Wolfy-J
6		*/
7		namespace Spiral\ODM\Accessors;
8
9		use Spiral\Models\Traits\SolidableTrait;
10		use Spiral\ODM\CompositableInterface;
11
12		/**
13		* Provides ability to perform scalar operations on arrays.
14		*
15		* Attention, array will be saved as one big $set operation in case when multiple atomic
16		* operations applied to it (not supported by Mongo).
17		*/
18		abstract class AbstractArray implements CompositableInterface, \Countable, \IteratorAggregate
19		{
20		use SolidableTrait;
21
22		/**
23		* @var array
24		*/
25		protected $values = [];
26
27		/**
28		* Low level atomic operations.
29		*
30		* @var array
31		*/
32		protected $atomics = [];
33
34		/**
35		* @param mixed $values
36		*/
37		public function __construct($values)
38		{
39		if (!is_array($values)) {
40		//Since we have to overwrite non array field
41		$this->solidState = true;
42		}
43
44		$this->addValues($values);
45		}
46
47		/**
48		* Check if value presented in array.
49		*
50		* @param mixed $needle
51		* @param bool $strict
52		*
53		* @return bool
54		*/
55		public function has($needle, bool $strict = true): bool
56		{
57		foreach ($this->values as $value) {
58		if ($strict && $value === $needle) {
59		return true;
60		}
61
62		if ($strict && $value == $needle) {
63		return true;
64		}
65		}
66
67		return false;
68		}
69
70		/**
71		* Alias for atomic operation $push. Only values passed type filter will be added.
72		*
73		* @param mixed $value
74		*
75		* @return self\|$this
76		*/
77		public function push($value): AbstractArray
78		{
79		$value = $this->filterValue($value);
80		if (is_null($value)) {
81		return $this;
82		}
83
84		array_push($this->values, $value);
85		$this->atomics['$push']['$each'][] = $value;
86
87		return $this;
88		}
89
90		/**
91		* Alias for atomic operation $addToSet. Only values passed type filter will be added.
92		*
93		* @param mixed $value
94		*
95		* @return self\|$this
96		*/
97	View Code Duplication	public function add($value): AbstractArray
		0 ignored issues – show Duplication introduced 2016-12-24 20:50 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...
98		{
99		$value = $this->filterValue($value);
100		if (is_null($value)) {
101		return $this;
102		}
103
104		if (!in_array($value, $this->values)) {
105		array_push($this->values, $value);
106		}
107
108		$this->atomics['$addToSet']['$each'][] = $value;
109
110		return $this;
111		}
112
113		/**
114		* Alias for atomic operation $pull. Only values passed type filter will be added.
115		*
116		* @param mixed $value
117		*
118		* @return self\|$this
119		*/
120	View Code Duplication	public function pull($value): AbstractArray
		0 ignored issues – show Duplication introduced 2016-12-24 20:50 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...
121		{
122		$value = $this->filterValue($value);
123		if (is_null($value)) {
124		return $this;
125		}
126
127		//Removing values from array (non strict)
128		$this->values = array_filter($this->values, function ($item) use ($value) {
129		return $item != $value;
130		});
131
132		$this->atomics['$pull']['$in'][] = $value;
133
134		return $this;
135		}
136
137		/**
138		* {@inheritdoc}
139		*/
140		public function stateValue($data)
141		{
142		//Manually altered arrays must always end in solid state
143		$this->solidState = true;
144
145		//Flushing existed values
146		$this->values = [];
147
148		//Pushing filtered values in array
149		$this->addValues($data);
150		}
151
152		/**
153		* {@inheritdoc}
154		*/
155		public function hasUpdates(): bool
156		{
157		return !empty($this->atomics);
158		}
159
160		/**
161		* {@inheritdoc}
162		*/
163		public function flushUpdates()
164		{
165		$this->atomics = [];
166		}
167
168		/**
169		* {@inheritdoc}
170		*/
171		public function buildAtomics(string $container = ''): array
172		{
173		if (!$this->hasUpdates()) {
174		return [];
175		}
176
177		//Mongo does not support multiple operations for one field, switching to $set (make sure it's
178		//reasonable)
179	View Code Duplication	if ($this->solidState \|\| count($this->atomics) > 1) {
		0 ignored issues – show Duplication introduced 2016-12-26 14:24 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
180		//We don't care about atomics in solid state
181		return ['$set' => [$container => $this->packValue()]];
182		}
183
184		$atomics = [];
185		foreach ($this->atomics as $operation => $values) {
186		$atomics[$operation] = [$container => $values];
187		}
188
189		return $atomics;
190		}
191
192		/**
193		* @return array
194		*/
195		public function packValue(): array
196		{
197		return $this->values;
198		}
199
200		/**
201		* @return int
202		*/
203		public function count(): int
204		{
205		return count($this->values);
206		}
207
208		/**
209		* @return \ArrayIterator
210		*/
211		public function getIterator()
212		{
213		return new \ArrayIterator($this->values);
214		}
215
216		/**
217		* Clone accessor and ensure that it state is updated.
218		*/
219		public function __clone()
220		{
221		$this->solidState = true;
222		$this->atomics = [];
223		}
224
225		/**
226		* @return array
227		*/
228		public function __debugInfo()
229		{
230		return [
231		'values' => $this->packValue(),
232		'atomics' => $this->buildAtomics('@scalarArray'),
233		];
234		}
235
236		/**
237		* @return array
238		*/
239		public function jsonSerialize()
240		{
241		return $this->packValue();
242		}
243
244		/**
245		* Add values matched with filter.
246		*
247		* @param mixed $values
248		*/
249		protected function addValues($values)
250		{
251		if (!is_array($values) && !$values instanceof \Traversable) {
252		//Unable to process values
253		return;
254		}
255
256		foreach ($values as $value) {
257		//Passing every value thought the filter
258		$value = $this->filterValue($value);
259		if (!is_null($value)) {
260		$this->values[] = $value;
261		}
262		}
263		}
264
265		/**
266		* Filter value, MUST return null if value is invalid.
267		*
268		* @param mixed $value
269		*
270		* @return mixed\|null
271		*/
272		abstract protected function filterValue($value);
273		}

spiral / components

Branch — feature/pre-split (6ce9be)

AbstractArray::push() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like