Migration::__construct() - Code Metrics - Inspection of "Merge pull request #537 from doctrine/align-projec..." - doctrine/migrations - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — master ( 87b221...17f61e )

by Marco

created 2017-08-25 07:07 UTC

Migration::__construct() A

↳ Parent: Migration

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	6
c	0
b	0
f	0
ccs	5
cts	5
cp	1
rs	9.4285
cc	1
eloc	4
nc	1
nop	1
crap	1

<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the LGPL. For more information, see
 * <http://www.doctrine-project.org>.
 */

namespace Doctrine\DBAL\Migrations;

use Doctrine\DBAL\Migrations\Configuration\Configuration;
use Doctrine\DBAL\Migrations\Event\MigrationsEventArgs;

/**
 * Class for running migrations to the current version or a manually specified version.
 *
 * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
 * @link        www.doctrine-project.org
 * @since       2.0
 * @author      Jonathan H. Wage <[email protected]>
 */
class Migration
{
    /**
     * The OutputWriter object instance used for outputting information
     *
     * @var OutputWriter
     */
    private $outputWriter;

    /**
     * @var Configuration
     */
    private $configuration;

    /**
     * @var boolean
     */
    private $noMigrationException;

    /**
     * Construct a Migration instance
     *
     * @param Configuration $configuration A migration Configuration instance
     */
    public function __construct(Configuration $configuration)
    {
        $this->configuration        = $configuration;
        $this->outputWriter         = $configuration->getOutputWriter();
        $this->noMigrationException = false;
    }

    /**
     * Get the array of versions and SQL queries that would be executed for
     * each version but do not execute anything.
     *
     * @param string $to The version to migrate to.
     *
     * @return array $sql  The array of SQL queries.
     */
    public function getSql($to = null)
    {
        return $this->migrate($to, true);
    }

    /**
     * Write a migration SQL file to the given path
     *
     * @param string $path The path to write the migration SQL file.
     * @param string $to   The version to migrate to.
     *
     * @return boolean $written
     */
    public function writeSqlFile($path, $to = null)
    {
        $sql  = $this->getSql($to);
        $from = $this->configuration->getCurrentVersion();

        if ($to === null) {
            $to = $this->configuration->getLatestVersion();
        }

        $direction = $from > $to ? Version::DIRECTION_DOWN : Version::DIRECTION_UP;

        $this->outputWriter->write(sprintf("-- Migrating from %s to %s\n", $from, $to));

        /*
         * Since the configuration object changes during the creation we cannot inject things
         * properly, so I had to violate LoD here (so please, let's find a way to solve it on v2).
         */
        return $this->configuration->getQueryWriter()
                                   ->write($path, $direction, $sql);
    }

    /**
     * @param boolean $noMigrationException Throw an exception or not if no migration is found. Mostly for Continuous Integration.
     */
    public function setNoMigrationException($noMigrationException = false)
    {
        $this->noMigrationException = $noMigrationException;
    }

    /**
     * Run a migration to the current version or the given target version.
     *
     * @param string  $to             The version to migrate to.
     * @param boolean $dryRun         Whether or not to make this a dry run and not execute anything.
     * @param boolean $timeAllQueries Measuring or not the execution time of each SQL query.
     * @param callable|null $confirm A callback to confirm whether the migrations should be executed.
     *
     * @return array An array of migration sql statements. This will be empty if the the $confirm callback declines to execute the migration
     *
     * @throws MigrationException
     */
    public function migrate($to = null, $dryRun = false, $timeAllQueries = false, callable $confirm = null)
    {
        /**
         * If no version to migrate to is given we default to the last available one.
         */
        if ($to === null) {
            $to = $this->configuration->getLatestVersion();
        }

        $from = (string) $this->configuration->getCurrentVersion();
        $to   = (string) $to;

        /**
         * Throw an error if we can't find the migration to migrate to in the registered
         * migrations.
         */
        $migrations = $this->configuration->getMigrations();
        if (!isset($migrations[$to]) && $to > 0) {
            throw MigrationException::unknownMigrationVersion($to);
        }

        $direction = $from > $to ? Version::DIRECTION_DOWN : Version::DIRECTION_UP;
        $migrationsToExecute = $this->configuration->getMigrationsToExecute($direction, $to);

        /**
         * If
         *  there are no migrations to execute
         *  and there are migrations,
         *  and the migration from and to are the same
         * means we are already at the destination return an empty array()
         * to signify that there is nothing left to do.
         */
        if ($from === $to && empty($migrationsToExecute) && !empty($migrations)) {
            return $this->noMigrations();
        }

        if (!$dryRun && false === $this->migrationsCanExecute($confirm)) {
            return [];
        }

        $output = $dryRun ? 'Executing dry run of migration' : 'Migrating';
        $output .= ' <info>%s</info> to <comment>%s</comment> from <comment>%s</comment>';
        $this->outputWriter->write(sprintf($output, $direction, $to, $from));

        /**
         * If there are no migrations to execute throw an exception.
         */
        if (empty($migrationsToExecute) && !$this->noMigrationException) {
            throw MigrationException::noMigrationsToExecute();
        } elseif (empty($migrationsToExecute)) {
            return $this->noMigrations();
        }

        $this->configuration->dispatchEvent(
            Events::onMigrationsMigrating,
            new MigrationsEventArgs($this->configuration, $direction, $dryRun)
        );

        $sql  = [];
        $time = 0;

        foreach ($migrationsToExecute as $version) {
            $versionSql = $version->execute($direction, $dryRun, $timeAllQueries);
            $sql[$version->getVersion()] = $versionSql;
            $time += $version->getTime();
        }

        $this->configuration->dispatchEvent(
            Events::onMigrationsMigrated,
            new MigrationsEventArgs($this->configuration, $direction, $dryRun)
        );

        $this->outputWriter->write("\n  <comment>------------------------</comment>\n");
        $this->outputWriter->write(sprintf("  <info>++</info> finished in %ss", $time));
        $this->outputWriter->write(sprintf("  <info>++</info> %s migrations executed", count($migrationsToExecute)));
        $this->outputWriter->write(sprintf("  <info>++</info> %s sql queries", count($sql, true) - count($sql)));

        return $sql;
    }

    private function noMigrations() : array
    {
        $this->outputWriter->write('<comment>No migrations to execute.</comment>');

        return [];
    }

    private function migrationsCanExecute(callable $confirm = null) : bool
    {
        return null === $confirm ? true : (bool) $confirm();
    }
}


1		<?php
2		/*
3		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
5		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
6		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
7		* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
8		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
9		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
10		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
11		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
12		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
13		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14		*
15		* This software consists of voluntary contributions made by many individuals
16		* and is licensed under the LGPL. For more information, see
17		* <http://www.doctrine-project.org>.
18		*/
19
20		namespace Doctrine\DBAL\Migrations;
21
22		use Doctrine\DBAL\Migrations\Configuration\Configuration;
23		use Doctrine\DBAL\Migrations\Event\MigrationsEventArgs;
24
25		/**
26		* Class for running migrations to the current version or a manually specified version.
27		*
28		* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
29		* @link www.doctrine-project.org
30		* @since 2.0
31		* @author Jonathan H. Wage <[email protected]>
32		*/
33		class Migration
34		{
35		/**
36		* The OutputWriter object instance used for outputting information
37		*
38		* @var OutputWriter
39		*/
40		private $outputWriter;
41
42		/**
43		* @var Configuration
44		*/
45		private $configuration;
46
47		/**
48		* @var boolean
49		*/
50		private $noMigrationException;
51
52		/**
53		* Construct a Migration instance
54		*
55		* @param Configuration $configuration A migration Configuration instance
56		*/
57	37	public function __construct(Configuration $configuration)
58		{
59	37	$this->configuration = $configuration;
60	37	$this->outputWriter = $configuration->getOutputWriter();
61	37	$this->noMigrationException = false;
62	37	}
63
64		/**
65		* Get the array of versions and SQL queries that would be executed for
66		* each version but do not execute anything.
67		*
68		* @param string $to The version to migrate to.
69		*
70		* @return array $sql The array of SQL queries.
71		*/
72	2	public function getSql($to = null)
73		{
74	2	return $this->migrate($to, true);
75		}
76
77		/**
78		* Write a migration SQL file to the given path
79		*
80		* @param string $path The path to write the migration SQL file.
81		* @param string $to The version to migrate to.
82		*
83		* @return boolean $written
84		*/
85	6	public function writeSqlFile($path, $to = null)
86		{
87	6	$sql = $this->getSql($to);
88	6	$from = $this->configuration->getCurrentVersion();
89
90	6	if ($to === null) {
91	1	$to = $this->configuration->getLatestVersion();
92		}
93
94	6	$direction = $from > $to ? Version::DIRECTION_DOWN : Version::DIRECTION_UP;
95
96	6	$this->outputWriter->write(sprintf("-- Migrating from %s to %s\n", $from, $to));
97
98		/*
99		* Since the configuration object changes during the creation we cannot inject things
100		* properly, so I had to violate LoD here (so please, let's find a way to solve it on v2).
101		*/
102	6	return $this->configuration->getQueryWriter()
103	6	->write($path, $direction, $sql);
104		}
105
106		/**
107		* @param boolean $noMigrationException Throw an exception or not if no migration is found. Mostly for Continuous Integration.
108		*/
109	2	public function setNoMigrationException($noMigrationException = false)
110		{
111	2	$this->noMigrationException = $noMigrationException;
112	2	}
113
114		/**
115		* Run a migration to the current version or the given target version.
116		*
117		* @param string $to The version to migrate to.
118		* @param boolean $dryRun Whether or not to make this a dry run and not execute anything.
119		* @param boolean $timeAllQueries Measuring or not the execution time of each SQL query.
120		* @param callable\|null $confirm A callback to confirm whether the migrations should be executed.
121		*
122		* @return array An array of migration sql statements. This will be empty if the the $confirm callback declines to execute the migration
123		*
124		* @throws MigrationException
125		*/
126	31	public function migrate($to = null, $dryRun = false, $timeAllQueries = false, callable $confirm = null)
127		{
128		/**
129		* If no version to migrate to is given we default to the last available one.
130		*/
131	31	if ($to === null) {
132	14	$to = $this->configuration->getLatestVersion();
133		}
134
135	31	$from = (string) $this->configuration->getCurrentVersion();
136	31	$to = (string) $to;
137
138		/**
139		* Throw an error if we can't find the migration to migrate to in the registered
140		* migrations.
141		*/
142	31	$migrations = $this->configuration->getMigrations();
143	31	if (!isset($migrations[$to]) && $to > 0) {
144	1	throw MigrationException::unknownMigrationVersion($to);
145		}
146
147	30	$direction = $from > $to ? Version::DIRECTION_DOWN : Version::DIRECTION_UP;
148	30	$migrationsToExecute = $this->configuration->getMigrationsToExecute($direction, $to);
149
150		/**
151		* If
152		* there are no migrations to execute
153		* and there are migrations,
154		* and the migration from and to are the same
155		* means we are already at the destination return an empty array()
156		* to signify that there is nothing left to do.
157		*/
158	30	if ($from === $to && empty($migrationsToExecute) && !empty($migrations)) {
159	2	return $this->noMigrations();
160		}
161
162	29	if (!$dryRun && false === $this->migrationsCanExecute($confirm)) {
163	1	return [];
164		}
165
166	28	$output = $dryRun ? 'Executing dry run of migration' : 'Migrating';
167	28	$output .= ' <info>%s</info> to <comment>%s</comment> from <comment>%s</comment>';
168	28	$this->outputWriter->write(sprintf($output, $direction, $to, $from));
169
170		/**
171		* If there are no migrations to execute throw an exception.
172		*/
173	28	if (empty($migrationsToExecute) && !$this->noMigrationException) {
174	1	throw MigrationException::noMigrationsToExecute();
175		} elseif (empty($migrationsToExecute)) {
176	1	return $this->noMigrations();
177		}
178
179	26	$this->configuration->dispatchEvent(
180	26	Events::onMigrationsMigrating,
181	26	new MigrationsEventArgs($this->configuration, $direction, $dryRun)
182		);
183
184	26	$sql = [];
185	26	$time = 0;
186
187	26	foreach ($migrationsToExecute as $version) {
188	26	$versionSql = $version->execute($direction, $dryRun, $timeAllQueries);
189	26	$sql[$version->getVersion()] = $versionSql;
190	26	$time += $version->getTime();
191		}
192
193	26	$this->configuration->dispatchEvent(
194	26	Events::onMigrationsMigrated,
195	26	new MigrationsEventArgs($this->configuration, $direction, $dryRun)
196		);
197
198	26	$this->outputWriter->write("\n <comment>------------------------</comment>\n");
199	26	$this->outputWriter->write(sprintf(" <info>++</info> finished in %ss", $time));
200	26	$this->outputWriter->write(sprintf(" <info>++</info> %s migrations executed", count($migrationsToExecute)));
201	26	$this->outputWriter->write(sprintf(" <info>++</info> %s sql queries", count($sql, true) - count($sql)));
202
203	26	return $sql;
204		}
205
206	3	private function noMigrations() : array
207		{
208	3	$this->outputWriter->write('<comment>No migrations to execute.</comment>');
209
210	3	return [];
211		}
212
213	27	private function migrationsCanExecute(callable $confirm = null) : bool
214		{
215	27	return null === $confirm ? true : (bool) $confirm();
216		}
217		}
218

doctrine / migrations

Push — master ( 87b221...17f61e )

Migration::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like