Instantiator::attemptInstantiationViaUnSerialization() - Code Metrics - padraic/mockery - Measure and Improve Code Quality continuously with Scrutinizer

attemptInstantiationViaUnSerialization() B
last analyzed 2017-04-07 09:10 UTC

↳ Parent: Instantiator

Complexity

Conditions	3
Paths	3

Size

Total Lines	27
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	27
ccs	0
cts	16
cp	0
rs	8.8571
cc	3
eloc	16
nc	3
nop	2
crap	12

<?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 Mockery;

use Closure;
use ReflectionClass;
use UnexpectedValueException;
use InvalidArgumentException;

/**
 * This is a trimmed down version of https://github.com/doctrine/instantiator,
 * basically without the caching
 *
 * @author Marco Pivetta <[email protected]>
 */
final class Instantiator
{
    /**
     * 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';

    /**
     * {@inheritDoc}
     */
    public function instantiate($className)
    {
        $factory    = $this->buildFactory($className);
        $instance   = $factory();
        $reflection = new ReflectionClass($instance);

        return $instance;
    }

    /**
     * @internal
     * @private
     *
     * Builds a {@see \Closure} capable of instantiating the given $className without
     * invoking its constructor.
     * This method is only exposed as public because of PHP 5.3 compatibility. Do not
     * use this method in your own code
     *
     * @param string $className
     *
     * @return Closure
     */
    public function buildFactory($className)
    {
        $reflectionClass = $this->getReflectionClass($className);

        if ($this->isInstantiableViaReflection($reflectionClass)) {
            return function () use ($reflectionClass) {
                return $reflectionClass->newInstanceWithoutConstructor();
            };
        }

        $serializedString = sprintf(
            '%s:%d:"%s":0:{}',
            $this->getSerializationFormat($reflectionClass),
            strlen($className),
            $className
        );

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

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

    /**
     * @param string $className
     *
     * @return ReflectionClass
     *
     * @throws InvalidArgumentException
     */
    private function getReflectionClass($className)
    {
        if (! class_exists($className)) {
            throw new InvalidArgumentException("Class:$className does not exist");
        }

        $reflection = new ReflectionClass($className);

        if ($reflection->isAbstract()) {
            throw new InvalidArgumentException("Class:$className is an abstract class");
        }

        return $reflection;
    }

    /**
     * @param ReflectionClass $reflectionClass
     * @param string          $serializedString
     *
     * @throws UnexpectedValueException
     *
     * @return void
     */
    private function attemptInstantiationViaUnSerialization(ReflectionClass $reflectionClass, $serializedString)
    {
        set_error_handler(function ($code, $message, $file, $line) use ($reflectionClass, & $error) {
            $msg = sprintf(
                'Could not produce an instance of "%s" via un-serialization, since an error was triggered in file "%s" at line "%d"',
                $reflectionClass->getName(),

                $file,
                $line
            );

            $error = new UnexpectedValueException($msg, 0, new \Exception($message, $code));
        });

        try {
            unserialize($serializedString);
        } catch (\Exception $exception) {
            restore_error_handler();

            throw new UnexpectedValueException("An exception was raised while trying to instantiate an instance of \"{$reflectionClass->getName()}\" via un-serialization", 0, $exception);

        }

        restore_error_handler();

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

    /**
     * @param ReflectionClass $reflectionClass
     *
     * @return bool
     */
    private function isInstantiableViaReflection(ReflectionClass $reflectionClass)
    {
        return ! ($reflectionClass->isInternal() && $reflectionClass->isFinal());
    }

    /**
     * Verifies whether the given class is to be considered internal
     *
     * @param ReflectionClass $reflectionClass
     *
     * @return bool
     */
    private function hasInternalAncestors(ReflectionClass $reflectionClass)

    {
        do {
            if ($reflectionClass->isInternal()) {
                return true;
            }
        } while ($reflectionClass = $reflectionClass->getParentClass());

        return false;
    }

    /**
     * Verifies if the given PHP version implements the `Serializable` interface serialization
     * with an incompatible serialization format. If that's the case, use serialization marker
     * "C" instead of "O".
     *
     * @link http://news.php.net/php.internals/74654
     *
     * @param ReflectionClass $reflectionClass
     *
     * @return string the serialization format marker, either self::SERIALIZATION_FORMAT_USE_UNSERIALIZER
     *                or self::SERIALIZATION_FORMAT_AVOID_UNSERIALIZER
     */
    private function getSerializationFormat(ReflectionClass $reflectionClass)
    {
        if ($this->isPhpVersionWithBrokenSerializationFormat()
            && $reflectionClass->implementsInterface('Serializable')
        ) {
            return self::SERIALIZATION_FORMAT_USE_UNSERIALIZER;
        }

        return self::SERIALIZATION_FORMAT_AVOID_UNSERIALIZER;
    }

    /**
     * Checks whether the current PHP runtime uses an incompatible serialization format
     *
     * @return bool
     */
    private function isPhpVersionWithBrokenSerializationFormat()
    {
        return PHP_VERSION_ID === 50429 || PHP_VERSION_ID === 50513;
    }
}


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 Mockery;
21
22		use Closure;
23		use ReflectionClass;
24		use UnexpectedValueException;
25		use InvalidArgumentException;
26
27		/**
28		* This is a trimmed down version of https://github.com/doctrine/instantiator,
29		* basically without the caching
30		*
31		* @author Marco Pivetta <[email protected]>
32		*/
33		final class Instantiator
34		{
35		/**
36		* Markers used internally by PHP to define whether {@see \unserialize} should invoke
37		* the method {@see \Serializable::unserialize()} when dealing with classes implementing
38		* the {@see \Serializable} interface.
39		*/
40		const SERIALIZATION_FORMAT_USE_UNSERIALIZER = 'C';
41		const SERIALIZATION_FORMAT_AVOID_UNSERIALIZER = 'O';
42
43		/**
44		* {@inheritDoc}
45		*/
46	402	public function instantiate($className)
47		{
48	402	$factory = $this->buildFactory($className);
49	402	$instance = $factory();
50	402	$reflection = new ReflectionClass($instance);
51
52	402	return $instance;
53		}
54
55		/**
56		* @internal
57		* @private
58		*
59		* Builds a {@see \Closure} capable of instantiating the given $className without
60		* invoking its constructor.
61		* This method is only exposed as public because of PHP 5.3 compatibility. Do not
62		* use this method in your own code
63		*
64		* @param string $className
65		*
66		* @return Closure
67		*/
68	402	public function buildFactory($className)
69		{
70	402	$reflectionClass = $this->getReflectionClass($className);
71
72	402	if ($this->isInstantiableViaReflection($reflectionClass)) {
73		return function () use ($reflectionClass) {
74	402	return $reflectionClass->newInstanceWithoutConstructor();
75	402	};
76		}
77
78		$serializedString = sprintf(
79		'%s:%d:"%s":0:{}',
80		$this->getSerializationFormat($reflectionClass),
81		strlen($className),
82		$className
83		);
84
85		$this->attemptInstantiationViaUnSerialization($reflectionClass, $serializedString);
86
87		return function () use ($serializedString) {
88		return unserialize($serializedString);
89		};
90		}
91
92		/**
93		* @param string $className
94		*
95		* @return ReflectionClass
96		*
97		* @throws InvalidArgumentException
98		*/
99	402	private function getReflectionClass($className)
100		{
101	402	if (! class_exists($className)) {
102		throw new InvalidArgumentException("Class:$className does not exist");
103		}
104
105	402	$reflection = new ReflectionClass($className);
106
107	402	if ($reflection->isAbstract()) {
108		throw new InvalidArgumentException("Class:$className is an abstract class");
109		}
110
111	402	return $reflection;
112		}
113
114		/**
115		* @param ReflectionClass $reflectionClass
116		* @param string $serializedString
117		*
118		* @throws UnexpectedValueException
119		*
120		* @return void
121		*/
122		private function attemptInstantiationViaUnSerialization(ReflectionClass $reflectionClass, $serializedString)
123		{
124		set_error_handler(function ($code, $message, $file, $line) use ($reflectionClass, & $error) {
125		$msg = sprintf(
126		'Could not produce an instance of "%s" via un-serialization, since an error was triggered in file "%s" at line "%d"',
127		$reflectionClass->getName(),
		0 ignored issues – show Bug introduced 2017-01-17 14:28 UTC by Report Bug Copy Issue Report Consider using `$reflectionClass->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
128		$file,
129		$line
130		);
131
132		$error = new UnexpectedValueException($msg, 0, new \Exception($message, $code));
133		});
134
135		try {
136		unserialize($serializedString);
137		} catch (\Exception $exception) {
138		restore_error_handler();
139
140		throw new UnexpectedValueException("An exception was raised while trying to instantiate an instance of \"{$reflectionClass->getName()}\" via un-serialization", 0, $exception);
		0 ignored issues – show Bug introduced 2017-01-17 14:28 UTC by Report Bug Copy Issue Report Consider using `$reflectionClass->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
141		}
142
143		restore_error_handler();
144
145		if ($error) {
146		throw $error;
147		}
148		}
149
150		/**
151		* @param ReflectionClass $reflectionClass
152		*
153		* @return bool
154		*/
155	402	private function isInstantiableViaReflection(ReflectionClass $reflectionClass)
156		{
157	402	return ! ($reflectionClass->isInternal() && $reflectionClass->isFinal());
158		}
159
160		/**
161		* Verifies whether the given class is to be considered internal
162		*
163		* @param ReflectionClass $reflectionClass
164		*
165		* @return bool
166		*/
167		private function hasInternalAncestors(ReflectionClass $reflectionClass)
		0 ignored issues – show Unused Code introduced 2017-01-17 14:28 UTC by Report Bug Copy Issue Report This method is not used, and could be removed. Loading history...
168		{
169		do {
170		if ($reflectionClass->isInternal()) {
171		return true;
172		}
173		} while ($reflectionClass = $reflectionClass->getParentClass());
174
175		return false;
176		}
177
178		/**
179		* Verifies if the given PHP version implements the `Serializable` interface serialization
180		* with an incompatible serialization format. If that's the case, use serialization marker
181		* "C" instead of "O".
182		*
183		* @link http://news.php.net/php.internals/74654
184		*
185		* @param ReflectionClass $reflectionClass
186		*
187		* @return string the serialization format marker, either self::SERIALIZATION_FORMAT_USE_UNSERIALIZER
188		* or self::SERIALIZATION_FORMAT_AVOID_UNSERIALIZER
189		*/
190		private function getSerializationFormat(ReflectionClass $reflectionClass)
191		{
192		if ($this->isPhpVersionWithBrokenSerializationFormat()
193		&& $reflectionClass->implementsInterface('Serializable')
194		) {
195		return self::SERIALIZATION_FORMAT_USE_UNSERIALIZER;
196		}
197
198		return self::SERIALIZATION_FORMAT_AVOID_UNSERIALIZER;
199		}
200
201		/**
202		* Checks whether the current PHP runtime uses an incompatible serialization format
203		*
204		* @return bool
205		*/
206		private function isPhpVersionWithBrokenSerializationFormat()
207		{
208		return PHP_VERSION_ID === 50429 \|\| PHP_VERSION_ID === 50513;
209		}
210		}
211

padraic / mockery

attemptInstantiationViaUnSerialization() B last analyzed 2017-04-07 09:10 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

attemptInstantiationViaUnSerialization() B
last analyzed 2017-04-07 09:10 UTC