ProxyFactory::createCloner() - Code Metrics - Inspection of "Start working on ODM 2.0" - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1668)

by Andreas

created 2017-11-03 06:09 UTC

ProxyFactory::createCloner() C

↳ Parent: ProxyFactory

Complexity

Conditions	7
Paths	1

Size

Total Lines	32
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	39.826

Importance

Changes

Metric	Value
dl	0
loc	32
ccs	2
cts	16
cp	0.125
rs	6.7272
c	0
b	0
f	0
cc	7
eloc	19
nc	1
nop	3
crap	39.826

<?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\Proxy;

use Doctrine\Common\NotifyPropertyChanged;
use Doctrine\Common\Proxy\AbstractProxyFactory;
use Doctrine\Common\Proxy\ProxyDefinition;
use Doctrine\ODM\MongoDB\DocumentManager;
use Doctrine\ODM\MongoDB\DocumentNotFoundException;
use Doctrine\Common\Proxy\ProxyGenerator;
use Doctrine\Common\Util\ClassUtils;
use Doctrine\Common\Proxy\Proxy as BaseProxy;
use Doctrine\Common\Persistence\Mapping\ClassMetadata as BaseClassMetadata;
use Doctrine\ODM\MongoDB\Persisters\DocumentPersister;
use Doctrine\ODM\MongoDB\Utility\LifecycleEventManager;
use ReflectionProperty;

/**
 * This factory is used to create proxy objects for documents at runtime.
 *
 * @since       1.0
 */
class ProxyFactory extends AbstractProxyFactory
{
    /**
     * @var \Doctrine\ODM\MongoDB\Mapping\ClassMetadataFactory
     */
    private $metadataFactory;


    /**
     * @var \Doctrine\ODM\MongoDB\UnitOfWork The UnitOfWork this factory is bound to.
     */
    private $uow;

    /**
     * @var string The namespace that contains all proxy classes.
     */
    private $proxyNamespace;

    /**
     * @var \Doctrine\Common\EventManager
     */
    private $lifecycleEventManager;

    /**
     * Initializes a new instance of the <tt>ProxyFactory</tt> class that is
     * connected to the given <tt>DocumentManager</tt>.
     *
     * @param \Doctrine\ODM\MongoDB\DocumentManager $documentManager The DocumentManager the new factory works for.
     * @param string                                $proxyDir        The directory to use for the proxy classes. It
     *                                                               must exist.
     * @param string                                $proxyNamespace  The namespace to use for the proxy classes.
     * @param integer                               $autoGenerate    Whether to automatically generate proxy classes.
     */
    public function __construct(DocumentManager $documentManager, $proxyDir, $proxyNamespace, $autoGenerate = AbstractProxyFactory::AUTOGENERATE_NEVER)
    {
        $this->metadataFactory = $documentManager->getMetadataFactory();
        $this->uow = $documentManager->getUnitOfWork();
        $this->proxyNamespace = $proxyNamespace;
        $this->lifecycleEventManager = new LifecycleEventManager($documentManager, $this->uow, $documentManager->getEventManager());

        $proxyGenerator = new ProxyGenerator($proxyDir, $proxyNamespace);

        $proxyGenerator->setPlaceholder('baseProxyInterface', Proxy::class);

        parent::__construct($proxyGenerator, $this->metadataFactory, $autoGenerate);
    }

    /**
     * {@inheritDoc}
     */
    public function skipClass(BaseClassMetadata $class)
    {
        /* @var $class \Doctrine\ODM\Mongodb\Mapping\ClassMetadataInfo */
        return $class->isMappedSuperclass || $class->isQueryResultDocument || $class->getReflectionClass()->isAbstract();
    }

    /**
     * {@inheritDoc}
     */
    public function createProxyDefinition($className)
    {
        /* @var $classMetadata \Doctrine\ODM\MongoDB\Mapping\ClassMetadataInfo */
        $classMetadata     = $this->metadataFactory->getMetadataFor($className);
        $documentPersister = $this->uow->getDocumentPersister($className);
        $reflectionId      = $classMetadata->reflFields[$classMetadata->identifier];

        return new ProxyDefinition(
            ClassUtils::generateProxyClassName($className, $this->proxyNamespace),
            $classMetadata->getIdentifierFieldNames(),
            $classMetadata->getReflectionProperties(),
            $this->createInitializer($classMetadata, $documentPersister, $reflectionId),
            $this->createCloner($classMetadata, $documentPersister, $reflectionId)
        );
    }

    /**
     * Generates a closure capable of initializing a proxy
     *
     * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $classMetadata
     * @param \Doctrine\ODM\MongoDB\Persisters\DocumentPersister $documentPersister
     * @param \ReflectionProperty                                $reflectionId
     *
     * @return \Closure
     *
     * @throws \Doctrine\ODM\MongoDB\DocumentNotFoundException
     */
    private function createInitializer(
        BaseClassMetadata $classMetadata,
        DocumentPersister $documentPersister,
        ReflectionProperty $reflectionId
    ) {
        if ($classMetadata->getReflectionClass()->hasMethod('__wakeup')) {
            return function (BaseProxy $proxy) use ($documentPersister, $reflectionId) {

                $proxy->__setInitializer(null);
                $proxy->__setCloner(null);

                if ($proxy->__isInitialized()) {
                    return;
                }

                $properties = $proxy->__getLazyProperties();

                foreach ($properties as $propertyName => $property) {
                    if ( ! isset($proxy->$propertyName)) {
                        $proxy->$propertyName = $properties[$propertyName];
                    }
                }

                $proxy->__setInitialized(true);
                $proxy->__wakeup();


                $id = $reflectionId->getValue($proxy);

                if (null === $documentPersister->load(array('_id' => $id), $proxy)) {
                    if ( ! $this->lifecycleEventManager->documentNotFound($proxy, $id)) {

                        throw DocumentNotFoundException::documentNotFound(get_class($proxy), $id);
                    }
                }

                if ($proxy instanceof NotifyPropertyChanged) {
                    $proxy->addPropertyChangedListener($this->uow);
                }
            };
        }

        return function (BaseProxy $proxy) use ($documentPersister, $reflectionId) {

            $proxy->__setInitializer(null);
            $proxy->__setCloner(null);

            if ($proxy->__isInitialized()) {
                return;
            }

            $properties = $proxy->__getLazyProperties();

            foreach ($properties as $propertyName => $property) {
                if ( ! isset($proxy->$propertyName)) {
                    $proxy->$propertyName = $properties[$propertyName];
                }
            }

            $proxy->__setInitialized(true);

            $id = $reflectionId->getValue($proxy);

            if (null === $documentPersister->load(array('_id' => $id), $proxy)) {
                if ( ! $this->lifecycleEventManager->documentNotFound($proxy, $id)) {

                    throw DocumentNotFoundException::documentNotFound(get_class($proxy), $id);
                }
            }

            if ($proxy instanceof NotifyPropertyChanged) {
                $proxy->addPropertyChangedListener($this->uow);
            }
        };
    }

    /**
     * Generates a closure capable of finalizing a cloned proxy
     *
     * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $classMetadata
     * @param \Doctrine\ODM\MongoDB\Persisters\DocumentPersister $documentPersister
     * @param \ReflectionProperty                                $reflectionId
     *
     * @return \Closure
     *
     * @throws \Doctrine\ODM\MongoDB\DocumentNotFoundException
     */
    private function createCloner(
        BaseClassMetadata $classMetadata,
        DocumentPersister $documentPersister,
        ReflectionProperty $reflectionId
    ) {
        return function (BaseProxy $proxy) use ($documentPersister, $classMetadata, $reflectionId) {
            if ($proxy->__isInitialized()) {
                return;
            }

            $proxy->__setInitialized(true);
            $proxy->__setInitializer(null);

            $id       = $reflectionId->getValue($proxy);
            $original = $documentPersister->load(array('_id' => $id));

            if (null === $original) {
                if ( ! $this->lifecycleEventManager->documentNotFound($proxy, $id)) {

                    throw DocumentNotFoundException::documentNotFound(get_class($proxy), $id);
                }
            }

            foreach ($classMetadata->getReflectionClass()->getProperties() as $reflectionProperty) {
                $propertyName = $reflectionProperty->getName();

                if ($classMetadata->hasField($propertyName) || $classMetadata->hasAssociation($propertyName)) {
                    $reflectionProperty->setAccessible(true);
                    $reflectionProperty->setValue($proxy, $reflectionProperty->getValue($original));
                }
            }
        };
    }
}


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\Proxy;
21
22			use Doctrine\Common\NotifyPropertyChanged;
23			use Doctrine\Common\Proxy\AbstractProxyFactory;
24			use Doctrine\Common\Proxy\ProxyDefinition;
25			use Doctrine\ODM\MongoDB\DocumentManager;
26			use Doctrine\ODM\MongoDB\DocumentNotFoundException;
27			use Doctrine\Common\Proxy\ProxyGenerator;
28			use Doctrine\Common\Util\ClassUtils;
29			use Doctrine\Common\Proxy\Proxy as BaseProxy;
30			use Doctrine\Common\Persistence\Mapping\ClassMetadata as BaseClassMetadata;
31			use Doctrine\ODM\MongoDB\Persisters\DocumentPersister;
32			use Doctrine\ODM\MongoDB\Utility\LifecycleEventManager;
33			use ReflectionProperty;
34
35			/**
36			* This factory is used to create proxy objects for documents at runtime.
37			*
38			* @since 1.0
39			*/
40			class ProxyFactory extends AbstractProxyFactory
41			{
42			/**
43			* @var \Doctrine\ODM\MongoDB\Mapping\ClassMetadataFactory
44			*/
45			private $metadataFactory;
			0 ignored issues – show Comprehensibility introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report Consider using a different property name as you override a private property of the parent class. Loading history...
46
47			/**
48			* @var \Doctrine\ODM\MongoDB\UnitOfWork The UnitOfWork this factory is bound to.
49			*/
50			private $uow;
51
52			/**
53			* @var string The namespace that contains all proxy classes.
54			*/
55			private $proxyNamespace;
56
57			/**
58			* @var \Doctrine\Common\EventManager
59			*/
60			private $lifecycleEventManager;
61
62			/**
63			* Initializes a new instance of the <tt>ProxyFactory</tt> class that is
64			* connected to the given <tt>DocumentManager</tt>.
65			*
66			* @param \Doctrine\ODM\MongoDB\DocumentManager $documentManager The DocumentManager the new factory works for.
67			* @param string $proxyDir The directory to use for the proxy classes. It
68			* must exist.
69			* @param string $proxyNamespace The namespace to use for the proxy classes.
70			* @param integer $autoGenerate Whether to automatically generate proxy classes.
71			*/
72	1109		public function __construct(DocumentManager $documentManager, $proxyDir, $proxyNamespace, $autoGenerate = AbstractProxyFactory::AUTOGENERATE_NEVER)
73			{
74	1109		$this->metadataFactory = $documentManager->getMetadataFactory();
75	1109		$this->uow = $documentManager->getUnitOfWork();
76	1109		$this->proxyNamespace = $proxyNamespace;
77	1109		$this->lifecycleEventManager = new LifecycleEventManager($documentManager, $this->uow, $documentManager->getEventManager());
			0 ignored issues – show Documentation Bug introduced 2016-01-08 10:22 UTC by Report Bug Copy Issue Report It seems like `new \Doctrine\ODM\MongoD...ger->getEventManager())` of type `object<Doctrine\ODM\Mong...\LifecycleEventManager>` is incompatible with the declared type `object<Doctrine\Common\EventManager>` of property `$lifecycleEventManager`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
78	1109		$proxyGenerator = new ProxyGenerator($proxyDir, $proxyNamespace);
79
80	1109		$proxyGenerator->setPlaceholder('baseProxyInterface', Proxy::class);
81
82	1109		parent::__construct($proxyGenerator, $this->metadataFactory, $autoGenerate);
83	1109		}
84
85			/**
86			* {@inheritDoc}
87			*/
88			public function skipClass(BaseClassMetadata $class)
89			{
90			/* @var $class \Doctrine\ODM\Mongodb\Mapping\ClassMetadataInfo */
91			return $class->isMappedSuperclass \|\| $class->isQueryResultDocument \|\| $class->getReflectionClass()->isAbstract();
92			}
93
94			/**
95			* {@inheritDoc}
96			*/
97	97		public function createProxyDefinition($className)
98			{
99			/* @var $classMetadata \Doctrine\ODM\MongoDB\Mapping\ClassMetadataInfo */
100	97		$classMetadata = $this->metadataFactory->getMetadataFor($className);
101	97		$documentPersister = $this->uow->getDocumentPersister($className);
102	97		$reflectionId = $classMetadata->reflFields[$classMetadata->identifier];
103
104	97		return new ProxyDefinition(
105	97		ClassUtils::generateProxyClassName($className, $this->proxyNamespace),
106	97		$classMetadata->getIdentifierFieldNames(),
107	97		$classMetadata->getReflectionProperties(),
108	97		$this->createInitializer($classMetadata, $documentPersister, $reflectionId),
109	97		$this->createCloner($classMetadata, $documentPersister, $reflectionId)
110			);
111			}
112
113			/**
114			* Generates a closure capable of initializing a proxy
115			*
116			* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $classMetadata
117			* @param \Doctrine\ODM\MongoDB\Persisters\DocumentPersister $documentPersister
118			* @param \ReflectionProperty $reflectionId
119			*
120			* @return \Closure
121			*
122			* @throws \Doctrine\ODM\MongoDB\DocumentNotFoundException
123			*/
124	97		private function createInitializer(
125			BaseClassMetadata $classMetadata,
126			DocumentPersister $documentPersister,
127			ReflectionProperty $reflectionId
128			) {
129	97		if ($classMetadata->getReflectionClass()->hasMethod('__wakeup')) {
130		View Code Duplication	return function (BaseProxy $proxy) use ($documentPersister, $reflectionId) {
			0 ignored issues – show Duplication introduced 2015-12-22 17:02 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...
131			$proxy->__setInitializer(null);
132			$proxy->__setCloner(null);
133
134			if ($proxy->__isInitialized()) {
135			return;
136			}
137
138			$properties = $proxy->__getLazyProperties();
139
140			foreach ($properties as $propertyName => $property) {
141			if ( ! isset($proxy->$propertyName)) {
142			$proxy->$propertyName = $properties[$propertyName];
143			}
144			}
145
146			$proxy->__setInitialized(true);
147			$proxy->__wakeup();
			0 ignored issues – show Bug introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report The method `__wakeup()` does not seem to exist on `object<Doctrine\Common\Proxy\Proxy>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
148
149			$id = $reflectionId->getValue($proxy);
150
151			if (null === $documentPersister->load(array('_id' => $id), $proxy)) {
152			if ( ! $this->lifecycleEventManager->documentNotFound($proxy, $id)) {
			0 ignored issues – show Bug introduced 2016-02-29 21:40 UTC by Report Bug Copy Issue Report The method `documentNotFound()` does not seem to exist on `object<Doctrine\Common\EventManager>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
153			throw DocumentNotFoundException::documentNotFound(get_class($proxy), $id);
154			}
155			}
156
157			if ($proxy instanceof NotifyPropertyChanged) {
158			$proxy->addPropertyChangedListener($this->uow);
159			}
160			};
161			}
162
163		View Code Duplication	return function (BaseProxy $proxy) use ($documentPersister, $reflectionId) {
			0 ignored issues – show Duplication introduced 2016-02-29 21:40 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...
164	43		$proxy->__setInitializer(null);
165	43		$proxy->__setCloner(null);
166
167	43		if ($proxy->__isInitialized()) {
168	3		return;
169			}
170
171	43		$properties = $proxy->__getLazyProperties();
172
173	43		foreach ($properties as $propertyName => $property) {
174	23		if ( ! isset($proxy->$propertyName)) {
175	23		$proxy->$propertyName = $properties[$propertyName];
176			}
177			}
178
179	43		$proxy->__setInitialized(true);
180
181	43		$id = $reflectionId->getValue($proxy);
182
183	43		if (null === $documentPersister->load(array('_id' => $id), $proxy)) {
184	9		if ( ! $this->lifecycleEventManager->documentNotFound($proxy, $id)) {
			0 ignored issues – show Bug introduced 2016-02-29 21:40 UTC by Report Bug Copy Issue Report The method `documentNotFound()` does not seem to exist on `object<Doctrine\Common\EventManager>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
185	8		throw DocumentNotFoundException::documentNotFound(get_class($proxy), $id);
186			}
187			}
188
189	39		if ($proxy instanceof NotifyPropertyChanged) {
190	1		$proxy->addPropertyChangedListener($this->uow);
191			}
192	97		};
193			}
194
195			/**
196			* Generates a closure capable of finalizing a cloned proxy
197			*
198			* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $classMetadata
199			* @param \Doctrine\ODM\MongoDB\Persisters\DocumentPersister $documentPersister
200			* @param \ReflectionProperty $reflectionId
201			*
202			* @return \Closure
203			*
204			* @throws \Doctrine\ODM\MongoDB\DocumentNotFoundException
205			*/
206			private function createCloner(
207			BaseClassMetadata $classMetadata,
208			DocumentPersister $documentPersister,
209			ReflectionProperty $reflectionId
210			) {
211	97		return function (BaseProxy $proxy) use ($documentPersister, $classMetadata, $reflectionId) {
212			if ($proxy->__isInitialized()) {
213			return;
214			}
215
216			$proxy->__setInitialized(true);
217			$proxy->__setInitializer(null);
218
219			$id = $reflectionId->getValue($proxy);
220			$original = $documentPersister->load(array('_id' => $id));
221
222			if (null === $original) {
223			if ( ! $this->lifecycleEventManager->documentNotFound($proxy, $id)) {
			0 ignored issues – show Bug introduced 2016-02-29 21:40 UTC by Report Bug Copy Issue Report The method `documentNotFound()` does not seem to exist on `object<Doctrine\Common\EventManager>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
224			throw DocumentNotFoundException::documentNotFound(get_class($proxy), $id);
225			}
226			}
227
228			foreach ($classMetadata->getReflectionClass()->getProperties() as $reflectionProperty) {
229			$propertyName = $reflectionProperty->getName();
230
231			if ($classMetadata->hasField($propertyName) \|\| $classMetadata->hasAssociation($propertyName)) {
232			$reflectionProperty->setAccessible(true);
233			$reflectionProperty->setValue($proxy, $reflectionProperty->getValue($original));
234			}
235			}
236	97		};
237			}
238			}
239

doctrine / mongodb-odm

Pull Request — master (#1668)

ProxyFactory::createCloner() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like