init

backend/vendor/doctrine/migrations/src/SchemaDumper.php

@@ -0,0 +1,178 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Migrations;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Schema\AbstractSchemaManager;
+use Doctrine\DBAL\Schema\NamedObject;
+use Doctrine\DBAL\Schema\Table;
+use Doctrine\Migrations\Exception\NoTablesFound;
+use Doctrine\Migrations\Generator\Generator;
+use Doctrine\Migrations\Generator\SqlGenerator;
+use InvalidArgumentException;
+
+use function array_merge;
+use function count;
+use function implode;
+use function preg_last_error;
+use function preg_last_error_msg;
+use function preg_match;
+use function restore_error_handler;
+use function set_error_handler;
+use function sprintf;
+
+use const PREG_INTERNAL_ERROR;
+
+/**
+ * The SchemaDumper class is responsible for dumping the current state of your database schema to a migration. This
+ * is to be used in conjunction with the Rollup class.
+ *
+ * @internal
+ *
+ * @see Doctrine\Migrations\Rollup
+ */
+class SchemaDumper
+{
+    /**
+     * @param AbstractSchemaManager<AbstractPlatform> $schemaManager
+     * @param string[]                                $excludedTablesRegexes
+     */
+    public function __construct(
+        private readonly AbstractPlatform $platform,
+        private readonly AbstractSchemaManager $schemaManager,
+        private readonly Generator $migrationGenerator,
+        private readonly SqlGenerator $migrationSqlGenerator,
+        private readonly array $excludedTablesRegexes = [],
+    ) {
+    }
+
+    /**
+     * @param string[] $excludedTablesRegexes
+     *
+     * @throws NoTablesFound
+     */
+    public function dump(
+        string $fqcn,
+        array $excludedTablesRegexes = [],
+        bool $formatted = false,
+        bool|null $nowdocOutput = null,
+        int $lineLength = 120,
+    ): string {
+        $schema = $this->schemaManager->introspectSchema();
+
+        $up   = [];
+        $down = [];
+
+        foreach ($schema->getTables() as $table) {
+            if ($this->shouldSkipTable($table, $excludedTablesRegexes)) {
+                continue;
+            }
+
+            $upSql = $this->platform->getCreateTableSQL($table);
+
+            $upCode = $this->migrationSqlGenerator->generate(
+                $upSql,
+                $formatted,
+                $nowdocOutput,
+                $lineLength,
+            );
+
+            if ($upCode !== '') {
+                $up[] = $upCode;
+            }
+
+            /** @phpstan-ignore instanceof.alwaysTrue */
+            if ($table instanceof NamedObject) {
+                $tableName = $table->getObjectName()->toSQL($this->platform);
+            } else {
+                $tableName = $table->getName();
+            }
+
+            $downSql  = [$this->platform->getDropTableSQL($tableName)];
+            $downCode = $this->migrationSqlGenerator->generate(
+                $downSql,
+                $formatted,
+                $nowdocOutput,
+                $lineLength,
+            );
+
+            if ($downCode === '') {
+                continue;
+            }
+
+            $down[] = $downCode;
+        }
+
+        if (count($up) === 0) {
+            throw NoTablesFound::new();
+        }
+
+        $up   = implode("\n", $up);
+        $down = implode("\n", $down);
+
+        return $this->migrationGenerator->generateMigration(
+            $fqcn,
+            $up,
+            $down,
+        );
+    }
+
+    /** @param string[] $excludedTablesRegexes */
+    private function shouldSkipTable(Table $table, array $excludedTablesRegexes): bool
+    {
+        foreach (array_merge($excludedTablesRegexes, $this->excludedTablesRegexes) as $regex) {
+            if (
+                self::pregMatch(
+                    $regex,
+                    /** @phpstan-ignore instanceof.alwaysTrue */
+                    $table instanceof NamedObject ?
+                    $table->getObjectName()->toString() :
+                    $table->getName(),
+                ) !== 0
+            ) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * A local wrapper for "preg_match" which will throw a InvalidArgumentException if there
+     * is an internal error in the PCRE engine.
+     * Copied from https://github.com/symfony/symfony/blob/62216ea67762b18982ca3db73c391b0748a49d49/src/Symfony/Component/Yaml/Parser.php#L1072-L1090
+     *
+     * @internal
+     *
+     * @param mixed[]                                                 $matches
+     * @param int-mask-of<PREG_OFFSET_CAPTURE|PREG_UNMATCHED_AS_NULL> $flags
+     *
+     * @phpstan-ignore parameterByRef.unusedType
+     */
+    private static function pregMatch(string $pattern, string $subject, array|null &$matches = null, int $flags = 0, int $offset = 0): int
+    {
+        $errorMessages = [];
+        set_error_handler(static function (int $severity, string $message) use (&$errorMessages): bool {
+            $errorMessages[] = $message;
+
+            return true;
+        });
+
+        try {
+            $ret = preg_match($pattern, $subject, $matches, $flags, $offset);
+        } finally {
+            restore_error_handler();
+        }
+
+        if ($ret === false) {
+            throw new InvalidArgumentException(match (preg_last_error()) {
+                PREG_INTERNAL_ERROR => sprintf('Internal PCRE error, please check your Regex. Reported errors: %s.', implode(', ', $errorMessages)),
+                default => preg_last_error_msg(),
+            });
+        }
+
+        return $ret;
+    }
+}