Doctrine\Migrations\AbstractMigration

Complexity

Total Complexity

20

Size/Duplication

Total Lines	125
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	warnIf()	0	12	3
A	abortIf()	0	4	3
A	isTransactional()	0	3	1
A	skipIf()	0	4	3
A	postUp()	0	2	1
A	write()	0	3	1
A	preDown()	0	2	1
A	__construct()	0	9	1
A	getDescription()	0	3	1
A	postDown()	0	2	1
A	addSql()	0	6	1
A	throwIrreversibleMigrationException()	0	7	2
A	preUp()	0	2	1

<?php

declare(strict_types=1);

namespace Doctrine\Migrations;

use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Schema\AbstractSchemaManager;
use Doctrine\DBAL\Schema\Schema;
use function sprintf;

abstract class AbstractMigration
{
    /** @var Version */
    protected $version;

    /** @var Connection */
    protected $connection;

    /** @var AbstractSchemaManager */
    protected $sm;

    /** @var AbstractPlatform */
    protected $platform;

    /** @var OutputWriter */
    private $outputWriter;

    public function __construct(Version $version)
    {
        $config = $version->getConfiguration();

        $this->version      = $version;
        $this->connection   = $config->getConnection();
        $this->sm           = $this->connection->getSchemaManager();
        $this->platform     = $this->connection->getDatabasePlatform();
        $this->outputWriter = $config->getOutputWriter();
    }

    /**
     * Indicates the transactional mode of this migration.
     *
     * If this function returns true (default) the migration will be executed
     * in one transaction, otherwise non-transactional state will be used to
     * execute each of the migration SQLs.
     *
     * Extending class should override this function to alter the return value.
     */
    public function isTransactional() : bool
    {
        return true;
    }

    public function getDescription() : string
    {
        return '';
    }

    public function warnIf(bool $condition, string $message = '') : void
    {
        if (! $condition) {
            return;
        }

        $message = $message ?: 'Unknown Reason';

        $this->outputWriter->write(sprintf(
            '    <comment>Warning during %s: %s</comment>',
            $this->version->getExecutionState(),
            $message
        ));
    }

    /**
     * @throws AbortMigrationException
     */
    public function abortIf(bool $condition, string $message = '') : void
    {
        if ($condition) {
            throw new AbortMigrationException($message ?: 'Unknown Reason');
        }
    }

    /**
     * @throws SkipMigrationException
     */
    public function skipIf(bool $condition, string $message = '') : void
    {
        if ($condition) {
            throw new SkipMigrationException($message ?: 'Unknown Reason');
        }
    }

    public function preUp(Schema $schema) : void

The parameter $schema is not used and could be removed.

    {
    }

    public function postUp(Schema $schema) : void

The parameter $schema is not used and could be removed.

    {
    }

    public function preDown(Schema $schema) : void

The parameter $schema is not used and could be removed.

    {
    }

    public function postDown(Schema $schema) : void

The parameter $schema is not used and could be removed.

    {
    }

    abstract public function up(Schema $schema) : void;
    abstract public function down(Schema $schema) : void;

    /**
     * @param mixed[] $params
     * @param mixed[] $types
     */
    protected function addSql(
        string $sql,
        array $params = [],
        array $types = []
    ) : void {
        $this->version->addSql($sql, $params, $types);
    }

    protected function write(string $message) : void
    {
        $this->outputWriter->write($message);
    }

    protected function throwIrreversibleMigrationException(?string $message = null) : void
    {
        if ($message === null) {
            $message = 'This migration is irreversible and cannot be reverted.';
        }

        throw new IrreversibleMigrationException($message);
    }
}