[VarExporter] add Instantiator::instantiate() to create+populate objects without calling their constructor nor any other methods

nicolas-grekas · nicolas-grekas · commit b157f1d5c9e7 · 2018-09-09T23:20:07.000+02:00
diff --git a/src/Symfony/Component/VarExporter/Instantiator.php b/src/Symfony/Component/VarExporter/Instantiator.php
@@ -0,0 +1,104 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\VarExporter;
+
+use Symfony\Component\VarExporter\Internal\Hydrator;
+use Symfony\Component\VarExporter\Internal\Registry;
+
+/**
+ * A utility class to create objects without calling their constructor.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class Instantiator
+{
+    /**
+     * Creates an object and sets its properties without calling its constructor nor any other methods.
+     *
+     * For example:
+     *
+     *     // creates an empty instance of Foo
+     *     Instantiator::instantiate([Foo::class => []]);
+     *
+     *     // creates a Foo instance and sets one of its public, protected or private properties
+     *     Instantiator::instantiate([Foo::class => ['propertyName' => $propertyValue]]);
+     *
+     *     // creates a Foo instance and sets a private property defined on its parent Bar class
+     *     Instantiator::instantiate([
+     *         Foo::class => [],
+     *         Bar::class => ['privatePropertyName' => $propertyValue],
+     *     ]);
+     *
+     * Instances of ArrayObject, ArrayIterator and SplObjectHash can be created
+     * by using the special "\0" property name to define their internal value:
+     *
+     *     // creates an SplObjectHash where $info1 is attached to $obj1, etc.
+     *     Instantiator::instantiate([SplObjectStorage::class => ["\0" => [$obj1, $info1, $obj2, $info2...]]]);
+     *
+     *     // creates an ArrayObject pupolated with $inputArray
+     *     Instantiator::instantiate([ArrayObject::class => ["\0" => $inputArray]]);
+     *
+     * @param array $propertiesByClass The properties to set on the object, keyed by the class to bind to
+     *                                 when setting them. The first key of the array defines the class
+     *                                 of the returned instance.
+     *
+     * @return object An instance of the class defined by the first key of $propertiesByClass
+     *
+     * @throws \ReflectionException When the instance cannot be created
+     */
+    public static function instantiate(array $propertiesByClass)
+    {
+        if (!$propertiesByClass) {
+            throw new \ReflectionException('No class provided.');
+        }
+
+        foreach ($propertiesByClass as $class => $properties) {
+            break;
+        }
+
+        try {
+            $reflector = Registry::$reflectors[$class] ?? Registry::getClassReflector($class);
+        } catch (\Exception $e) {
+            if (0 === strpos($e->getMessage(), 'Serialization of ')) {
+                $e = new \ReflectionException(substr_replace($e->getMessage(), 'Instanti', 0, 8));
+            }
+
+            throw $e;
+        }
+
+        if (Registry::$cloneable[$class]) {
+            $instance = clone Registry::$prototypes[$class];
+        } elseif (Registry::$instantiableWithoutConstructor[$class]) {
+            $instance = $reflector->newInstanceWithoutConstructor();
+        } elseif (null === Registry::$prototypes[$class]) {
+            throw new \ReflectionException(sprintf("Instantiation of '%s' is not allowed", $class));
+        } elseif ($reflector->implementsInterface('Serializable')) {
+            $instance = unserialize('C:'.\strlen($class).':"'.$class.'":0:{}');
+        } else {
+            $instance = unserialize('O:'.\strlen($class).':"'.$class.'":0:{}');
+        }
+
+        $instance = array($instance);
+
+        foreach ($propertiesByClass as $class => $properties) {
+            if (!$properties) {
+                continue;
+            }
+            foreach ($properties as $name => $value) {
+                $properties[$name] = array($value);
+            }
+            (Hydrator::$hydrators[$class] ?? Hydrator::getHydrator($class))($properties, $instance);
+        }
+
+        return $instance[0];
+    }
+}
diff --git a/src/Symfony/Component/VarExporter/Internal/Hydrator.php b/src/Symfony/Component/VarExporter/Internal/Hydrator.php
@@ -78,7 +78,7 @@ public static function getHydrator($class)
                             }
                         }
                     }
-                    foreach ($properties["\0"] as $i => $v) {
+                    foreach ($properties["\0"] ?? array() as $i => $v) {
                         $constructor->invokeArgs($objects[$i], $v);
                     }
                 };
diff --git a/src/Symfony/Component/VarExporter/README.md b/src/Symfony/Component/VarExporter/README.md
@@ -5,6 +5,9 @@ The VarExporter component allows exporting any serializable PHP data structure t
 plain PHP code. While doing so, it preserves all the semantics associated with
 the serialization mechanism of PHP (`__wakeup`, `__sleep`, `Serializable`).
 
+It also provides an instantiator that allows creating and populating objects
+without calling their constructor nor any other methods.
+
 The reason to use this component *vs* `serialize()` or
 [igbinary](https://github.com/igbinary/igbinary) is performance: thanks to
 OPcache, the resulting code is significantly faster and more memory efficient

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ public static function getHydrator($class)`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`	`}`
`81`		`- foreach ($properties["\0"] as $i => $v) {`
	`81`	`+ foreach ($properties["\0"] ?? array() as $i => $v) {`
`82`	`82`	`$constructor->invokeArgs($objects[$i], $v);`
`83`	`83`	`}`
`84`	`84`	`};`