DocumentCompositor::packValues() - 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

DocumentCompositor::packValues() A

↳ Parent: DocumentCompositor

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
c	0
b	0
f	0
cc	2
eloc	5
nc	2
nop	1
rs	9.6666

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

use Spiral\Models\PublishableInterface;
use Spiral\Models\Traits\SolidableTrait;
use Spiral\ODM\CompositableInterface;
use Spiral\ODM\Exceptions\CompositorException;
use Spiral\ODM\ODMInterface;

/**
 * Provides ability to composite multiple documents in a form of array.
 *
 * Attention, composition will be saved as one big $set operation in case when multiple atomic
 * operations applied to it (not supported by Mongo).
 */
class DocumentCompositor implements
    CompositableInterface,
    PublishableInterface,
    \Countable,
    \IteratorAggregate
{
    use SolidableTrait;

    /**
     * Lazy conversion from array to CompositableInterface (ie DocumentEntity).
     *
     * @var CompositableInterface[]
     */
    private $entities = [];

    /**
     * Set of atomic operation applied to whole composition set.
     *
     * @var array
     */
    protected $atomics = [];

    /**
     * @var string
     */
    protected $class;

    /**
     * @invisible
     * @var ODMInterface
     */
    protected $odm;

    /**
     * @param string                        $class
     * @param array|CompositableInterface[] $data
     * @param ODMInterface                  $odm
     */
    public function __construct(string $class, array $data, ODMInterface $odm)
    {
        $this->class = $class;
        $this->odm = $odm;

        //Instantiating composed entities (no data filtering)
        $this->entities = $this->createEntities($data, false);
    }

    /**
     * Get primary composition class.
     *
     * @return string
     */
    public function getClass(): string
    {
        return $this->class;
    }

    /**
     * Push new entity to end of set.
     *
     * Be aware that any added entity will be cloned in order to detach it from passed object:
     * $user->addresses->push($address);
     * $address->city = 'Minsk'; //this will have no effect of $user->addresses
     *
     * @param CompositableInterface $entity
     *
     * @return DocumentCompositor
     *
     * @throws CompositorException When entity is invalid type.
     */
    public function push(CompositableInterface $entity): DocumentCompositor

    {
        //Detaching entity
        $entity = clone $entity;

        $this->assertSupported($entity);

        $this->entities[] = $entity;
        $this->atomics['$push'][] = $entity;

        return $this;
    }

    /**
     * Add entity to set, only one instance of document must be presented.
     *
     * Be aware that any added entity will be cloned in order to detach it from passed object:
     * $user->addresses->add($address);
     * $address->city = 'Minsk'; //this will have no effect of $user->addresses
     *
     * @param CompositableInterface $entity
     *
     * @return DocumentCompositor
     *
     * @throws CompositorException When entity is invalid type.
     */
    public function add(CompositableInterface $entity): DocumentCompositor

    {
        //Detaching entity
        $entity = clone $entity;

        $this->assertSupported($entity);

        if (!$this->has($entity)) {
            $this->entities[] = $entity;
        }

        $this->atomics['$addToSet'][] = $entity;

        return $this;
    }

    /**
     * Pull mathced entities from composition.
     *
     * $user->addresses->pull($address);
     *
     * @param CompositableInterface $entity
     *
     * @return DocumentCompositor
     */
    public function pull(CompositableInterface $entity): DocumentCompositor

    {
        //Passing true to get all entity offsets
        $targets = $this->find($entity, true);

        foreach ($targets as $offset => $target) {
            unset($this->entities[$offset]);
        }

        $this->atomics['$pull'][] = clone $entity;

        return $this;
    }

    /**
     * Check if composition contains desired document or document matching query.
     *
     * Example:
     * $user->cards->has(['active' => true]);
     * $user->cards->has(new Card(...));
     *
     * @param CompositableInterface|array $query
     *
     * @return bool
     */
    public function has($query): bool
    {
        return !empty($this->findOne($query));
    }

    /**
     * Find document in composition based on given entity or matching query.
     *
     * $user->cards->findOne(['active' => true]);
     * $user->cards->findOne(new Card(...));
     *
     * @param CompositableInterface|array $query
     *
     * @return CompositableInterface|null
     */
    public function findOne($query)
    {
        $entities = $this->find($query);
        if (empty($entities)) {
            return null;
        }

        return current($entities);
    }

    /**
     * Find all entities matching given query (query can be provided in a form of
     * CompositableInterface).
     *
     * $user->cards->find(['active' => true]);
     * $user->cards->find(new Card(...));     //Attention, this will likely to return only on match
     *
     * @param CompositableInterface|array $query
     * @param bool                        $preserveKeys Set to true to keep original offsets.
     *
     * @return CompositableInterface[]
     */
    public function find($query, bool $preserveKeys = false): array
    {
        if ($query instanceof CompositableInterface) {
            //Intersecting using values
            $query = $query->packValue();
        }

        $result = [];
        foreach ($this->entities as $offset => $entity) {
            //Looking for entities using key intersection
            if (empty($query) || (array_intersect_assoc($entity->packValue(), $query) == $query)) {
                $result[$offset] = $entity;
            }
        }

        if (!$preserveKeys) {
            return array_values($result);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     *
     * Be aware that any added entity will be cloned in order to detach it from passed object:
     * $user->addresses->mountValue([$address]);
     * $address->city = 'Minsk'; //this will have no effect of $user->addresses
     */
    public function stateValue($data)
    {
        //Manually altered compositions must always end in solid state
        $this->solidState = true;
        $this->entities = [];

        if (!is_array($data)) {
            //Unable to initiate
            return;
        }

        //Instantiating entities (with filtering enabled)
        $this->entities = $this->createEntities($data, true);
    }

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

    /**
     * {@inheritdoc}
     *
     * @param bool $changedEntities Reference, will be set to true if any of entities changed
     *                              internally.
     */
    public function hasUpdates(bool &$changedEntities = null): bool
    {
        foreach ($this->entities as $entity) {
            if ($entity->hasUpdates()) {
                $changedEntities = true;

                return true;
            }
        }

        return !empty($this->atomics);
    }

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

        foreach ($this->entities as $entity) {
            $entity->flushUpdates();
        }
    }

    /**
     * {@inheritdoc}
     */
    public function buildAtomics(string $container = ''): array
    {
        //$changedEntities will be set to true if any of internal entities were changed directly
        if (!$this->hasUpdates($changedEntities)) {
            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 || $changedEntities) {

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

        //Aggregate composition specific atomics (pull, push, addToSet) and entity specific atomics
        $atomics = [];

        //If entity already presented in any of composition atomics we are not insluding it's own
        //offset specific operations into atomics
        $excluded = [];

        foreach ($this->atomics as $operation => $items) {
            //Collect all atomics handled on
            $excluded = array_merge($excluded, $items);

            //Into array form
            $atomics[$operation][$container][$operation == '$pull' ? '$in' : '$each'] = $this->packValues($items);
        }

        //Document specific atomic operations (excluding document which are colliding with composition
        //specific operations)
        foreach ($this->entities as $offset => $document) {
            if (in_array($document, $excluded)) {
                //Handler on higher level
                continue;
            }

            $atomics = array_merge(
                $atomics,
                $document->buildAtomics((!empty($container) ? $container . '.' : '') . $offset)
            );
        }

        return $atomics;
    }

    /**
     * Packs only public values of all nested documents.
     *
     * @return array
     */
    public function publicFields(): array
    {
        $result = [];
        foreach ($this->entities as $entity) {
            if ($entity instanceof PublishableInterface) {
                $result[] = $entity->publicFields();
            }
        }

        return $result;
    }

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

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

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

    /**
     * Cloning will be called when object will be embedded into another document.
     */
    public function __clone()
    {
        $this->solidState = true;
        $this->atomics = [];

        //De-serialize composition in order to ensure that all compositions are recreated
        $this->stateValue($this->packValue());
    }

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

    /**
     * Assert that given entity supported by composition.
     *
     * @param mixed $entity
     *
     * @throws CompositorException
     */
    protected function assertSupported($entity)
    {
        if (!is_object($entity) || !is_a($entity, $this->class)) {
            throw new CompositorException(sprintf(
                "Only instances of '%s' supported, '%s' given",
                $this->class,
                is_object($entity) ? get_class($entity) : gettype($entity)
            ));
        }
    }

    /**
     * Instantiate every entity in composition.
     *
     * @param array $data
     * @param bool  $filter
     *
     * @return CompositableInterface[]
     *
     * @throws CompositorException
     */
    private function createEntities(array $data, bool $filter = true): array
    {
        $result = [];
        foreach ($data as $item) {
            if ($item instanceof CompositableInterface) {
                $this->assertSupported($item);

                //Always clone to detach from original value
                $result[] = clone $item;
            } else {
                $result[] = $this->odm->instantiate($this->class, $item, $filter);
            }
        }

        return $result;
    }

    /**
     * Pack multiple entities into array form.
     *
     * @param CompositableInterface[] $entities
     *
     * @return array
     */
    private function packValues(array $entities): array
    {
        $result = [];
        foreach ($entities as $entity) {
            $result[] = $entity->packValue();
        }

        return $result;
    }
}

1		<?php
2		/**
3		* components
4		*
5		* @author Wolfy-J
6		*/
7		namespace Spiral\ODM\Entities;
8
9		use Spiral\Models\PublishableInterface;
10		use Spiral\Models\Traits\SolidableTrait;
11		use Spiral\ODM\CompositableInterface;
12		use Spiral\ODM\Exceptions\CompositorException;
13		use Spiral\ODM\ODMInterface;
14
15		/**
16		* Provides ability to composite multiple documents in a form of array.
17		*
18		* Attention, composition will be saved as one big $set operation in case when multiple atomic
19		* operations applied to it (not supported by Mongo).
20		*/
21		class DocumentCompositor implements
22		CompositableInterface,
23		PublishableInterface,
24		\Countable,
25		\IteratorAggregate
26		{
27		use SolidableTrait;
28
29		/**
30		* Lazy conversion from array to CompositableInterface (ie DocumentEntity).
31		*
32		* @var CompositableInterface[]
33		*/
34		private $entities = [];
35
36		/**
37		* Set of atomic operation applied to whole composition set.
38		*
39		* @var array
40		*/
41		protected $atomics = [];
42
43		/**
44		* @var string
45		*/
46		protected $class;
47
48		/**
49		* @invisible
50		* @var ODMInterface
51		*/
52		protected $odm;
53
54		/**
55		* @param string $class
56		* @param array\|CompositableInterface[] $data
57		* @param ODMInterface $odm
58		*/
59		public function __construct(string $class, array $data, ODMInterface $odm)
60		{
61		$this->class = $class;
62		$this->odm = $odm;
63
64		//Instantiating composed entities (no data filtering)
65		$this->entities = $this->createEntities($data, false);
66		}
67
68		/**
69		* Get primary composition class.
70		*
71		* @return string
72		*/
73		public function getClass(): string
74		{
75		return $this->class;
76		}
77
78		/**
79		* Push new entity to end of set.
80		*
81		* Be aware that any added entity will be cloned in order to detach it from passed object:
82		* $user->addresses->push($address);
83		* $address->city = 'Minsk'; //this will have no effect of $user->addresses
84		*
85		* @param CompositableInterface $entity
86		*
87		* @return DocumentCompositor
88		*
89		* @throws CompositorException When entity is invalid type.
90		*/
91	View Code Duplication	public function push(CompositableInterface $entity): DocumentCompositor
		0 ignored issues – show Duplication introduced 2016-12-26 14:24 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...
92		{
93		//Detaching entity
94		$entity = clone $entity;
95
96		$this->assertSupported($entity);
97
98		$this->entities[] = $entity;
99		$this->atomics['$push'][] = $entity;
100
101		return $this;
102		}
103
104		/**
105		* Add entity to set, only one instance of document must be presented.
106		*
107		* Be aware that any added entity will be cloned in order to detach it from passed object:
108		* $user->addresses->add($address);
109		* $address->city = 'Minsk'; //this will have no effect of $user->addresses
110		*
111		* @param CompositableInterface $entity
112		*
113		* @return DocumentCompositor
114		*
115		* @throws CompositorException When entity is invalid type.
116		*/
117	View Code Duplication	public function add(CompositableInterface $entity): DocumentCompositor
		0 ignored issues – show Duplication introduced 2016-12-26 14:24 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...
118		{
119		//Detaching entity
120		$entity = clone $entity;
121
122		$this->assertSupported($entity);
123
124		if (!$this->has($entity)) {
125		$this->entities[] = $entity;
126		}
127
128		$this->atomics['$addToSet'][] = $entity;
129
130		return $this;
131		}
132
133		/**
134		* Pull mathced entities from composition.
135		*
136		* $user->addresses->pull($address);
137		*
138		* @param CompositableInterface $entity
139		*
140		* @return DocumentCompositor
141		*/
142	View Code Duplication	public function pull(CompositableInterface $entity): DocumentCompositor
		0 ignored issues – show Duplication introduced 2016-12-26 14:24 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...
143		{
144		//Passing true to get all entity offsets
145		$targets = $this->find($entity, true);
146
147		foreach ($targets as $offset => $target) {
148		unset($this->entities[$offset]);
149		}
150
151		$this->atomics['$pull'][] = clone $entity;
152
153		return $this;
154		}
155
156		/**
157		* Check if composition contains desired document or document matching query.
158		*
159		* Example:
160		* $user->cards->has(['active' => true]);
161		* $user->cards->has(new Card(...));
162		*
163		* @param CompositableInterface\|array $query
164		*
165		* @return bool
166		*/
167		public function has($query): bool
168		{
169		return !empty($this->findOne($query));
170		}
171
172		/**
173		* Find document in composition based on given entity or matching query.
174		*
175		* $user->cards->findOne(['active' => true]);
176		* $user->cards->findOne(new Card(...));
177		*
178		* @param CompositableInterface\|array $query
179		*
180		* @return CompositableInterface\|null
181		*/
182		public function findOne($query)
183		{
184		$entities = $this->find($query);
185		if (empty($entities)) {
186		return null;
187		}
188
189		return current($entities);
190		}
191
192		/**
193		* Find all entities matching given query (query can be provided in a form of
194		* CompositableInterface).
195		*
196		* $user->cards->find(['active' => true]);
197		* $user->cards->find(new Card(...)); //Attention, this will likely to return only on match
198		*
199		* @param CompositableInterface\|array $query
200		* @param bool $preserveKeys Set to true to keep original offsets.
201		*
202		* @return CompositableInterface[]
203		*/
204		public function find($query, bool $preserveKeys = false): array
205		{
206		if ($query instanceof CompositableInterface) {
207		//Intersecting using values
208		$query = $query->packValue();
209		}
210
211		$result = [];
212		foreach ($this->entities as $offset => $entity) {
213		//Looking for entities using key intersection
214		if (empty($query) \|\| (array_intersect_assoc($entity->packValue(), $query) == $query)) {
215		$result[$offset] = $entity;
216		}
217		}
218
219		if (!$preserveKeys) {
220		return array_values($result);
221		}
222
223		return $result;
224		}
225
226		/**
227		* {@inheritdoc}
228		*
229		* Be aware that any added entity will be cloned in order to detach it from passed object:
230		* $user->addresses->mountValue([$address]);
231		* $address->city = 'Minsk'; //this will have no effect of $user->addresses
232		*/
233		public function stateValue($data)
234		{
235		//Manually altered compositions must always end in solid state
236		$this->solidState = true;
237		$this->entities = [];
238
239		if (!is_array($data)) {
240		//Unable to initiate
241		return;
242		}
243
244		//Instantiating entities (with filtering enabled)
245		$this->entities = $this->createEntities($data, true);
246		}
247
248		/**
249		* {@inheritdoc}
250		*/
251		public function packValue(): array
252		{
253		return $this->packValues($this->entities);
254		}
255
256		/**
257		* {@inheritdoc}
258		*
259		* @param bool $changedEntities Reference, will be set to true if any of entities changed
260		* internally.
261		*/
262		public function hasUpdates(bool &$changedEntities = null): bool
263		{
264		foreach ($this->entities as $entity) {
265		if ($entity->hasUpdates()) {
266		$changedEntities = true;
267
268		return true;
269		}
270		}
271
272		return !empty($this->atomics);
273		}
274
275		/**
276		* {@inheritdoc}
277		*/
278		public function flushUpdates()
279		{
280		$this->atomics = [];
281
282		foreach ($this->entities as $entity) {
283		$entity->flushUpdates();
284		}
285		}
286
287		/**
288		* {@inheritdoc}
289		*/
290		public function buildAtomics(string $container = ''): array
291		{
292		//$changedEntities will be set to true if any of internal entities were changed directly
293		if (!$this->hasUpdates($changedEntities)) {
294		return [];
295		}
296
297		//Mongo does not support multiple operations for one field, switching to $set (make sure it's
298		//reasonable)
299	View Code Duplication	if ($this->solidState \|\| count($this->atomics) > 1 \|\| $changedEntities) {
		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...
300		//We don't care about atomics in solid state
301		return ['$set' => [$container => $this->packValue()]];
302		}
303
304		//Aggregate composition specific atomics (pull, push, addToSet) and entity specific atomics
305		$atomics = [];
306
307		//If entity already presented in any of composition atomics we are not insluding it's own
308		//offset specific operations into atomics
309		$excluded = [];
310
311		foreach ($this->atomics as $operation => $items) {
312		//Collect all atomics handled on
313		$excluded = array_merge($excluded, $items);
314
315		//Into array form
316		$atomics[$operation][$container][$operation == '$pull' ? '$in' : '$each'] = $this->packValues($items);
317		}
318
319		//Document specific atomic operations (excluding document which are colliding with composition
320		//specific operations)
321		foreach ($this->entities as $offset => $document) {
322		if (in_array($document, $excluded)) {
323		//Handler on higher level
324		continue;
325		}
326
327		$atomics = array_merge(
328		$atomics,
329		$document->buildAtomics((!empty($container) ? $container . '.' : '') . $offset)
330		);
331		}
332
333		return $atomics;
334		}
335
336		/**
337		* Packs only public values of all nested documents.
338		*
339		* @return array
340		*/
341		public function publicFields(): array
342		{
343		$result = [];
344		foreach ($this->entities as $entity) {
345		if ($entity instanceof PublishableInterface) {
346		$result[] = $entity->publicFields();
347		}
348		}
349
350		return $result;
351		}
352
353		/**
354		* {@inheritdoc}
355		*/
356		public function jsonSerialize()
357		{
358		return $this->publicFields();
359		}
360
361		/**
362		* @return int
363		*/
364		public function count(): int
365		{
366		return count($this->entities);
367		}
368
369		/**
370		* @return \ArrayIterator
371		*/
372		public function getIterator(): \ArrayIterator
373		{
374		return new \ArrayIterator($this->entities);
375		}
376
377		/**
378		* Cloning will be called when object will be embedded into another document.
379		*/
380		public function __clone()
381		{
382		$this->solidState = true;
383		$this->atomics = [];
384
385		//De-serialize composition in order to ensure that all compositions are recreated
386		$this->stateValue($this->packValue());
387		}
388
389		/**
390		* @return array
391		*/
392		public function __debugInfo()
393		{
394		return [
395		'entities' => array_values($this->entities),
396		'atomics' => $this->buildAtomics('@compositor')
397		];
398		}
399
400		/**
401		* Assert that given entity supported by composition.
402		*
403		* @param mixed $entity
404		*
405		* @throws CompositorException
406		*/
407		protected function assertSupported($entity)
408		{
409		if (!is_object($entity) \|\| !is_a($entity, $this->class)) {
410		throw new CompositorException(sprintf(
411		"Only instances of '%s' supported, '%s' given",
412		$this->class,
413		is_object($entity) ? get_class($entity) : gettype($entity)
414		));
415		}
416		}
417
418		/**
419		* Instantiate every entity in composition.
420		*
421		* @param array $data
422		* @param bool $filter
423		*
424		* @return CompositableInterface[]
425		*
426		* @throws CompositorException
427		*/
428		private function createEntities(array $data, bool $filter = true): array
429		{
430		$result = [];
431		foreach ($data as $item) {
432		if ($item instanceof CompositableInterface) {
433		$this->assertSupported($item);
434
435		//Always clone to detach from original value
436		$result[] = clone $item;
437		} else {
438		$result[] = $this->odm->instantiate($this->class, $item, $filter);
439		}
440		}
441
442		return $result;
443		}
444
445		/**
446		* Pack multiple entities into array form.
447		*
448		* @param CompositableInterface[] $entities
449		*
450		* @return array
451		*/
452		private function packValues(array $entities): array
453		{
454		$result = [];
455		foreach ($entities as $entity) {
456		$result[] = $entity->packValue();
457		}
458
459		return $result;
460		}
461		}

spiral / components

Branch — feature/pre-split (6ce9be)

DocumentCompositor::packValues() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like