Doctrine\Migrations\Tools\Console\Command\ListCommand

Complexity

Total Complexity

12

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	1

4 Methods

Rating	Name	Duplication	Size	Complexity
A	configure()	0	13	1
A	getSortedVersions()	0	18	1
B	showVersions()	0	50	9
A	execute()	0	15	1

<?php

declare(strict_types=1);

namespace Doctrine\Migrations\Tools\Console\Command;

use DateTimeInterface;
use Doctrine\Migrations\Metadata\AvailableMigration;
use Doctrine\Migrations\Metadata\AvailableMigrationsList;
use Doctrine\Migrations\Metadata\ExecutedMigration;
use Doctrine\Migrations\Metadata\ExecutedMigrationsSet;
use Doctrine\Migrations\Version\Version;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Helper\TableCell;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use function array_map;
use function array_merge;
use function array_unique;
use function uasort;

/**
 * The StatusCommand class is responsible for outputting a list of all available migrations and their status.
 */
final class ListCommand extends DoctrineCommand
{
    /** @var string */
    protected static $defaultName = 'migrations:list';

    protected function configure() : void
    {
        $this
            ->setAliases(['list-migrations'])
            ->setDescription('Display a list of all available migrations and their status.')
            ->setHelp(<<<EOT
The <info>%command.name%</info> command outputs a list of all available migrations and their status:

    <info>%command.full_name%</info>
EOT
            );

        parent::configure();
    }

    public function execute(InputInterface $input, OutputInterface $output) : int
    {
        $storage       = $this->getDependencyFactory()->getMetadataStorage();
        $migrationRepo = $this->getDependencyFactory()->getMigrationRepository();

        $availableMigrations = $migrationRepo->getMigrations();

The assignment to $availableMigrations is dead and can be removed.

        $executedMigrations  = $storage->getExecutedMigrations();

The assignment to $executedMigrations is dead and can be removed.

        $this->showVersions(
            $this->getDependencyFactory()->getMigrationRepository()->getMigrations(), // available migrations
            $this->getDependencyFactory()->getMetadataStorage()->getExecutedMigrations(), // executed migrations
            $output
        );

        return 0;
    }

    private function showVersions(
        AvailableMigrationsList $availableMigrationsSet,
        ExecutedMigrationsSet $executedMigrationsSet,
        OutputInterface $output
    ) : void {
        $versions = $this->getSortedVersions($availableMigrationsSet, $executedMigrationsSet);

The assignment to $versions is dead and can be removed.

        $table = new Table($output);
        $table->setHeaders(
            [
                [new TableCell('Migration Versions', ['colspan' => 4])],
                ['Migration', 'Status', 'Migrated At', 'Execution Time', 'Description'],
            ]
        );

        foreach ($this->getSortedVersions($availableMigrationsSet, $executedMigrationsSet) as $version) {
            $description   = null;
            $executedAt    = null;
            $executionTime = null;

            if ($executedMigrationsSet->hasMigration($version)) {
                $executedMigration = $executedMigrationsSet->getMigration($version);
                $executionTime     = $executedMigration->getExecutionTime();
                $executedAt        = $executedMigration->getExecutedAt() instanceof DateTimeInterface
                    ? $executedMigration->getExecutedAt()->format('Y-m-d H:i:s')
                    : null;
            }

            if ($availableMigrationsSet->hasMigration($version)) {
                $description = $availableMigrationsSet->getMigration($version)->getMigration()->getDescription();
            }

            if ($executedMigrationsSet->hasMigration($version) && $availableMigrationsSet->hasMigration($version)) {
                $status = '<info>migrated</info>';
            } elseif ($executedMigrationsSet->hasMigration($version)) {
                $status = '<error>migrated, not available</error>';
            } else {
                $status = '<comment>not migrated</comment>';
            }

            $table->addRow([
                (string) $version,
                $status,
                (string) $executedAt,
                $executionTime !== null ? $executionTime . 's': '',
                $description,
            ]);
        }

        $table->render();
    }

    /**
     * @return Version[]
     */
    private function getSortedVersions(AvailableMigrationsList $availableMigrationsSet, ExecutedMigrationsSet $executedMigrationsSet) : array
    {
        $availableVersions = array_map(static function (AvailableMigration $availableMigration) : Version {
            return $availableMigration->getVersion();
        }, $availableMigrationsSet->getItems());

        $executedVersions = array_map(static function (ExecutedMigration $executedMigration) : Version {
            return $executedMigration->getVersion();
        }, $executedMigrationsSet->getItems());

        $versions = array_unique(array_merge($availableVersions, $executedVersions));

        $comparator = $this->getDependencyFactory()->getVersionComparator();
        uasort($versions, static function (Version $a, Version $b) use ($comparator) : int {
            return $comparator->compare($a, $b);
        });

        return $versions;
    }
}