CollectionPersister::getPathAndParent() - Code Metrics - Inspection of "Merge pull request #1519 from malarzm/gh1271" - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2f1eb7...23b3b5 )

by Maciej

created 2016-12-27 22:08 UTC

CollectionPersister::getPathAndParent() A

↳ Parent: CollectionPersister

Complexity

Conditions	4
Paths	6

Size

Total Lines	20
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	16
CRAP Score	4.0032

Importance

Changes

Metric	Value
dl	0
loc	20
ccs	16
cts	17
cp	0.9412
rs	9.2
c	0
b	0
f	0
cc	4
eloc	15
nc	6
nop	1
crap	4.0032

<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <http://www.doctrine-project.org>.
 */

namespace Doctrine\ODM\MongoDB\Persisters;

use Doctrine\ODM\MongoDB\DocumentManager;
use Doctrine\ODM\MongoDB\LockException;
use Doctrine\ODM\MongoDB\Mapping\ClassMetadataInfo;
use Doctrine\ODM\MongoDB\PersistentCollection\PersistentCollectionInterface;
use Doctrine\ODM\MongoDB\UnitOfWork;
use Doctrine\ODM\MongoDB\Utility\CollectionHelper;

/**
 * The CollectionPersister is responsible for persisting collections of embedded
 * or referenced documents. When a PersistentCollection is scheduledForDeletion
 * in the UnitOfWork by calling PersistentCollection::clear() or is
 * de-referenced in the domain application code, CollectionPersister::delete()
 * will be called. When documents within the PersistentCollection are added or
 * removed, CollectionPersister::update() will be called, which may set the
 * entire collection or delete/insert individual elements, depending on the
 * mapping strategy.
 *
 * @since       1.0
 */
class CollectionPersister
{
    /**
     * The DocumentManager instance.
     *
     * @var DocumentManager
     */
    private $dm;

    /**
     * The PersistenceBuilder instance.
     *
     * @var PersistenceBuilder
     */
    private $pb;

    /**
     * Constructs a new CollectionPersister instance.
     *
     * @param DocumentManager $dm
     * @param PersistenceBuilder $pb
     * @param UnitOfWork $uow
     */
    public function __construct(DocumentManager $dm, PersistenceBuilder $pb, UnitOfWork $uow)
    {
        $this->dm = $dm;
        $this->pb = $pb;
        $this->uow = $uow;
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Deletes a PersistentCollection instance completely from a document using $unset.
     *
     * @param PersistentCollectionInterface $coll
     * @param array $options
     */
    public function delete(PersistentCollectionInterface $coll, array $options)
    {
        $mapping = $coll->getMapping();
        if ($mapping['isInverseSide']) {
            return; // ignore inverse side
        }
        if (CollectionHelper::isAtomic($mapping['strategy'])) {
            throw new \UnexpectedValueException($mapping['strategy'] . ' delete collection strategy should have been handled by DocumentPersister. Please report a bug in issue tracker');
        }
        list($propertyPath, $parent) = $this->getPathAndParent($coll);
        $query = array('$unset' => array($propertyPath => true));
        $this->executeQuery($parent, $query, $options);
    }

    /**
     * Updates a PersistentCollection instance deleting removed rows and
     * inserting new rows.
     *
     * @param PersistentCollectionInterface $coll
     * @param array $options
     */
    public function update(PersistentCollectionInterface $coll, array $options)
    {
        $mapping = $coll->getMapping();

        if ($mapping['isInverseSide']) {
            return; // ignore inverse side
        }

        switch ($mapping['strategy']) {
            case ClassMetadataInfo::STORAGE_STRATEGY_ATOMIC_SET:
            case ClassMetadataInfo::STORAGE_STRATEGY_ATOMIC_SET_ARRAY:
                throw new \UnexpectedValueException($mapping['strategy'] . ' update collection strategy should have been handled by DocumentPersister. Please report a bug in issue tracker');

            case ClassMetadataInfo::STORAGE_STRATEGY_SET:
            case ClassMetadataInfo::STORAGE_STRATEGY_SET_ARRAY:
                $this->setCollection($coll, $options);
                break;

            case ClassMetadataInfo::STORAGE_STRATEGY_ADD_TO_SET:
            case ClassMetadataInfo::STORAGE_STRATEGY_PUSH_ALL:
                $coll->initialize();
                $this->deleteElements($coll, $options);
                $this->insertElements($coll, $options);
                break;

            default:
                throw new \UnexpectedValueException('Unsupported collection strategy: ' . $mapping['strategy']);
        }
    }

    /**
     * Sets a PersistentCollection instance.
     *
     * This method is intended to be used with the "set" or "setArray"
     * strategies. The "setArray" strategy will ensure that the collection is
     * set as a BSON array, which means the collection elements will be
     * reindexed numerically before storage.
     *
     * @param PersistentCollectionInterface $coll
     * @param array $options
     */
    private function setCollection(PersistentCollectionInterface $coll, array $options)
    {
        list($propertyPath, $parent) = $this->getPathAndParent($coll);
        $coll->initialize();
        $mapping = $coll->getMapping();
        $setData = $this->pb->prepareAssociatedCollectionValue($coll, CollectionHelper::usesSet($mapping['strategy']));
        $query = array('$set' => array($propertyPath => $setData));
        $this->executeQuery($parent, $query, $options);
    }

    /**
     * Deletes removed elements from a PersistentCollection instance.
     *
     * This method is intended to be used with the "pushAll" and "addToSet"
     * strategies.
     *
     * @param PersistentCollectionInterface $coll
     * @param array $options
     */
    private function deleteElements(PersistentCollectionInterface $coll, array $options)
    {
        $deleteDiff = $coll->getDeleteDiff();

        if (empty($deleteDiff)) {
            return;
        }

        list($propertyPath, $parent) = $this->getPathAndParent($coll);

        $query = array('$unset' => array());

        foreach ($deleteDiff as $key => $document) {
            $query['$unset'][$propertyPath . '.' . $key] = true;
        }

        $this->executeQuery($parent, $query, $options);

        /**
         * @todo This is a hack right now because we don't have a proper way to
         * remove an element from an array by its key. Unsetting the key results
         * in the element being left in the array as null so we have to pull
         * null values.
         */
        $this->executeQuery($parent, array('$pull' => array($propertyPath => null)), $options);
    }

    /**
     * Inserts new elements for a PersistentCollection instance.
     *
     * This method is intended to be used with the "pushAll" and "addToSet"
     * strategies.
     *
     * @param PersistentCollectionInterface $coll
     * @param array $options
     */
    private function insertElements(PersistentCollectionInterface $coll, array $options)
    {
        $insertDiff = $coll->getInsertDiff();

        if (empty($insertDiff)) {
            return;
        }

        $mapping = $coll->getMapping();
        list($propertyPath, $parent) = $this->getPathAndParent($coll);

        $pb = $this->pb;

        $callback = isset($mapping['embedded'])
            ? function($v) use ($pb, $mapping) { return $pb->prepareEmbeddedDocumentValue($mapping, $v); }
            : function($v) use ($pb, $mapping) { return $pb->prepareReferencedDocumentValue($mapping, $v); };

        $value = array_values(array_map($callback, $insertDiff));

        if ($mapping['strategy'] === ClassMetadataInfo::STORAGE_STRATEGY_ADD_TO_SET) {
            $value = array('$each' => $value);
        }

        $query = array('$' . $mapping['strategy'] => array($propertyPath => $value));

        $this->executeQuery($parent, $query, $options);
    }

    /**
     * Gets the parent information for a given PersistentCollection. It will
     * retrieve the top-level persistent Document that the PersistentCollection
     * lives in. We can use this to issue queries when updating a
     * PersistentCollection that is multiple levels deep inside an embedded
     * document.
     *
     *     <code>
     *     list($path, $parent) = $this->getPathAndParent($coll)
     *     </code>
     *
     * @param PersistentCollectionInterface $coll
     * @return array $pathAndParent
     */
    private function getPathAndParent(PersistentCollectionInterface $coll)
    {
        $mapping = $coll->getMapping();
        $fields = array();
        $parent = $coll->getOwner();
        while (null !== ($association = $this->uow->getParentAssociation($parent))) {
            list($m, $owner, $field) = $association;
            if (isset($m['reference'])) {
                break;
            }
            $parent = $owner;
            $fields[] = $field;
        }
        $propertyPath = implode('.', array_reverse($fields));
        $path = $mapping['name'];
        if ($propertyPath) {
            $path = $propertyPath . '.' . $path;
        }
        return array($path, $parent);
    }

    /**
     * Executes a query updating the given document.
     *
     * @param object $document
     * @param array $newObj
     * @param array $options
     */
    private function executeQuery($document, array $newObj, array $options)
    {
        $className = get_class($document);
        $class = $this->dm->getClassMetadata($className);
        $id = $class->getDatabaseIdentifierValue($this->uow->getDocumentIdentifier($document));
        $query = array('_id' => $id);
        if ($class->isVersioned) {
            $query[$class->versionField] = $class->reflFields[$class->versionField]->getValue($document);
        }
        $collection = $this->dm->getDocumentCollection($className);
        $result = $collection->update($query, $newObj, $options);
        if ($class->isVersioned && ! $result['n']) {
            throw LockException::lockFailed($document);
        }
    }
}


1		<?php
2		/*
3		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
5		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
6		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
7		* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
8		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
9		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
10		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
11		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
12		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
13		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14		*
15		* This software consists of voluntary contributions made by many individuals
16		* and is licensed under the MIT license. For more information, see
17		* <http://www.doctrine-project.org>.
18		*/
19
20		namespace Doctrine\ODM\MongoDB\Persisters;
21
22		use Doctrine\ODM\MongoDB\DocumentManager;
23		use Doctrine\ODM\MongoDB\LockException;
24		use Doctrine\ODM\MongoDB\Mapping\ClassMetadataInfo;
25		use Doctrine\ODM\MongoDB\PersistentCollection\PersistentCollectionInterface;
26		use Doctrine\ODM\MongoDB\UnitOfWork;
27		use Doctrine\ODM\MongoDB\Utility\CollectionHelper;
28
29		/**
30		* The CollectionPersister is responsible for persisting collections of embedded
31		* or referenced documents. When a PersistentCollection is scheduledForDeletion
32		* in the UnitOfWork by calling PersistentCollection::clear() or is
33		* de-referenced in the domain application code, CollectionPersister::delete()
34		* will be called. When documents within the PersistentCollection are added or
35		* removed, CollectionPersister::update() will be called, which may set the
36		* entire collection or delete/insert individual elements, depending on the
37		* mapping strategy.
38		*
39		* @since 1.0
40		*/
41		class CollectionPersister
42		{
43		/**
44		* The DocumentManager instance.
45		*
46		* @var DocumentManager
47		*/
48		private $dm;
49
50		/**
51		* The PersistenceBuilder instance.
52		*
53		* @var PersistenceBuilder
54		*/
55		private $pb;
56
57		/**
58		* Constructs a new CollectionPersister instance.
59		*
60		* @param DocumentManager $dm
61		* @param PersistenceBuilder $pb
62		* @param UnitOfWork $uow
63		*/
64	743	public function __construct(DocumentManager $dm, PersistenceBuilder $pb, UnitOfWork $uow)
65		{
66	743	$this->dm = $dm;
67	743	$this->pb = $pb;
68	743	$this->uow = $uow;
		0 ignored issues – show Bug introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report The property `uow` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
69	743	}
70
71		/**
72		* Deletes a PersistentCollection instance completely from a document using $unset.
73		*
74		* @param PersistentCollectionInterface $coll
75		* @param array $options
76		*/
77	35	public function delete(PersistentCollectionInterface $coll, array $options)
78		{
79	35	$mapping = $coll->getMapping();
80	35	if ($mapping['isInverseSide']) {
81		return; // ignore inverse side
82		}
83	35	if (CollectionHelper::isAtomic($mapping['strategy'])) {
84		throw new \UnexpectedValueException($mapping['strategy'] . ' delete collection strategy should have been handled by DocumentPersister. Please report a bug in issue tracker');
85		}
86	35	list($propertyPath, $parent) = $this->getPathAndParent($coll);
87	35	$query = array('$unset' => array($propertyPath => true));
88	35	$this->executeQuery($parent, $query, $options);
89	34	}
90
91		/**
92		* Updates a PersistentCollection instance deleting removed rows and
93		* inserting new rows.
94		*
95		* @param PersistentCollectionInterface $coll
96		* @param array $options
97		*/
98	99	public function update(PersistentCollectionInterface $coll, array $options)
99		{
100	99	$mapping = $coll->getMapping();
101
102	99	if ($mapping['isInverseSide']) {
103		return; // ignore inverse side
104		}
105
106	99	switch ($mapping['strategy']) {
107	99	case ClassMetadataInfo::STORAGE_STRATEGY_ATOMIC_SET:
108	99	case ClassMetadataInfo::STORAGE_STRATEGY_ATOMIC_SET_ARRAY:
109		throw new \UnexpectedValueException($mapping['strategy'] . ' update collection strategy should have been handled by DocumentPersister. Please report a bug in issue tracker');
110
111	99	case ClassMetadataInfo::STORAGE_STRATEGY_SET:
112	99	case ClassMetadataInfo::STORAGE_STRATEGY_SET_ARRAY:
113	11	$this->setCollection($coll, $options);
114	11	break;
115
116	89	case ClassMetadataInfo::STORAGE_STRATEGY_ADD_TO_SET:
117	89	case ClassMetadataInfo::STORAGE_STRATEGY_PUSH_ALL:
118	89	$coll->initialize();
119	89	$this->deleteElements($coll, $options);
120	89	$this->insertElements($coll, $options);
121	88	break;
122
123		default:
124		throw new \UnexpectedValueException('Unsupported collection strategy: ' . $mapping['strategy']);
125	98	}
126	98	}
127
128		/**
129		* Sets a PersistentCollection instance.
130		*
131		* This method is intended to be used with the "set" or "setArray"
132		* strategies. The "setArray" strategy will ensure that the collection is
133		* set as a BSON array, which means the collection elements will be
134		* reindexed numerically before storage.
135		*
136		* @param PersistentCollectionInterface $coll
137		* @param array $options
138		*/
139	11	private function setCollection(PersistentCollectionInterface $coll, array $options)
140		{
141	11	list($propertyPath, $parent) = $this->getPathAndParent($coll);
142	11	$coll->initialize();
143	11	$mapping = $coll->getMapping();
144	11	$setData = $this->pb->prepareAssociatedCollectionValue($coll, CollectionHelper::usesSet($mapping['strategy']));
145	11	$query = array('$set' => array($propertyPath => $setData));
146	11	$this->executeQuery($parent, $query, $options);
147	11	}
148
149		/**
150		* Deletes removed elements from a PersistentCollection instance.
151		*
152		* This method is intended to be used with the "pushAll" and "addToSet"
153		* strategies.
154		*
155		* @param PersistentCollectionInterface $coll
156		* @param array $options
157		*/
158	89	private function deleteElements(PersistentCollectionInterface $coll, array $options)
159		{
160	89	$deleteDiff = $coll->getDeleteDiff();
161
162	89	if (empty($deleteDiff)) {
163	69	return;
164		}
165
166	29	list($propertyPath, $parent) = $this->getPathAndParent($coll);
167
168	29	$query = array('$unset' => array());
169
170	29	foreach ($deleteDiff as $key => $document) {
171	29	$query['$unset'][$propertyPath . '.' . $key] = true;
172	29	}
173
174	29	$this->executeQuery($parent, $query, $options);
175
176		/**
177		* @todo This is a hack right now because we don't have a proper way to
178		* remove an element from an array by its key. Unsetting the key results
179		* in the element being left in the array as null so we have to pull
180		* null values.
181		*/
182	29	$this->executeQuery($parent, array('$pull' => array($propertyPath => null)), $options);
183	29	}
184
185		/**
186		* Inserts new elements for a PersistentCollection instance.
187		*
188		* This method is intended to be used with the "pushAll" and "addToSet"
189		* strategies.
190		*
191		* @param PersistentCollectionInterface $coll
192		* @param array $options
193		*/
194	89	private function insertElements(PersistentCollectionInterface $coll, array $options)
195		{
196	89	$insertDiff = $coll->getInsertDiff();
197
198	89	if (empty($insertDiff)) {
199	21	return;
200		}
201
202	74	$mapping = $coll->getMapping();
203	74	list($propertyPath, $parent) = $this->getPathAndParent($coll);
204
205	74	$pb = $this->pb;
206
207	74	$callback = isset($mapping['embedded'])
208		? function($v) use ($pb, $mapping) { return $pb->prepareEmbeddedDocumentValue($mapping, $v); }
209		: function($v) use ($pb, $mapping) { return $pb->prepareReferencedDocumentValue($mapping, $v); };
210
211	74	$value = array_values(array_map($callback, $insertDiff));
212
213	74	if ($mapping['strategy'] === ClassMetadataInfo::STORAGE_STRATEGY_ADD_TO_SET) {
214	6	$value = array('$each' => $value);
215	6	}
216
217	74	$query = array('$' . $mapping['strategy'] => array($propertyPath => $value));
218
219	74	$this->executeQuery($parent, $query, $options);
220	73	}
221
222		/**
223		* Gets the parent information for a given PersistentCollection. It will
224		* retrieve the top-level persistent Document that the PersistentCollection
225		* lives in. We can use this to issue queries when updating a
226		* PersistentCollection that is multiple levels deep inside an embedded
227		* document.
228		*
229		* <code>
230		* list($path, $parent) = $this->getPathAndParent($coll)
231		* </code>
232		*
233		* @param PersistentCollectionInterface $coll
234		* @return array $pathAndParent
235		*/
236	110	private function getPathAndParent(PersistentCollectionInterface $coll)
237		{
238	110	$mapping = $coll->getMapping();
239	110	$fields = array();
240	110	$parent = $coll->getOwner();
241	110	while (null !== ($association = $this->uow->getParentAssociation($parent))) {
242	15	list($m, $owner, $field) = $association;
243	15	if (isset($m['reference'])) {
244		break;
245		}
246	15	$parent = $owner;
247	15	$fields[] = $field;
248	15	}
249	110	$propertyPath = implode('.', array_reverse($fields));
250	110	$path = $mapping['name'];
251	110	if ($propertyPath) {
252	15	$path = $propertyPath . '.' . $path;
253	15	}
254	110	return array($path, $parent);
255		}
256
257		/**
258		* Executes a query updating the given document.
259		*
260		* @param object $document
261		* @param array $newObj
262		* @param array $options
263		*/
264	110	private function executeQuery($document, array $newObj, array $options)
265		{
266	110	$className = get_class($document);
267	110	$class = $this->dm->getClassMetadata($className);
268	110	$id = $class->getDatabaseIdentifierValue($this->uow->getDocumentIdentifier($document));
269	110	$query = array('_id' => $id);
270	110	if ($class->isVersioned) {
271	5	$query[$class->versionField] = $class->reflFields[$class->versionField]->getValue($document);
272	5	}
273	110	$collection = $this->dm->getDocumentCollection($className);
274	110	$result = $collection->update($query, $newObj, $options);
275	110	if ($class->isVersioned && ! $result['n']) {
276	2	throw LockException::lockFailed($document);
277		}
278	108	}
279		}
280

doctrine / mongodb-odm

Push — master ( 2f1eb7...23b3b5 )

CollectionPersister::getPathAndParent() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like