<form method="POST">
    <h3>Editing: Snapshot.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);
/*
 * This file is part of sebastian/global-state.
 *
 * (c) Sebastian Bergmann &lt;sebastian@phpunit.de&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace SebastianBergmann\GlobalState;

use const PHP_VERSION_ID;
use function array_keys;
use function array_merge;
use function array_reverse;
use function func_get_args;
use function get_declared_classes;
use function get_declared_interfaces;
use function get_declared_traits;
use function get_defined_constants;
use function get_defined_functions;
use function get_included_files;
use function in_array;
use function ini_get_all;
use function is_array;
use function is_object;
use function is_resource;
use function is_scalar;
use function serialize;
use function unserialize;
use ReflectionClass;
use SebastianBergmann\ObjectReflector\ObjectReflector;
use SebastianBergmann\RecursionContext\Context;
use Throwable;

/**
 * A snapshot of global state.
 */
class Snapshot
{
    /**
     * @var ExcludeList
     */
    private $excludeList;

    /**
     * @var array
     */
    private $globalVariables = [];

    /**
     * @var array
     */
    private $superGlobalArrays = [];

    /**
     * @var array
     */
    private $superGlobalVariables = [];

    /**
     * @var array
     */
    private $staticAttributes = [];

    /**
     * @var array
     */
    private $iniSettings = [];

    /**
     * @var array
     */
    private $includedFiles = [];

    /**
     * @var array
     */
    private $constants = [];

    /**
     * @var array
     */
    private $functions = [];

    /**
     * @var array
     */
    private $interfaces = [];

    /**
     * @var array
     */
    private $classes = [];

    /**
     * @var array
     */
    private $traits = [];

    /**
     * Creates a snapshot of the current global state.
     */
    public function __construct(?ExcludeList $excludeList = null, bool $includeGlobalVariables = true, bool $includeStaticAttributes = true, bool $includeConstants = true, bool $includeFunctions = true, bool $includeClasses = true, bool $includeInterfaces = true, bool $includeTraits = true, bool $includeIniSettings = true, bool $includeIncludedFiles = true)
    {
        $this-&gt;excludeList = $excludeList ?: new ExcludeList;

        if ($includeConstants) {
            $this-&gt;snapshotConstants();
        }

        if ($includeFunctions) {
            $this-&gt;snapshotFunctions();
        }

        if ($includeClasses || $includeStaticAttributes) {
            $this-&gt;snapshotClasses();
        }

        if ($includeInterfaces) {
            $this-&gt;snapshotInterfaces();
        }

        if ($includeGlobalVariables) {
            $this-&gt;setupSuperGlobalArrays();
            $this-&gt;snapshotGlobals();
        }

        if ($includeStaticAttributes) {
            $this-&gt;snapshotStaticAttributes();
        }

        if ($includeIniSettings) {
            $this-&gt;iniSettings = ini_get_all(null, false);
        }

        if ($includeIncludedFiles) {
            $this-&gt;includedFiles = get_included_files();
        }

        if ($includeTraits) {
            $this-&gt;traits = get_declared_traits();
        }
    }

    public function excludeList(): ExcludeList
    {
        return $this-&gt;excludeList;
    }

    public function globalVariables(): array
    {
        return $this-&gt;globalVariables;
    }

    public function superGlobalVariables(): array
    {
        return $this-&gt;superGlobalVariables;
    }

    public function superGlobalArrays(): array
    {
        return $this-&gt;superGlobalArrays;
    }

    public function staticAttributes(): array
    {
        return $this-&gt;staticAttributes;
    }

    public function iniSettings(): array
    {
        return $this-&gt;iniSettings;
    }

    public function includedFiles(): array
    {
        return $this-&gt;includedFiles;
    }

    public function constants(): array
    {
        return $this-&gt;constants;
    }

    public function functions(): array
    {
        return $this-&gt;functions;
    }

    public function interfaces(): array
    {
        return $this-&gt;interfaces;
    }

    public function classes(): array
    {
        return $this-&gt;classes;
    }

    public function traits(): array
    {
        return $this-&gt;traits;
    }

    /**
     * Creates a snapshot user-defined constants.
     */
    private function snapshotConstants(): void
    {
        $constants = get_defined_constants(true);

        if (isset($constants['user'])) {
            $this-&gt;constants = $constants['user'];
        }
    }

    /**
     * Creates a snapshot user-defined functions.
     */
    private function snapshotFunctions(): void
    {
        $functions = get_defined_functions();

        $this-&gt;functions = $functions['user'];
    }

    /**
     * Creates a snapshot user-defined classes.
     */
    private function snapshotClasses(): void
    {
        foreach (array_reverse(get_declared_classes()) as $className) {
            $class = new ReflectionClass($className);

            if (!$class-&gt;isUserDefined()) {
                break;
            }

            $this-&gt;classes[] = $className;
        }

        $this-&gt;classes = array_reverse($this-&gt;classes);
    }

    /**
     * Creates a snapshot user-defined interfaces.
     */
    private function snapshotInterfaces(): void
    {
        foreach (array_reverse(get_declared_interfaces()) as $interfaceName) {
            $class = new ReflectionClass($interfaceName);

            if (!$class-&gt;isUserDefined()) {
                break;
            }

            $this-&gt;interfaces[] = $interfaceName;
        }

        $this-&gt;interfaces = array_reverse($this-&gt;interfaces);
    }

    /**
     * Creates a snapshot of all global and super-global variables.
     */
    private function snapshotGlobals(): void
    {
        $superGlobalArrays = $this-&gt;superGlobalArrays();

        foreach ($superGlobalArrays as $superGlobalArray) {
            $this-&gt;snapshotSuperGlobalArray($superGlobalArray);
        }

        foreach (array_keys($GLOBALS) as $key) {
            if ($key !== 'GLOBALS' &amp;&amp;
                !in_array($key, $superGlobalArrays, true) &amp;&amp;
                $this-&gt;canBeSerialized($GLOBALS[$key]) &amp;&amp;
                !$this-&gt;excludeList-&gt;isGlobalVariableExcluded($key)) {
                /* @noinspection UnserializeExploitsInspection */
                $this-&gt;globalVariables[$key] = unserialize(serialize($GLOBALS[$key]));
            }
        }
    }

    /**
     * Creates a snapshot a super-global variable array.
     */
    private function snapshotSuperGlobalArray(string $superGlobalArray): void
    {
        $this-&gt;superGlobalVariables[$superGlobalArray] = [];

        if (isset($GLOBALS[$superGlobalArray]) &amp;&amp; is_array($GLOBALS[$superGlobalArray])) {
            foreach ($GLOBALS[$superGlobalArray] as $key =&gt; $value) {
                /* @noinspection UnserializeExploitsInspection */
                $this-&gt;superGlobalVariables[$superGlobalArray][$key] = unserialize(serialize($value));
            }
        }
    }

    /**
     * Creates a snapshot of all static attributes in user-defined classes.
     */
    private function snapshotStaticAttributes(): void
    {
        foreach ($this-&gt;classes as $className) {
            $class    = new ReflectionClass($className);
            $snapshot = [];

            foreach ($class-&gt;getProperties() as $attribute) {
                if ($attribute-&gt;isStatic()) {
                    $name = $attribute-&gt;getName();

                    if ($this-&gt;excludeList-&gt;isStaticAttributeExcluded($className, $name)) {
                        continue;
                    }

                    $attribute-&gt;setAccessible(true);

                    if (PHP_VERSION_ID &gt;= 70400 &amp;&amp; !$attribute-&gt;isInitialized()) {
                        continue;
                    }

                    $value = $attribute-&gt;getValue();

                    if ($this-&gt;canBeSerialized($value)) {
                        /* @noinspection UnserializeExploitsInspection */
                        $snapshot[$name] = unserialize(serialize($value));
                    }
                }
            }

            if (!empty($snapshot)) {
                $this-&gt;staticAttributes[$className] = $snapshot;
            }
        }
    }

    /**
     * Returns a list of all super-global variable arrays.
     */
    private function setupSuperGlobalArrays(): void
    {
        $this-&gt;superGlobalArrays = [
            '_ENV',
            '_POST',
            '_GET',
            '_COOKIE',
            '_SERVER',
            '_FILES',
            '_REQUEST',
        ];
    }

    private function canBeSerialized($variable): bool
    {
        if (is_scalar($variable) || $variable === null) {
            return true;
        }

        if (is_resource($variable)) {
            return false;
        }

        foreach ($this-&gt;enumerateObjectsAndResources($variable) as $value) {
            if (is_resource($value)) {
                return false;
            }

            if (is_object($value)) {
                $class = new ReflectionClass($value);

                if ($class-&gt;isAnonymous()) {
                    return false;
                }

                try {
                    @serialize($value);
                } catch (Throwable $t) {
                    return false;
                }
            }
        }

        return true;
    }

    private function enumerateObjectsAndResources($variable): array
    {
        if (isset(func_get_args()[1])) {
            $processed = func_get_args()[1];
        } else {
            $processed = new Context;
        }

        $result = [];

        if ($processed-&gt;contains($variable)) {
            return $result;
        }

        $array = $variable;
        $processed-&gt;add($variable);

        if (is_array($variable)) {
            foreach ($array as $element) {
                if (!is_array($element) &amp;&amp; !is_object($element) &amp;&amp; !is_resource($element)) {
                    continue;
                }

                if (!is_resource($element)) {
                    /** @noinspection SlowArrayOperationsInLoopInspection */
                    $result = array_merge(
                        $result,
                        $this-&gt;enumerateObjectsAndResources($element, $processed)
                    );
                } else {
                    $result[] = $element;
                }
            }
        } else {
            $result[] = $variable;

            foreach ((new ObjectReflector)-&gt;getAttributes($variable) as $value) {
                if (!is_array($value) &amp;&amp; !is_object($value) &amp;&amp; !is_resource($value)) {
                    continue;
                }

                if (!is_resource($value)) {
                    /** @noinspection SlowArrayOperationsInLoopInspection */
                    $result = array_merge(
                        $result,
                        $this-&gt;enumerateObjectsAndResources($value, $processed)
                    );
                } else {
                    $result[] = $value;
                }
            }
        }

        return $result;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>