Instantiator::buildAndCacheFromFactory() - Code Metrics - Inspection of "Merge pull request #36 from bendavies/php-bench" - doctrine/instantiator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 185b88...fe8b2f )

by Marco

created 2017-09-19 11:45 UTC

Instantiator::buildAndCacheFromFactory() A

↳ Parent: Instantiator

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	11
ccs	6
cts	6
cp	1
rs	9.4285
c	1
b	0
f	0
cc	2
eloc	6
nc	2
nop	1
crap	2

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

use Doctrine\Instantiator\Exception\InvalidArgumentException;
use Doctrine\Instantiator\Exception\UnexpectedValueException;
use Exception;
use ReflectionClass;

/**
 * {@inheritDoc}
 *
 * @author Marco Pivetta <[email protected]>
 */
final class Instantiator implements InstantiatorInterface
{
    /**
     * Markers used internally by PHP to define whether {@see \unserialize} should invoke
     * the method {@see \Serializable::unserialize()} when dealing with classes implementing
     * the {@see \Serializable} interface.
     */
    const SERIALIZATION_FORMAT_USE_UNSERIALIZER   = 'C';
    const SERIALIZATION_FORMAT_AVOID_UNSERIALIZER = 'O';

    /**
     * @var \callable[] used to instantiate specific classes, indexed by class name
     */
    private static $cachedInstantiators = [];

    /**
     * @var object[] of objects that can directly be cloned, indexed by class name
     */
    private static $cachedCloneables = [];

    /**
     * {@inheritDoc}
     */
    public function instantiate($className)
    {
        if (isset(self::$cachedCloneables[$className])) {
            return clone self::$cachedCloneables[$className];
        }

        if (isset(self::$cachedInstantiators[$className])) {
            $factory = self::$cachedInstantiators[$className];

            return $factory();
        }

        return $this->buildAndCacheFromFactory($className);
    }

    /**
     * Builds the requested object and caches it in static properties for performance
     *
     * @return object
     */
    private function buildAndCacheFromFactory(string $className)
    {
        $factory  = self::$cachedInstantiators[$className] = $this->buildFactory($className);
        $instance = $factory();

        if ($this->isSafeToClone(new ReflectionClass($instance))) {
            self::$cachedCloneables[$className] = clone $instance;
        }

        return $instance;
    }

    /**
     * Builds a callable capable of instantiating the given $className without
     * invoking its constructor.
     *
     * @throws InvalidArgumentException
     * @throws UnexpectedValueException
     * @throws \ReflectionException
     */
    private function buildFactory(string $className) : callable
    {
        $reflectionClass = $this->getReflectionClass($className);

        if ($this->isInstantiableViaReflection($reflectionClass)) {
            return [$reflectionClass, 'newInstanceWithoutConstructor'];
        }

        $serializedString = sprintf(
            '%s:%d:"%s":0:{}',
            self::SERIALIZATION_FORMAT_AVOID_UNSERIALIZER,
            strlen($className),
            $className
        );

        $this->checkIfUnSerializationIsSupported($reflectionClass, $serializedString);

        return function () use ($serializedString) {
            return unserialize($serializedString);
        };
    }

    /**
     * @param string $className
     *
     * @return ReflectionClass
     *
     * @throws InvalidArgumentException
     * @throws \ReflectionException
     */
    private function getReflectionClass($className) : ReflectionClass
    {
        if (! class_exists($className)) {
            throw InvalidArgumentException::fromNonExistingClass($className);
        }

        $reflection = new ReflectionClass($className);

        if ($reflection->isAbstract()) {
            throw InvalidArgumentException::fromAbstractClass($reflection);
        }

        return $reflection;
    }

    /**
     * @param ReflectionClass $reflectionClass
     * @param string          $serializedString
     *
     * @throws UnexpectedValueException
     *
     * @return void
     */
    private function checkIfUnSerializationIsSupported(ReflectionClass $reflectionClass, $serializedString) : void
    {
        set_error_handler(function ($code, $message, $file, $line) use ($reflectionClass, & $error) : void {
            $error = UnexpectedValueException::fromUncleanUnSerialization(
                $reflectionClass,
                $message,
                $code,
                $file,
                $line
            );
        });

        $this->attemptInstantiationViaUnSerialization($reflectionClass, $serializedString);

        restore_error_handler();

        if ($error) {
            throw $error;
        }
    }

    /**
     * @param ReflectionClass $reflectionClass
     * @param string          $serializedString
     *
     * @throws UnexpectedValueException
     *
     * @return void
     */
    private function attemptInstantiationViaUnSerialization(ReflectionClass $reflectionClass, $serializedString) : void
    {
        try {
            unserialize($serializedString);
        } catch (Exception $exception) {
            restore_error_handler();

            throw UnexpectedValueException::fromSerializationTriggeredException($reflectionClass, $exception);
        }
    }

    private function isInstantiableViaReflection(ReflectionClass $reflectionClass) : bool
    {
        return ! ($this->hasInternalAncestors($reflectionClass) && $reflectionClass->isFinal());
    }

    /**
     * Verifies whether the given class is to be considered internal
     */
    private function hasInternalAncestors(ReflectionClass $reflectionClass) : bool
    {
        do {
            if ($reflectionClass->isInternal()) {
                return true;
            }
        } while ($reflectionClass = $reflectionClass->getParentClass());

        return false;
    }

    /**
     * Checks if a class is cloneable
     *
     * Classes implementing `__clone` cannot be safely cloned, as that may cause side-effects.
     */
    private function isSafeToClone(ReflectionClass $reflection) : bool
    {
        return $reflection->isCloneable() && ! $reflection->hasMethod('__clone');
    }
}


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\Instantiator;
21
22		use Doctrine\Instantiator\Exception\InvalidArgumentException;
23		use Doctrine\Instantiator\Exception\UnexpectedValueException;
24		use Exception;
25		use ReflectionClass;
26
27		/**
28		* {@inheritDoc}
29		*
30		* @author Marco Pivetta <[email protected]>
31		*/
32		final class Instantiator implements InstantiatorInterface
33		{
34		/**
35		* Markers used internally by PHP to define whether {@see \unserialize} should invoke
36		* the method {@see \Serializable::unserialize()} when dealing with classes implementing
37		* the {@see \Serializable} interface.
38		*/
39		const SERIALIZATION_FORMAT_USE_UNSERIALIZER = 'C';
40		const SERIALIZATION_FORMAT_AVOID_UNSERIALIZER = 'O';
41
42		/**
43		* @var \callable[] used to instantiate specific classes, indexed by class name
44		*/
45		private static $cachedInstantiators = [];
46
47		/**
48		* @var object[] of objects that can directly be cloned, indexed by class name
49		*/
50		private static $cachedCloneables = [];
51
52		/**
53		* {@inheritDoc}
54		*/
55	40	public function instantiate($className)
56		{
57	40	if (isset(self::$cachedCloneables[$className])) {
58	10	return clone self::$cachedCloneables[$className];
59		}
60
61	31	if (isset(self::$cachedInstantiators[$className])) {
62	9	$factory = self::$cachedInstantiators[$className];
63
64	9	return $factory();
65		}
66
67	22	return $this->buildAndCacheFromFactory($className);
68		}
69
70		/**
71		* Builds the requested object and caches it in static properties for performance
72		*
73		* @return object
74		*/
75	22	private function buildAndCacheFromFactory(string $className)
76		{
77	22	$factory = self::$cachedInstantiators[$className] = $this->buildFactory($className);
78	17	$instance = $factory();
79
80	17	if ($this->isSafeToClone(new ReflectionClass($instance))) {
81	10	self::$cachedCloneables[$className] = clone $instance;
82		}
83
84	17	return $instance;
85		}
86
87		/**
88		* Builds a callable capable of instantiating the given $className without
89		* invoking its constructor.
90		*
91		* @throws InvalidArgumentException
92		* @throws UnexpectedValueException
93		* @throws \ReflectionException
94		*/
95	22	private function buildFactory(string $className) : callable
96		{
97	22	$reflectionClass = $this->getReflectionClass($className);
98
99	18	if ($this->isInstantiableViaReflection($reflectionClass)) {
100	16	return [$reflectionClass, 'newInstanceWithoutConstructor'];
101		}
102
103	2	$serializedString = sprintf(
104	2	'%s:%d:"%s":0:{}',
105	2	self::SERIALIZATION_FORMAT_AVOID_UNSERIALIZER,
106	2	strlen($className),
107	2	$className
108		);
109
110	2	$this->checkIfUnSerializationIsSupported($reflectionClass, $serializedString);
111
112	2	return function () use ($serializedString) {
113	2	return unserialize($serializedString);
114	1	};
115		}
116
117		/**
118		* @param string $className
119		*
120		* @return ReflectionClass
121		*
122		* @throws InvalidArgumentException
123		* @throws \ReflectionException
124		*/
125	22	private function getReflectionClass($className) : ReflectionClass
126		{
127	22	if (! class_exists($className)) {
128	3	throw InvalidArgumentException::fromNonExistingClass($className);
129		}
130
131	19	$reflection = new ReflectionClass($className);
132
133	19	if ($reflection->isAbstract()) {
134	1	throw InvalidArgumentException::fromAbstractClass($reflection);
135		}
136
137	18	return $reflection;
138		}
139
140		/**
141		* @param ReflectionClass $reflectionClass
142		* @param string $serializedString
143		*
144		* @throws UnexpectedValueException
145		*
146		* @return void
147		*/
148		private function checkIfUnSerializationIsSupported(ReflectionClass $reflectionClass, $serializedString) : void
149		{
150	2	set_error_handler(function ($code, $message, $file, $line) use ($reflectionClass, & $error) : void {
151	1	$error = UnexpectedValueException::fromUncleanUnSerialization(
152	1	$reflectionClass,
153	1	$message,
154	1	$code,
155	1	$file,
156	1	$line
157		);
158	2	});
159
160	2	$this->attemptInstantiationViaUnSerialization($reflectionClass, $serializedString);
161
162	2	restore_error_handler();
163
164	2	if ($error) {
165	1	throw $error;
166		}
167	1	}
168
169		/**
170		* @param ReflectionClass $reflectionClass
171		* @param string $serializedString
172		*
173		* @throws UnexpectedValueException
174		*
175		* @return void
176		*/
177	2	private function attemptInstantiationViaUnSerialization(ReflectionClass $reflectionClass, $serializedString) : void
178		{
179		try {
180	2	unserialize($serializedString);
181		} catch (Exception $exception) {
182		restore_error_handler();
183
184		throw UnexpectedValueException::fromSerializationTriggeredException($reflectionClass, $exception);
185		}
186	2	}
187
188	18	private function isInstantiableViaReflection(ReflectionClass $reflectionClass) : bool
189		{
190	18	return ! ($this->hasInternalAncestors($reflectionClass) && $reflectionClass->isFinal());
191		}
192
193		/**
194		* Verifies whether the given class is to be considered internal
195		*/
196	18	private function hasInternalAncestors(ReflectionClass $reflectionClass) : bool
197		{
198		do {
199	18	if ($reflectionClass->isInternal()) {
200	13	return true;
201		}
202	13	} while ($reflectionClass = $reflectionClass->getParentClass());
203
204	5	return false;
205		}
206
207		/**
208		* Checks if a class is cloneable
209		*
210		* Classes implementing `__clone` cannot be safely cloned, as that may cause side-effects.
211		*/
212	17	private function isSafeToClone(ReflectionClass $reflection) : bool
213		{
214	17	return $reflection->isCloneable() && ! $reflection->hasMethod('__clone');
215		}
216		}
217

doctrine / instantiator

Push — master ( 185b88...fe8b2f )

Instantiator::buildAndCacheFromFactory() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like