AbstractMigration::down() - Code Metrics - Inspection of "Merge pull request #952 from goetas/default-down-m..." - doctrine/migrations - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — master ( aa89df...96a683 )

by Asmir

created 2020-03-28 20:44 UTC

AbstractMigration::down() A

↳ Parent: AbstractMigration

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Doctrine\Migrations;

use Doctrine\DBAL\Connection;
use Doctrine\DBAL\DBALException;
use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Schema\AbstractSchemaManager;
use Doctrine\DBAL\Schema\Schema;
use Doctrine\Migrations\Exception\AbortMigration;
use Doctrine\Migrations\Exception\IrreversibleMigration;
use Doctrine\Migrations\Exception\MigrationException;
use Doctrine\Migrations\Exception\SkipMigration;
use Doctrine\Migrations\Query\Query;
use Psr\Log\LoggerInterface;
use function sprintf;

/**
 * The AbstractMigration class is for end users to extend from when creating migrations. Extend this class
 * and implement the required up() and down() methods.
 */
abstract class AbstractMigration
{
    /** @var Connection */
    protected $connection;

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

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

    /** @var LoggerInterface */
    private $logger;

    /** @var Query[] */
    private $plannedSql = [];

    public function __construct(Connection $connection, LoggerInterface $logger)
    {
        $this->connection = $connection;
        $this->sm         = $this->connection->getSchemaManager();
        $this->platform   = $this->connection->getDatabasePlatform();
        $this->logger     = $logger;
    }

    /**
     * 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 = 'Unknown Reason') : void
    {
        if (! $condition) {
            return;
        }

        $this->logger->warning($message, ['migration' => $this]);
    }

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

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

    /**
     * @throws MigrationException|DBALException
     */
    public function preUp(Schema $schema) : void
    public function preUp(/** @scrutinizer ignore-unused */ Schema $schema) : void
    {
    }

    /**
     * @throws MigrationException|DBALException
     */
    public function postUp(Schema $schema) : void
    public function postUp(/** @scrutinizer ignore-unused */ Schema $schema) : void
    {
    }

    /**
     * @throws MigrationException|DBALException
     */
    public function preDown(Schema $schema) : void
    public function preDown(/** @scrutinizer ignore-unused */ Schema $schema) : void
    {
    }

    /**
     * @throws MigrationException|DBALException
     */
    public function postDown(Schema $schema) : void
    public function postDown(/** @scrutinizer ignore-unused */ Schema $schema) : void
    {
    }

    /**
     * @throws MigrationException|DBALException
     */
    abstract public function up(Schema $schema) : void;

    /**
     * @throws MigrationException|DBALException
     */
    public function down(Schema $schema) : void
    public function down(/** @scrutinizer ignore-unused */ Schema $schema) : void
    {
        $this->abortIf(true, sprintf('No down() migration implemented for "%s"', static::class));
    }

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

    /**
     * @return Query[]
     */
    public function getSql() : array
    {
        return $this->plannedSql;
    }

    protected function write(string $message) : void
    {
        $this->logger->notice($message, ['migration' => $this]);
    }

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

        throw new IrreversibleMigration($message);
    }
}


doctrine / migrations

Push — master ( aa89df...96a683 )

AbstractMigration::down() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like