Update website
This commit is contained in:
parent
0a686aeb9a
commit
c4ffa0f6ee
4360 changed files with 1727 additions and 718385 deletions
|
|
@ -1,12 +0,0 @@
|
|||
CHANGELOG
|
||||
=========
|
||||
|
||||
5.1.0
|
||||
-----
|
||||
|
||||
* added argument `array &$foundClasses` to `VarExporter::export()` to ease with preloading exported values
|
||||
|
||||
4.2.0
|
||||
-----
|
||||
|
||||
* added the component
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
<?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\Exception;
|
||||
|
||||
class ClassNotFoundException extends \Exception implements ExceptionInterface
|
||||
{
|
||||
public function __construct(string $class, \Throwable $previous = null)
|
||||
{
|
||||
parent::__construct(sprintf('Class "%s" not found.', $class), 0, $previous);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
<?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\Exception;
|
||||
|
||||
interface ExceptionInterface extends \Throwable
|
||||
{
|
||||
}
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
<?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\Exception;
|
||||
|
||||
class NotInstantiableTypeException extends \Exception implements ExceptionInterface
|
||||
{
|
||||
public function __construct(string $type, \Throwable $previous = null)
|
||||
{
|
||||
parent::__construct(sprintf('Type "%s" is not instantiable.', $type), 0, $previous);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,92 +0,0 @@
|
|||
<?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\Exception\ExceptionInterface;
|
||||
use Symfony\Component\VarExporter\Exception\NotInstantiableTypeException;
|
||||
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 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 => ['privateBarProperty' => $propertyValue],
|
||||
* ]);
|
||||
*
|
||||
* Instances of ArrayObject, ArrayIterator and SplObjectStorage can be created
|
||||
* by using the special "\0" property name to define their internal value:
|
||||
*
|
||||
* // creates an SplObjectStorage where $info1 is attached to $obj1, etc.
|
||||
* Instantiator::instantiate(SplObjectStorage::class, ["\0" => [$obj1, $info1, $obj2, $info2...]]);
|
||||
*
|
||||
* // creates an ArrayObject populated with $inputArray
|
||||
* Instantiator::instantiate(ArrayObject::class, ["\0" => [$inputArray]]);
|
||||
*
|
||||
* @param string $class The class of the instance to create
|
||||
* @param array $properties The properties to set on the instance
|
||||
* @param array $privateProperties The private properties to set on the instance,
|
||||
* keyed by their declaring class
|
||||
*
|
||||
* @throws ExceptionInterface When the instance cannot be created
|
||||
*/
|
||||
public static function instantiate(string $class, array $properties = [], array $privateProperties = []): object
|
||||
{
|
||||
$reflector = Registry::$reflectors[$class] ?? Registry::getClassReflector($class);
|
||||
|
||||
if (Registry::$cloneable[$class]) {
|
||||
$wrappedInstance = [clone Registry::$prototypes[$class]];
|
||||
} elseif (Registry::$instantiableWithoutConstructor[$class]) {
|
||||
$wrappedInstance = [$reflector->newInstanceWithoutConstructor()];
|
||||
} elseif (null === Registry::$prototypes[$class]) {
|
||||
throw new NotInstantiableTypeException($class);
|
||||
} elseif ($reflector->implementsInterface('Serializable') && (\PHP_VERSION_ID < 70400 || !method_exists($class, '__unserialize'))) {
|
||||
$wrappedInstance = [unserialize('C:'.\strlen($class).':"'.$class.'":0:{}')];
|
||||
} else {
|
||||
$wrappedInstance = [unserialize('O:'.\strlen($class).':"'.$class.'":0:{}')];
|
||||
}
|
||||
|
||||
if ($properties) {
|
||||
$privateProperties[$class] = isset($privateProperties[$class]) ? $properties + $privateProperties[$class] : $properties;
|
||||
}
|
||||
|
||||
foreach ($privateProperties as $class => $properties) {
|
||||
if (!$properties) {
|
||||
continue;
|
||||
}
|
||||
foreach ($properties as $name => $value) {
|
||||
// because they're also used for "unserialization", hydrators
|
||||
// deal with array of instances, so we need to wrap values
|
||||
$properties[$name] = [$value];
|
||||
}
|
||||
(Hydrator::$hydrators[$class] ?? Hydrator::getHydrator($class))($properties, $wrappedInstance);
|
||||
}
|
||||
|
||||
return $wrappedInstance[0];
|
||||
}
|
||||
}
|
||||
|
|
@ -1,410 +0,0 @@
|
|||
<?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\Internal;
|
||||
|
||||
use Symfony\Component\VarExporter\Exception\NotInstantiableTypeException;
|
||||
|
||||
/**
|
||||
* @author Nicolas Grekas <p@tchwork.com>
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class Exporter
|
||||
{
|
||||
/**
|
||||
* Prepares an array of values for VarExporter.
|
||||
*
|
||||
* For performance this method is public and has no type-hints.
|
||||
*
|
||||
* @param array &$values
|
||||
* @param \SplObjectStorage $objectsPool
|
||||
* @param array &$refsPool
|
||||
* @param int &$objectsCount
|
||||
* @param bool &$valuesAreStatic
|
||||
*
|
||||
* @throws NotInstantiableTypeException When a value cannot be serialized
|
||||
*/
|
||||
public static function prepare($values, $objectsPool, &$refsPool, &$objectsCount, &$valuesAreStatic): array
|
||||
{
|
||||
$refs = $values;
|
||||
foreach ($values as $k => $value) {
|
||||
if (\is_resource($value)) {
|
||||
throw new NotInstantiableTypeException(get_resource_type($value).' resource');
|
||||
}
|
||||
$refs[$k] = $objectsPool;
|
||||
|
||||
if ($isRef = !$valueIsStatic = $values[$k] !== $objectsPool) {
|
||||
$values[$k] = &$value; // Break hard references to make $values completely
|
||||
unset($value); // independent from the original structure
|
||||
$refs[$k] = $value = $values[$k];
|
||||
if ($value instanceof Reference && 0 > $value->id) {
|
||||
$valuesAreStatic = false;
|
||||
++$value->count;
|
||||
continue;
|
||||
}
|
||||
$refsPool[] = [&$refs[$k], $value, &$value];
|
||||
$refs[$k] = $values[$k] = new Reference(-\count($refsPool), $value);
|
||||
}
|
||||
|
||||
if (\is_array($value)) {
|
||||
if ($value) {
|
||||
$value = self::prepare($value, $objectsPool, $refsPool, $objectsCount, $valueIsStatic);
|
||||
}
|
||||
goto handle_value;
|
||||
} elseif (!\is_object($value) || $value instanceof \UnitEnum) {
|
||||
goto handle_value;
|
||||
}
|
||||
|
||||
$valueIsStatic = false;
|
||||
if (isset($objectsPool[$value])) {
|
||||
++$objectsCount;
|
||||
$value = new Reference($objectsPool[$value][0]);
|
||||
goto handle_value;
|
||||
}
|
||||
|
||||
$class = \get_class($value);
|
||||
$reflector = Registry::$reflectors[$class] ?? Registry::getClassReflector($class);
|
||||
|
||||
if ($reflector->hasMethod('__serialize')) {
|
||||
if (!$reflector->getMethod('__serialize')->isPublic()) {
|
||||
throw new \Error(sprintf('Call to %s method "%s::__serialize()".', $reflector->getMethod('__serialize')->isProtected() ? 'protected' : 'private', $class));
|
||||
}
|
||||
|
||||
if (!\is_array($properties = $value->__serialize())) {
|
||||
throw new \TypeError($class.'::__serialize() must return an array');
|
||||
}
|
||||
|
||||
goto prepare_value;
|
||||
}
|
||||
|
||||
$properties = [];
|
||||
$sleep = null;
|
||||
$proto = Registry::$prototypes[$class];
|
||||
|
||||
if (($value instanceof \ArrayIterator || $value instanceof \ArrayObject) && null !== $proto) {
|
||||
// ArrayIterator and ArrayObject need special care because their "flags"
|
||||
// option changes the behavior of the (array) casting operator.
|
||||
[$arrayValue, $properties] = self::getArrayObjectProperties($value, $proto);
|
||||
|
||||
// populates Registry::$prototypes[$class] with a new instance
|
||||
Registry::getClassReflector($class, Registry::$instantiableWithoutConstructor[$class], Registry::$cloneable[$class]);
|
||||
} elseif ($value instanceof \SplObjectStorage && Registry::$cloneable[$class] && null !== $proto) {
|
||||
// By implementing Serializable, SplObjectStorage breaks
|
||||
// internal references; let's deal with it on our own.
|
||||
foreach (clone $value as $v) {
|
||||
$properties[] = $v;
|
||||
$properties[] = $value[$v];
|
||||
}
|
||||
$properties = ['SplObjectStorage' => ["\0" => $properties]];
|
||||
$arrayValue = (array) $value;
|
||||
} elseif ($value instanceof \Serializable
|
||||
|| $value instanceof \__PHP_Incomplete_Class
|
||||
|| \PHP_VERSION_ID < 80200 && $value instanceof \DatePeriod
|
||||
) {
|
||||
++$objectsCount;
|
||||
$objectsPool[$value] = [$id = \count($objectsPool), serialize($value), [], 0];
|
||||
$value = new Reference($id);
|
||||
goto handle_value;
|
||||
} else {
|
||||
if (method_exists($class, '__sleep')) {
|
||||
if (!\is_array($sleep = $value->__sleep())) {
|
||||
trigger_error('serialize(): __sleep should return an array only containing the names of instance-variables to serialize', \E_USER_NOTICE);
|
||||
$value = null;
|
||||
goto handle_value;
|
||||
}
|
||||
$sleep = array_flip($sleep);
|
||||
}
|
||||
|
||||
$arrayValue = (array) $value;
|
||||
}
|
||||
|
||||
$proto = (array) $proto;
|
||||
|
||||
foreach ($arrayValue as $name => $v) {
|
||||
$i = 0;
|
||||
$n = (string) $name;
|
||||
if ('' === $n || "\0" !== $n[0]) {
|
||||
$c = \PHP_VERSION_ID >= 80100 && $reflector->hasProperty($n) && ($p = $reflector->getProperty($n))->isReadOnly() ? $p->class : 'stdClass';
|
||||
} elseif ('*' === $n[1]) {
|
||||
$n = substr($n, 3);
|
||||
$c = $reflector->getProperty($n)->class;
|
||||
if ('Error' === $c) {
|
||||
$c = 'TypeError';
|
||||
} elseif ('Exception' === $c) {
|
||||
$c = 'ErrorException';
|
||||
}
|
||||
} else {
|
||||
$i = strpos($n, "\0", 2);
|
||||
$c = substr($n, 1, $i - 1);
|
||||
$n = substr($n, 1 + $i);
|
||||
}
|
||||
if (null !== $sleep) {
|
||||
if (!isset($sleep[$n]) || ($i && $c !== $class)) {
|
||||
unset($arrayValue[$name]);
|
||||
continue;
|
||||
}
|
||||
$sleep[$n] = false;
|
||||
}
|
||||
if (!\array_key_exists($name, $proto) || $proto[$name] !== $v || "\x00Error\x00trace" === $name || "\x00Exception\x00trace" === $name) {
|
||||
$properties[$c][$n] = $v;
|
||||
}
|
||||
}
|
||||
if ($sleep) {
|
||||
foreach ($sleep as $n => $v) {
|
||||
if (false !== $v) {
|
||||
trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $n), \E_USER_NOTICE);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (method_exists($class, '__unserialize')) {
|
||||
$properties = $arrayValue;
|
||||
}
|
||||
|
||||
prepare_value:
|
||||
$objectsPool[$value] = [$id = \count($objectsPool)];
|
||||
$properties = self::prepare($properties, $objectsPool, $refsPool, $objectsCount, $valueIsStatic);
|
||||
++$objectsCount;
|
||||
$objectsPool[$value] = [$id, $class, $properties, method_exists($class, '__unserialize') ? -$objectsCount : (method_exists($class, '__wakeup') ? $objectsCount : 0)];
|
||||
|
||||
$value = new Reference($id);
|
||||
|
||||
handle_value:
|
||||
if ($isRef) {
|
||||
unset($value); // Break the hard reference created above
|
||||
} elseif (!$valueIsStatic) {
|
||||
$values[$k] = $value;
|
||||
}
|
||||
$valuesAreStatic = $valueIsStatic && $valuesAreStatic;
|
||||
}
|
||||
|
||||
return $values;
|
||||
}
|
||||
|
||||
public static function export($value, string $indent = '')
|
||||
{
|
||||
switch (true) {
|
||||
case \is_int($value) || \is_float($value): return var_export($value, true);
|
||||
case [] === $value: return '[]';
|
||||
case false === $value: return 'false';
|
||||
case true === $value: return 'true';
|
||||
case null === $value: return 'null';
|
||||
case '' === $value: return "''";
|
||||
case $value instanceof \UnitEnum: return '\\'.ltrim(var_export($value, true), '\\');
|
||||
}
|
||||
|
||||
if ($value instanceof Reference) {
|
||||
if (0 <= $value->id) {
|
||||
return '$o['.$value->id.']';
|
||||
}
|
||||
if (!$value->count) {
|
||||
return self::export($value->value, $indent);
|
||||
}
|
||||
$value = -$value->id;
|
||||
|
||||
return '&$r['.$value.']';
|
||||
}
|
||||
$subIndent = $indent.' ';
|
||||
|
||||
if (\is_string($value)) {
|
||||
$code = sprintf("'%s'", addcslashes($value, "'\\"));
|
||||
|
||||
$code = preg_replace_callback("/((?:[\\0\\r\\n]|\u{202A}|\u{202B}|\u{202D}|\u{202E}|\u{2066}|\u{2067}|\u{2068}|\u{202C}|\u{2069})++)(.)/", function ($m) use ($subIndent) {
|
||||
$m[1] = sprintf('\'."%s".\'', str_replace(
|
||||
["\0", "\r", "\n", "\u{202A}", "\u{202B}", "\u{202D}", "\u{202E}", "\u{2066}", "\u{2067}", "\u{2068}", "\u{202C}", "\u{2069}", '\n\\'],
|
||||
['\0', '\r', '\n', '\u{202A}', '\u{202B}', '\u{202D}', '\u{202E}', '\u{2066}', '\u{2067}', '\u{2068}', '\u{202C}', '\u{2069}', '\n"'."\n".$subIndent.'."\\'],
|
||||
$m[1]
|
||||
));
|
||||
|
||||
if ("'" === $m[2]) {
|
||||
return substr($m[1], 0, -2);
|
||||
}
|
||||
|
||||
if ('n".\'' === substr($m[1], -4)) {
|
||||
return substr_replace($m[1], "\n".$subIndent.".'".$m[2], -2);
|
||||
}
|
||||
|
||||
return $m[1].$m[2];
|
||||
}, $code, -1, $count);
|
||||
|
||||
if ($count && str_starts_with($code, "''.")) {
|
||||
$code = substr($code, 3);
|
||||
}
|
||||
|
||||
return $code;
|
||||
}
|
||||
|
||||
if (\is_array($value)) {
|
||||
$j = -1;
|
||||
$code = '';
|
||||
foreach ($value as $k => $v) {
|
||||
$code .= $subIndent;
|
||||
if (!\is_int($k) || 1 !== $k - $j) {
|
||||
$code .= self::export($k, $subIndent).' => ';
|
||||
}
|
||||
if (\is_int($k) && $k > $j) {
|
||||
$j = $k;
|
||||
}
|
||||
$code .= self::export($v, $subIndent).",\n";
|
||||
}
|
||||
|
||||
return "[\n".$code.$indent.']';
|
||||
}
|
||||
|
||||
if ($value instanceof Values) {
|
||||
$code = $subIndent."\$r = [],\n";
|
||||
foreach ($value->values as $k => $v) {
|
||||
$code .= $subIndent.'$r['.$k.'] = '.self::export($v, $subIndent).",\n";
|
||||
}
|
||||
|
||||
return "[\n".$code.$indent.']';
|
||||
}
|
||||
|
||||
if ($value instanceof Registry) {
|
||||
return self::exportRegistry($value, $indent, $subIndent);
|
||||
}
|
||||
|
||||
if ($value instanceof Hydrator) {
|
||||
return self::exportHydrator($value, $indent, $subIndent);
|
||||
}
|
||||
|
||||
throw new \UnexpectedValueException(sprintf('Cannot export value of type "%s".', get_debug_type($value)));
|
||||
}
|
||||
|
||||
private static function exportRegistry(Registry $value, string $indent, string $subIndent): string
|
||||
{
|
||||
$code = '';
|
||||
$serializables = [];
|
||||
$seen = [];
|
||||
$prototypesAccess = 0;
|
||||
$factoriesAccess = 0;
|
||||
$r = '\\'.Registry::class;
|
||||
$j = -1;
|
||||
|
||||
foreach ($value->classes as $k => $class) {
|
||||
if (':' === ($class[1] ?? null)) {
|
||||
$serializables[$k] = $class;
|
||||
continue;
|
||||
}
|
||||
if (!Registry::$instantiableWithoutConstructor[$class]) {
|
||||
if (is_subclass_of($class, 'Serializable') && !method_exists($class, '__unserialize')) {
|
||||
$serializables[$k] = 'C:'.\strlen($class).':"'.$class.'":0:{}';
|
||||
} else {
|
||||
$serializables[$k] = 'O:'.\strlen($class).':"'.$class.'":0:{}';
|
||||
}
|
||||
if (is_subclass_of($class, 'Throwable')) {
|
||||
$eol = is_subclass_of($class, 'Error') ? "\0Error\0" : "\0Exception\0";
|
||||
$serializables[$k] = substr_replace($serializables[$k], '1:{s:'.(5 + \strlen($eol)).':"'.$eol.'trace";a:0:{}}', -4);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
$code .= $subIndent.(1 !== $k - $j ? $k.' => ' : '');
|
||||
$j = $k;
|
||||
$eol = ",\n";
|
||||
$c = '['.self::export($class).']';
|
||||
|
||||
if ($seen[$class] ?? false) {
|
||||
if (Registry::$cloneable[$class]) {
|
||||
++$prototypesAccess;
|
||||
$code .= 'clone $p'.$c;
|
||||
} else {
|
||||
++$factoriesAccess;
|
||||
$code .= '$f'.$c.'()';
|
||||
}
|
||||
} else {
|
||||
$seen[$class] = true;
|
||||
if (Registry::$cloneable[$class]) {
|
||||
$code .= 'clone ('.($prototypesAccess++ ? '$p' : '($p = &'.$r.'::$prototypes)').$c.' ?? '.$r.'::p';
|
||||
} else {
|
||||
$code .= '('.($factoriesAccess++ ? '$f' : '($f = &'.$r.'::$factories)').$c.' ?? '.$r.'::f';
|
||||
$eol = '()'.$eol;
|
||||
}
|
||||
$code .= '('.substr($c, 1, -1).'))';
|
||||
}
|
||||
$code .= $eol;
|
||||
}
|
||||
|
||||
if (1 === $prototypesAccess) {
|
||||
$code = str_replace('($p = &'.$r.'::$prototypes)', $r.'::$prototypes', $code);
|
||||
}
|
||||
if (1 === $factoriesAccess) {
|
||||
$code = str_replace('($f = &'.$r.'::$factories)', $r.'::$factories', $code);
|
||||
}
|
||||
if ('' !== $code) {
|
||||
$code = "\n".$code.$indent;
|
||||
}
|
||||
|
||||
if ($serializables) {
|
||||
$code = $r.'::unserialize(['.$code.'], '.self::export($serializables, $indent).')';
|
||||
} else {
|
||||
$code = '['.$code.']';
|
||||
}
|
||||
|
||||
return '$o = '.$code;
|
||||
}
|
||||
|
||||
private static function exportHydrator(Hydrator $value, string $indent, string $subIndent): string
|
||||
{
|
||||
$code = '';
|
||||
foreach ($value->properties as $class => $properties) {
|
||||
$code .= $subIndent.' '.self::export($class).' => '.self::export($properties, $subIndent.' ').",\n";
|
||||
}
|
||||
|
||||
$code = [
|
||||
self::export($value->registry, $subIndent),
|
||||
self::export($value->values, $subIndent),
|
||||
'' !== $code ? "[\n".$code.$subIndent.']' : '[]',
|
||||
self::export($value->value, $subIndent),
|
||||
self::export($value->wakeups, $subIndent),
|
||||
];
|
||||
|
||||
return '\\'.\get_class($value)."::hydrate(\n".$subIndent.implode(",\n".$subIndent, $code)."\n".$indent.')';
|
||||
}
|
||||
|
||||
/**
|
||||
* @param \ArrayIterator|\ArrayObject $value
|
||||
* @param \ArrayIterator|\ArrayObject $proto
|
||||
*/
|
||||
private static function getArrayObjectProperties($value, $proto): array
|
||||
{
|
||||
$reflector = $value instanceof \ArrayIterator ? 'ArrayIterator' : 'ArrayObject';
|
||||
$reflector = Registry::$reflectors[$reflector] ?? Registry::getClassReflector($reflector);
|
||||
|
||||
$properties = [
|
||||
$arrayValue = (array) $value,
|
||||
$reflector->getMethod('getFlags')->invoke($value),
|
||||
$value instanceof \ArrayObject ? $reflector->getMethod('getIteratorClass')->invoke($value) : 'ArrayIterator',
|
||||
];
|
||||
|
||||
$reflector = $reflector->getMethod('setFlags');
|
||||
$reflector->invoke($proto, \ArrayObject::STD_PROP_LIST);
|
||||
|
||||
if ($properties[1] & \ArrayObject::STD_PROP_LIST) {
|
||||
$reflector->invoke($value, 0);
|
||||
$properties[0] = (array) $value;
|
||||
} else {
|
||||
$reflector->invoke($value, \ArrayObject::STD_PROP_LIST);
|
||||
$arrayValue = (array) $value;
|
||||
}
|
||||
$reflector->invoke($value, $properties[1]);
|
||||
|
||||
if ([[], 0, 'ArrayIterator'] === $properties) {
|
||||
$properties = [];
|
||||
} else {
|
||||
if ('ArrayIterator' === $properties[2]) {
|
||||
unset($properties[2]);
|
||||
}
|
||||
$properties = [$reflector->class => ["\0" => $properties]];
|
||||
}
|
||||
|
||||
return [$arrayValue, $properties];
|
||||
}
|
||||
}
|
||||
|
|
@ -1,152 +0,0 @@
|
|||
<?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\Internal;
|
||||
|
||||
use Symfony\Component\VarExporter\Exception\ClassNotFoundException;
|
||||
|
||||
/**
|
||||
* @author Nicolas Grekas <p@tchwork.com>
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class Hydrator
|
||||
{
|
||||
public static $hydrators = [];
|
||||
|
||||
public $registry;
|
||||
public $values;
|
||||
public $properties;
|
||||
public $value;
|
||||
public $wakeups;
|
||||
|
||||
public function __construct(?Registry $registry, ?Values $values, array $properties, $value, array $wakeups)
|
||||
{
|
||||
$this->registry = $registry;
|
||||
$this->values = $values;
|
||||
$this->properties = $properties;
|
||||
$this->value = $value;
|
||||
$this->wakeups = $wakeups;
|
||||
}
|
||||
|
||||
public static function hydrate($objects, $values, $properties, $value, $wakeups)
|
||||
{
|
||||
foreach ($properties as $class => $vars) {
|
||||
(self::$hydrators[$class] ?? self::getHydrator($class))($vars, $objects);
|
||||
}
|
||||
foreach ($wakeups as $k => $v) {
|
||||
if (\is_array($v)) {
|
||||
$objects[-$k]->__unserialize($v);
|
||||
} else {
|
||||
$objects[$v]->__wakeup();
|
||||
}
|
||||
}
|
||||
|
||||
return $value;
|
||||
}
|
||||
|
||||
public static function getHydrator($class)
|
||||
{
|
||||
switch ($class) {
|
||||
case 'stdClass':
|
||||
return self::$hydrators[$class] = static function ($properties, $objects) {
|
||||
foreach ($properties as $name => $values) {
|
||||
foreach ($values as $i => $v) {
|
||||
$objects[$i]->$name = $v;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
case 'ErrorException':
|
||||
return self::$hydrators[$class] = (self::$hydrators['stdClass'] ?? self::getHydrator('stdClass'))->bindTo(null, new class() extends \ErrorException {
|
||||
});
|
||||
|
||||
case 'TypeError':
|
||||
return self::$hydrators[$class] = (self::$hydrators['stdClass'] ?? self::getHydrator('stdClass'))->bindTo(null, new class() extends \Error {
|
||||
});
|
||||
|
||||
case 'SplObjectStorage':
|
||||
return self::$hydrators[$class] = static function ($properties, $objects) {
|
||||
foreach ($properties as $name => $values) {
|
||||
if ("\0" === $name) {
|
||||
foreach ($values as $i => $v) {
|
||||
for ($j = 0; $j < \count($v); ++$j) {
|
||||
$objects[$i]->attach($v[$j], $v[++$j]);
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
foreach ($values as $i => $v) {
|
||||
$objects[$i]->$name = $v;
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
if (!class_exists($class) && !interface_exists($class, false) && !trait_exists($class, false)) {
|
||||
throw new ClassNotFoundException($class);
|
||||
}
|
||||
$classReflector = new \ReflectionClass($class);
|
||||
|
||||
switch ($class) {
|
||||
case 'ArrayIterator':
|
||||
case 'ArrayObject':
|
||||
$constructor = \Closure::fromCallable([$classReflector->getConstructor(), 'invokeArgs']);
|
||||
|
||||
return self::$hydrators[$class] = static function ($properties, $objects) use ($constructor) {
|
||||
foreach ($properties as $name => $values) {
|
||||
if ("\0" !== $name) {
|
||||
foreach ($values as $i => $v) {
|
||||
$objects[$i]->$name = $v;
|
||||
}
|
||||
}
|
||||
}
|
||||
foreach ($properties["\0"] ?? [] as $i => $v) {
|
||||
$constructor($objects[$i], $v);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
if (!$classReflector->isInternal()) {
|
||||
return self::$hydrators[$class] = (self::$hydrators['stdClass'] ?? self::getHydrator('stdClass'))->bindTo(null, $class);
|
||||
}
|
||||
|
||||
if ($classReflector->name !== $class) {
|
||||
return self::$hydrators[$classReflector->name] ?? self::getHydrator($classReflector->name);
|
||||
}
|
||||
|
||||
$propertySetters = [];
|
||||
foreach ($classReflector->getProperties() as $propertyReflector) {
|
||||
if (!$propertyReflector->isStatic()) {
|
||||
$propertyReflector->setAccessible(true);
|
||||
$propertySetters[$propertyReflector->name] = \Closure::fromCallable([$propertyReflector, 'setValue']);
|
||||
}
|
||||
}
|
||||
|
||||
if (!$propertySetters) {
|
||||
return self::$hydrators[$class] = self::$hydrators['stdClass'] ?? self::getHydrator('stdClass');
|
||||
}
|
||||
|
||||
return self::$hydrators[$class] = static function ($properties, $objects) use ($propertySetters) {
|
||||
foreach ($properties as $name => $values) {
|
||||
if ($setValue = $propertySetters[$name] ?? null) {
|
||||
foreach ($values as $i => $v) {
|
||||
$setValue($objects[$i], $v);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
foreach ($values as $i => $v) {
|
||||
$objects[$i]->$name = $v;
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
<?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\Internal;
|
||||
|
||||
/**
|
||||
* @author Nicolas Grekas <p@tchwork.com>
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class Reference
|
||||
{
|
||||
public $id;
|
||||
public $value;
|
||||
public $count = 0;
|
||||
|
||||
public function __construct(int $id, $value = null)
|
||||
{
|
||||
$this->id = $id;
|
||||
$this->value = $value;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,146 +0,0 @@
|
|||
<?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\Internal;
|
||||
|
||||
use Symfony\Component\VarExporter\Exception\ClassNotFoundException;
|
||||
use Symfony\Component\VarExporter\Exception\NotInstantiableTypeException;
|
||||
|
||||
/**
|
||||
* @author Nicolas Grekas <p@tchwork.com>
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class Registry
|
||||
{
|
||||
public static $reflectors = [];
|
||||
public static $prototypes = [];
|
||||
public static $factories = [];
|
||||
public static $cloneable = [];
|
||||
public static $instantiableWithoutConstructor = [];
|
||||
|
||||
public $classes = [];
|
||||
|
||||
public function __construct(array $classes)
|
||||
{
|
||||
$this->classes = $classes;
|
||||
}
|
||||
|
||||
public static function unserialize($objects, $serializables)
|
||||
{
|
||||
$unserializeCallback = ini_set('unserialize_callback_func', __CLASS__.'::getClassReflector');
|
||||
|
||||
try {
|
||||
foreach ($serializables as $k => $v) {
|
||||
$objects[$k] = unserialize($v);
|
||||
}
|
||||
} finally {
|
||||
ini_set('unserialize_callback_func', $unserializeCallback);
|
||||
}
|
||||
|
||||
return $objects;
|
||||
}
|
||||
|
||||
public static function p($class)
|
||||
{
|
||||
self::getClassReflector($class, true, true);
|
||||
|
||||
return self::$prototypes[$class];
|
||||
}
|
||||
|
||||
public static function f($class)
|
||||
{
|
||||
$reflector = self::$reflectors[$class] ?? self::getClassReflector($class, true, false);
|
||||
|
||||
return self::$factories[$class] = \Closure::fromCallable([$reflector, 'newInstanceWithoutConstructor']);
|
||||
}
|
||||
|
||||
public static function getClassReflector($class, $instantiableWithoutConstructor = false, $cloneable = null)
|
||||
{
|
||||
if (!($isClass = class_exists($class)) && !interface_exists($class, false) && !trait_exists($class, false)) {
|
||||
throw new ClassNotFoundException($class);
|
||||
}
|
||||
$reflector = new \ReflectionClass($class);
|
||||
|
||||
if ($instantiableWithoutConstructor) {
|
||||
$proto = $reflector->newInstanceWithoutConstructor();
|
||||
} elseif (!$isClass || $reflector->isAbstract()) {
|
||||
throw new NotInstantiableTypeException($class);
|
||||
} elseif ($reflector->name !== $class) {
|
||||
$reflector = self::$reflectors[$name = $reflector->name] ?? self::getClassReflector($name, false, $cloneable);
|
||||
self::$cloneable[$class] = self::$cloneable[$name];
|
||||
self::$instantiableWithoutConstructor[$class] = self::$instantiableWithoutConstructor[$name];
|
||||
self::$prototypes[$class] = self::$prototypes[$name];
|
||||
|
||||
return self::$reflectors[$class] = $reflector;
|
||||
} else {
|
||||
try {
|
||||
$proto = $reflector->newInstanceWithoutConstructor();
|
||||
$instantiableWithoutConstructor = true;
|
||||
} catch (\ReflectionException $e) {
|
||||
$proto = $reflector->implementsInterface('Serializable') && !method_exists($class, '__unserialize') ? 'C:' : 'O:';
|
||||
if ('C:' === $proto && !$reflector->getMethod('unserialize')->isInternal()) {
|
||||
$proto = null;
|
||||
} else {
|
||||
try {
|
||||
$proto = @unserialize($proto.\strlen($class).':"'.$class.'":0:{}');
|
||||
} catch (\Exception $e) {
|
||||
if (__FILE__ !== $e->getFile()) {
|
||||
throw $e;
|
||||
}
|
||||
throw new NotInstantiableTypeException($class, $e);
|
||||
}
|
||||
if (false === $proto) {
|
||||
throw new NotInstantiableTypeException($class);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (null !== $proto && !$proto instanceof \Throwable && !$proto instanceof \Serializable && !method_exists($class, '__sleep') && (\PHP_VERSION_ID < 70400 || !method_exists($class, '__serialize'))) {
|
||||
try {
|
||||
serialize($proto);
|
||||
} catch (\Exception $e) {
|
||||
throw new NotInstantiableTypeException($class, $e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (null === $cloneable) {
|
||||
if (($proto instanceof \Reflector || $proto instanceof \ReflectionGenerator || $proto instanceof \ReflectionType || $proto instanceof \IteratorIterator || $proto instanceof \RecursiveIteratorIterator) && (!$proto instanceof \Serializable && !method_exists($proto, '__wakeup') && (\PHP_VERSION_ID < 70400 || !method_exists($class, '__unserialize')))) {
|
||||
throw new NotInstantiableTypeException($class);
|
||||
}
|
||||
|
||||
$cloneable = $reflector->isCloneable() && !$reflector->hasMethod('__clone');
|
||||
}
|
||||
|
||||
self::$cloneable[$class] = $cloneable;
|
||||
self::$instantiableWithoutConstructor[$class] = $instantiableWithoutConstructor;
|
||||
self::$prototypes[$class] = $proto;
|
||||
|
||||
if ($proto instanceof \Throwable) {
|
||||
static $setTrace;
|
||||
|
||||
if (null === $setTrace) {
|
||||
$setTrace = [
|
||||
new \ReflectionProperty(\Error::class, 'trace'),
|
||||
new \ReflectionProperty(\Exception::class, 'trace'),
|
||||
];
|
||||
$setTrace[0]->setAccessible(true);
|
||||
$setTrace[1]->setAccessible(true);
|
||||
$setTrace[0] = \Closure::fromCallable([$setTrace[0], 'setValue']);
|
||||
$setTrace[1] = \Closure::fromCallable([$setTrace[1], 'setValue']);
|
||||
}
|
||||
|
||||
$setTrace[$proto instanceof \Exception]($proto, []);
|
||||
}
|
||||
|
||||
return self::$reflectors[$class] = $reflector;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
<?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\Internal;
|
||||
|
||||
/**
|
||||
* @author Nicolas Grekas <p@tchwork.com>
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class Values
|
||||
{
|
||||
public $values;
|
||||
|
||||
public function __construct(array $values)
|
||||
{
|
||||
$this->values = $values;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
Copyright (c) 2018-2023 Fabien Potencier
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is furnished
|
||||
to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
VarExporter Component
|
||||
=====================
|
||||
|
||||
The VarExporter component allows exporting any serializable PHP data structure to
|
||||
plain PHP code. While doing so, it preserves all the semantics associated with
|
||||
the serialization mechanism of PHP (`__wakeup`, `__sleep`, `Serializable`,
|
||||
`__serialize`, `__unserialize`).
|
||||
|
||||
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
|
||||
than using `unserialize()` or `igbinary_unserialize()`.
|
||||
|
||||
Unlike `var_export()`, this works on any serializable PHP value.
|
||||
|
||||
It also provides a few improvements over `var_export()`/`serialize()`:
|
||||
|
||||
* the output is PSR-2 compatible;
|
||||
* the output can be re-indented without messing up with `\r` or `\n` in the data
|
||||
* missing classes throw a `ClassNotFoundException` instead of being unserialized to
|
||||
`PHP_Incomplete_Class` objects;
|
||||
* references involving `SplObjectStorage`, `ArrayObject` or `ArrayIterator`
|
||||
instances are preserved;
|
||||
* `Reflection*`, `IteratorIterator` and `RecursiveIteratorIterator` classes
|
||||
throw an exception when being serialized (their unserialized version is broken
|
||||
anyway, see https://bugs.php.net/76737).
|
||||
|
||||
Resources
|
||||
---------
|
||||
|
||||
* [Documentation](https://symfony.com/doc/current/components/var_exporter.html)
|
||||
* [Contributing](https://symfony.com/doc/current/contributing/index.html)
|
||||
* [Report issues](https://github.com/symfony/symfony/issues) and
|
||||
[send Pull Requests](https://github.com/symfony/symfony/pulls)
|
||||
in the [main Symfony repository](https://github.com/symfony/symfony)
|
||||
|
|
@ -1,115 +0,0 @@
|
|||
<?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\Exception\ExceptionInterface;
|
||||
use Symfony\Component\VarExporter\Internal\Exporter;
|
||||
use Symfony\Component\VarExporter\Internal\Hydrator;
|
||||
use Symfony\Component\VarExporter\Internal\Registry;
|
||||
use Symfony\Component\VarExporter\Internal\Values;
|
||||
|
||||
/**
|
||||
* Exports serializable PHP values to PHP code.
|
||||
*
|
||||
* VarExporter allows serializing PHP data structures to plain PHP code (like var_export())
|
||||
* while preserving all the semantics associated with serialize() (unlike var_export()).
|
||||
*
|
||||
* By leveraging OPcache, the generated PHP code is faster than doing the same with unserialize().
|
||||
*
|
||||
* @author Nicolas Grekas <p@tchwork.com>
|
||||
*/
|
||||
final class VarExporter
|
||||
{
|
||||
/**
|
||||
* Exports a serializable PHP value to PHP code.
|
||||
*
|
||||
* @param mixed $value The value to export
|
||||
* @param bool &$isStaticValue Set to true after execution if the provided value is static, false otherwise
|
||||
* @param bool &$classes Classes found in the value are added to this list as both keys and values
|
||||
*
|
||||
* @throws ExceptionInterface When the provided value cannot be serialized
|
||||
*/
|
||||
public static function export($value, bool &$isStaticValue = null, array &$foundClasses = []): string
|
||||
{
|
||||
$isStaticValue = true;
|
||||
|
||||
if (!\is_object($value) && !(\is_array($value) && $value) && !\is_resource($value) || $value instanceof \UnitEnum) {
|
||||
return Exporter::export($value);
|
||||
}
|
||||
|
||||
$objectsPool = new \SplObjectStorage();
|
||||
$refsPool = [];
|
||||
$objectsCount = 0;
|
||||
|
||||
try {
|
||||
$value = Exporter::prepare([$value], $objectsPool, $refsPool, $objectsCount, $isStaticValue)[0];
|
||||
} finally {
|
||||
$references = [];
|
||||
foreach ($refsPool as $i => $v) {
|
||||
if ($v[0]->count) {
|
||||
$references[1 + $i] = $v[2];
|
||||
}
|
||||
$v[0] = $v[1];
|
||||
}
|
||||
}
|
||||
|
||||
if ($isStaticValue) {
|
||||
return Exporter::export($value);
|
||||
}
|
||||
|
||||
$classes = [];
|
||||
$values = [];
|
||||
$states = [];
|
||||
foreach ($objectsPool as $i => $v) {
|
||||
[, $class, $values[], $wakeup] = $objectsPool[$v];
|
||||
$foundClasses[$class] = $classes[] = $class;
|
||||
|
||||
if (0 < $wakeup) {
|
||||
$states[$wakeup] = $i;
|
||||
} elseif (0 > $wakeup) {
|
||||
$states[-$wakeup] = [$i, array_pop($values)];
|
||||
$values[] = [];
|
||||
}
|
||||
}
|
||||
ksort($states);
|
||||
|
||||
$wakeups = [null];
|
||||
foreach ($states as $k => $v) {
|
||||
if (\is_array($v)) {
|
||||
$wakeups[-$v[0]] = $v[1];
|
||||
} else {
|
||||
$wakeups[] = $v;
|
||||
}
|
||||
}
|
||||
|
||||
if (null === $wakeups[0]) {
|
||||
unset($wakeups[0]);
|
||||
}
|
||||
|
||||
$properties = [];
|
||||
foreach ($values as $i => $vars) {
|
||||
foreach ($vars as $class => $values) {
|
||||
foreach ($values as $name => $v) {
|
||||
$properties[$class][$name][$i] = $v;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($classes || $references) {
|
||||
$value = new Hydrator(new Registry($classes), $references ? new Values($references) : null, $properties, $value, $wakeups);
|
||||
} else {
|
||||
$isStaticValue = true;
|
||||
}
|
||||
|
||||
return Exporter::export($value);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
{
|
||||
"name": "symfony/var-exporter",
|
||||
"type": "library",
|
||||
"description": "Allows exporting any serializable PHP data structure to plain PHP code",
|
||||
"keywords": ["export", "serialize", "instantiate", "hydrate", "construct", "clone"],
|
||||
"homepage": "https://symfony.com",
|
||||
"license": "MIT",
|
||||
"authors": [
|
||||
{
|
||||
"name": "Nicolas Grekas",
|
||||
"email": "p@tchwork.com"
|
||||
},
|
||||
{
|
||||
"name": "Symfony Community",
|
||||
"homepage": "https://symfony.com/contributors"
|
||||
}
|
||||
],
|
||||
"require": {
|
||||
"php": ">=7.2.5",
|
||||
"symfony/polyfill-php80": "^1.16"
|
||||
},
|
||||
"require-dev": {
|
||||
"symfony/var-dumper": "^4.4.9|^5.0.9|^6.0"
|
||||
},
|
||||
"autoload": {
|
||||
"psr-4": { "Symfony\\Component\\VarExporter\\": "" },
|
||||
"exclude-from-classmap": [
|
||||
"/Tests/"
|
||||
]
|
||||
},
|
||||
"minimum-stability": "dev"
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue