MigrationRepository::getAvailableVersions() - Code Metrics - Inspection of "Merge pull request #665 from doctrine/refactor-com..." - doctrine/migrations - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 368556...6bf94b )

by Jonathan

created 2018-05-11 20:59 UTC

MigrationRepository::getAvailableVersions() A

↳ Parent: MigrationRepository

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2

Importance

Changes

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

<?php

declare(strict_types=1);

namespace Doctrine\Migrations;

use Doctrine\DBAL\Connection;
use Doctrine\Migrations\Configuration\Configuration;
use Doctrine\Migrations\Exception\DuplicateMigrationVersion;
use Doctrine\Migrations\Exception\MigrationClassNotFound;
use Doctrine\Migrations\Exception\UnknownMigrationVersion;
use Doctrine\Migrations\Finder\MigrationFinder;
use const SORT_STRING;
use function array_diff;
use function array_keys;
use function array_map;
use function array_search;
use function array_unshift;
use function class_exists;
use function count;
use function end;
use function get_class;
use function implode;
use function ksort;
use function sprintf;
use function substr;

/**
 * @internal
 */
class MigrationRepository
{
    /** @var Configuration */
    private $configuration;

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

    /** @var MigrationFinder */
    private $migrationFinder;

    /** @var VersionFactory */
    private $versionFactory;

    /** @var Version[] */
    private $versions = [];

    public function __construct(
        Configuration $configuration,
        Connection $connection,
        MigrationFinder $migrationFinder,
        VersionFactory $versionFactory
    ) {
        $this->configuration   = $configuration;
        $this->connection      = $connection;
        $this->migrationFinder = $migrationFinder;
        $this->versionFactory  = $versionFactory;
    }

    /**
     * @return string[]
     */
    public function findMigrations(string $path) : array
    {
        return $this->migrationFinder->findMigrations($path, $this->configuration->getMigrationsNamespace());
    }

    /** @return Version[] */
    public function registerMigrationsFromDirectory(string $path) : array
    {
        return $this->registerMigrations($this->findMigrations($path));
    }

    /** @throws MigrationException */
    public function registerMigration(string $version, string $migrationClassName) : Version
    {
        $this->ensureMigrationClassExists($migrationClassName);

        if (isset($this->versions[$version])) {
            throw DuplicateMigrationVersion::new(
                $version,
                get_class($this->versions[$version])
            );
        }

        $version = $this->versionFactory->createVersion($version, $migrationClassName);

        $this->versions[$version->getVersion()] = $version;

        ksort($this->versions, SORT_STRING);

        return $version;
    }

    /**
     * @param string[] $migrations
     *
     * @return Version[]
     */
    public function registerMigrations(array $migrations) : array
    {
        $versions = [];

        foreach ($migrations as $version => $class) {
            $versions[] = $this->registerMigration((string) $version, $class);
        }

        return $versions;
    }

    public function getCurrentVersion() : string
    {
        $this->configuration->createMigrationTable();

        if (! $this->configuration->isMigrationTableCreated() && $this->configuration->isDryRun()) {
            return '0';
        }

        $this->configuration->connect();

        $this->loadMigrationsFromDirectory();

        $where = null;

        if (! empty($this->versions)) {
            $migratedVersions = [];

            foreach ($this->versions as $migration) {
                $migratedVersions[] = sprintf("'%s'", $migration->getVersion());
            }

            $where = sprintf(
                ' WHERE %s IN (%s)',
                $this->configuration->getQuotedMigrationsColumnName(),
                implode(', ', $migratedVersions)
            );
        }

        $sql = sprintf(
            'SELECT %s FROM %s%s ORDER BY %s DESC',
            $this->configuration->getQuotedMigrationsColumnName(),
            $this->configuration->getMigrationsTableName(),
            $where,
            $this->configuration->getQuotedMigrationsColumnName()
        );

        $sql    = $this->connection->getDatabasePlatform()->modifyLimitQuery($sql, 1);
        $result = $this->connection->fetchColumn($sql);

        return $result !== false ? (string) $result : '0';
    }

    public function getVersion(string $version) : Version
    {
        $this->loadMigrationsFromDirectory();

        if (! isset($this->versions[$version])) {
            throw UnknownMigrationVersion::new($version);
        }

        return $this->versions[$version];
    }

    public function hasVersion(string $version) : bool
    {
        $this->loadMigrationsFromDirectory();

        return isset($this->versions[$version]);
    }

    public function hasVersionMigrated(Version $version) : bool
    {
        $this->configuration->connect();
        $this->configuration->createMigrationTable();

        $sql = sprintf(
            'SELECT %s FROM %s WHERE %s = ?',
            $this->configuration->getQuotedMigrationsColumnName(),
            $this->configuration->getMigrationsTableName(),
            $this->configuration->getQuotedMigrationsColumnName()
        );

        $version = $this->connection->fetchColumn($sql, [$version->getVersion()]);

        return $version !== false;
    }

    /**
     * @return Version[]
     */
    public function getMigrations() : array
    {
        $this->loadMigrationsFromDirectory();

        return $this->versions;
    }

    /** @return string[] */
    public function getAvailableVersions() : array
    {
        $availableVersions = [];

        $this->loadMigrationsFromDirectory();

        foreach ($this->versions as $migration) {
            $availableVersions[] = $migration->getVersion();
        }

        return $availableVersions;
    }

    /** @return string[] */
    public function getNewVersions() : array
    {
        $availableMigrations = $this->getAvailableVersions();
        $executedMigrations  = $this->getMigratedVersions();

        return array_diff($availableMigrations, $executedMigrations);
    }

    /** @return string[] */
    public function getMigratedVersions() : array
    {
        $this->configuration->createMigrationTable();

        if (! $this->configuration->isMigrationTableCreated() && $this->configuration->isDryRun()) {
            return [];
        }

        $this->configuration->connect();

        $sql = sprintf(
            'SELECT %s FROM %s',
            $this->configuration->getQuotedMigrationsColumnName(),
            $this->configuration->getMigrationsTableName()
        );

        $result = $this->connection->fetchAll($sql);

        return array_map('current', $result);
    }

    /**
     * @return string[]
     */
    public function getExecutedUnavailableMigrations() : array
    {
        $executedMigrations  = $this->getMigratedVersions();
        $availableMigrations = $this->getAvailableVersions();

        return array_diff($executedMigrations, $availableMigrations);
    }

    public function getNumberOfAvailableMigrations() : int
    {
        $this->loadMigrationsFromDirectory();

        return count($this->versions);
    }

    public function getLatestVersion() : string
    {
        $this->loadMigrationsFromDirectory();

        $versions = array_keys($this->versions);
        $latest   = end($versions);

        return $latest !== false ? (string) $latest : '0';
    }

    public function getNumberOfExecutedMigrations() : int
    {
        $this->configuration->connect();
        $this->configuration->createMigrationTable();

        $sql = sprintf(
            'SELECT COUNT(%s) FROM %s',
            $this->configuration->getQuotedMigrationsColumnName(),
            $this->configuration->getMigrationsTableName()
        );

        $result = $this->connection->fetchColumn($sql);

        return $result !== false ? (int) $result : 0;
    }

    public function getRelativeVersion(string $version, int $delta) : ?string
    {
        $this->loadMigrationsFromDirectory();

        $versions = array_map('strval', array_keys($this->versions));

        array_unshift($versions, '0');

        $offset = array_search($version, $versions, true);

        if ($offset === false || ! isset($versions[$offset + $delta])) {
            // Unknown version or delta out of bounds.
            return null;
        }

        return $versions[$offset + $delta];
    }

    public function getDeltaVersion(string $delta) : ?string
    {
        $symbol = substr($delta, 0, 1);
        $number = (int) substr($delta, 1);

        if ($number <= 0) {
            return null;
        }

        if ($symbol === '+' || $symbol === '-') {
            return $this->getRelativeVersion($this->getCurrentVersion(), (int) $delta);
        }

        return null;
    }

    public function getPrevVersion() : ?string
    {
        return $this->getRelativeVersion($this->getCurrentVersion(), -1);
    }

    public function getNextVersion() : ?string
    {
        return $this->getRelativeVersion($this->getCurrentVersion(), 1);
    }

    private function loadMigrationsFromDirectory() : void
    {
        $migrationsDirectory = $this->configuration->getMigrationsDirectory();

        if (count($this->versions) !== 0 || $migrationsDirectory === null) {
            return;
        }

        $this->registerMigrationsFromDirectory($migrationsDirectory);
    }

    /** @throws MigrationException */
    private function ensureMigrationClassExists(string $class) : void
    {
        if (! class_exists($class)) {
            throw MigrationClassNotFound::new(
                $class,
                $this->configuration->getMigrationsNamespace()
            );
        }
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Doctrine\Migrations;
6
7		use Doctrine\DBAL\Connection;
8		use Doctrine\Migrations\Configuration\Configuration;
9		use Doctrine\Migrations\Exception\DuplicateMigrationVersion;
10		use Doctrine\Migrations\Exception\MigrationClassNotFound;
11		use Doctrine\Migrations\Exception\UnknownMigrationVersion;
12		use Doctrine\Migrations\Finder\MigrationFinder;
13		use const SORT_STRING;
14		use function array_diff;
15		use function array_keys;
16		use function array_map;
17		use function array_search;
18		use function array_unshift;
19		use function class_exists;
20		use function count;
21		use function end;
22		use function get_class;
23		use function implode;
24		use function ksort;
25		use function sprintf;
26		use function substr;
27
28		/**
29		* @internal
30		*/
31		class MigrationRepository
32		{
33		/** @var Configuration */
34		private $configuration;
35
36		/** @var Connection */
37		private $connection;
38
39		/** @var MigrationFinder */
40		private $migrationFinder;
41
42		/** @var VersionFactory */
43		private $versionFactory;
44
45		/** @var Version[] */
46		private $versions = [];
47
48	130	public function __construct(
49		Configuration $configuration,
50		Connection $connection,
51		MigrationFinder $migrationFinder,
52		VersionFactory $versionFactory
53		) {
54	130	$this->configuration = $configuration;
55	130	$this->connection = $connection;
56	130	$this->migrationFinder = $migrationFinder;
57	130	$this->versionFactory = $versionFactory;
58	130	}
59
60		/**
61		* @return string[]
62		*/
63	83	public function findMigrations(string $path) : array
64		{
65	83	return $this->migrationFinder->findMigrations($path, $this->configuration->getMigrationsNamespace());
66		}
67
68		/** @return Version[] */
69	83	public function registerMigrationsFromDirectory(string $path) : array
70		{
71	83	return $this->registerMigrations($this->findMigrations($path));
72		}
73
74		/** @throws MigrationException */
75	71	public function registerMigration(string $version, string $migrationClassName) : Version
76		{
77	71	$this->ensureMigrationClassExists($migrationClassName);
78
79	70	if (isset($this->versions[$version])) {
80	1	throw DuplicateMigrationVersion::new(
81	1	$version,
82	1	get_class($this->versions[$version])
83		);
84		}
85
86	70	$version = $this->versionFactory->createVersion($version, $migrationClassName);
87
88	70	$this->versions[$version->getVersion()] = $version;
89
90	70	ksort($this->versions, SORT_STRING);
91
92	70	return $version;
93		}
94
95		/**
96		* @param string[] $migrations
97		*
98		* @return Version[]
99		*/
100	87	public function registerMigrations(array $migrations) : array
101		{
102	87	$versions = [];
103
104	87	foreach ($migrations as $version => $class) {
105	35	$versions[] = $this->registerMigration((string) $version, $class);
106		}
107
108	86	return $versions;
109		}
110
111	42	public function getCurrentVersion() : string
112		{
113	42	$this->configuration->createMigrationTable();
114
115	42	if (! $this->configuration->isMigrationTableCreated() && $this->configuration->isDryRun()) {
116	1	return '0';
117		}
118
119	42	$this->configuration->connect();
120
121	42	$this->loadMigrationsFromDirectory();
122
123	42	$where = null;
124
125	42	if (! empty($this->versions)) {
126	38	$migratedVersions = [];
127
128	38	foreach ($this->versions as $migration) {
129	38	$migratedVersions[] = sprintf("'%s'", $migration->getVersion());
130		}
131
132	38	$where = sprintf(
133	38	' WHERE %s IN (%s)',
134	38	$this->configuration->getQuotedMigrationsColumnName(),
135	38	implode(', ', $migratedVersions)
136		);
137		}
138
139	42	$sql = sprintf(
140	42	'SELECT %s FROM %s%s ORDER BY %s DESC',
141	42	$this->configuration->getQuotedMigrationsColumnName(),
142	42	$this->configuration->getMigrationsTableName(),
143	42	$where,
144	42	$this->configuration->getQuotedMigrationsColumnName()
145		);
146
147	42	$sql = $this->connection->getDatabasePlatform()->modifyLimitQuery($sql, 1);
148	42	$result = $this->connection->fetchColumn($sql);
149
150	42	return $result !== false ? (string) $result : '0';
151		}
152
153	22	public function getVersion(string $version) : Version
154		{
155	22	$this->loadMigrationsFromDirectory();
156
157	22	if (! isset($this->versions[$version])) {
158	2	throw UnknownMigrationVersion::new($version);
159		}
160
161	20	return $this->versions[$version];
162		}
163
164	19	public function hasVersion(string $version) : bool
165		{
166	19	$this->loadMigrationsFromDirectory();
167
168	19	return isset($this->versions[$version]);
169		}
170
171	21	public function hasVersionMigrated(Version $version) : bool
172		{
173	21	$this->configuration->connect();
174	21	$this->configuration->createMigrationTable();
175
176	21	$sql = sprintf(
177	21	'SELECT %s FROM %s WHERE %s = ?',
178	21	$this->configuration->getQuotedMigrationsColumnName(),
179	21	$this->configuration->getMigrationsTableName(),
180	21	$this->configuration->getQuotedMigrationsColumnName()
181		);
182
183	21	$version = $this->connection->fetchColumn($sql, [$version->getVersion()]);
184
185	21	return $version !== false;
186		}
187
188		/**
189		* @return Version[]
190		*/
191	38	public function getMigrations() : array
192		{
193	38	$this->loadMigrationsFromDirectory();
194
195	38	return $this->versions;
196		}
197
198		/** @return string[] */
199	15	public function getAvailableVersions() : array
200		{
201	15	$availableVersions = [];
202
203	15	$this->loadMigrationsFromDirectory();
204
205	15	foreach ($this->versions as $migration) {
206	14	$availableVersions[] = $migration->getVersion();
207		}
208
209	15	return $availableVersions;
210		}
211
212		/** @return string[] */
213	8	public function getNewVersions() : array
214		{
215	8	$availableMigrations = $this->getAvailableVersions();
216	8	$executedMigrations = $this->getMigratedVersions();
217
218	8	return array_diff($availableMigrations, $executedMigrations);
219		}
220
221		/** @return string[] */
222	42	public function getMigratedVersions() : array
223		{
224	42	$this->configuration->createMigrationTable();
225
226	42	if (! $this->configuration->isMigrationTableCreated() && $this->configuration->isDryRun()) {
227	1	return [];
228		}
229
230	42	$this->configuration->connect();
231
232	42	$sql = sprintf(
233	42	'SELECT %s FROM %s',
234	42	$this->configuration->getQuotedMigrationsColumnName(),
235	42	$this->configuration->getMigrationsTableName()
236		);
237
238	42	$result = $this->connection->fetchAll($sql);
239
240	42	return array_map('current', $result);
241		}
242
243		/**
244		* @return string[]
245		*/
246	8	public function getExecutedUnavailableMigrations() : array
247		{
248	8	$executedMigrations = $this->getMigratedVersions();
249	8	$availableMigrations = $this->getAvailableVersions();
250
251	8	return array_diff($executedMigrations, $availableMigrations);
252		}
253
254	3	public function getNumberOfAvailableMigrations() : int
255		{
256	3	$this->loadMigrationsFromDirectory();
257
258	3	return count($this->versions);
259		}
260
261	25	public function getLatestVersion() : string
262		{
263	25	$this->loadMigrationsFromDirectory();
264
265	25	$versions = array_keys($this->versions);
266	25	$latest = end($versions);
267
268	25	return $latest !== false ? (string) $latest : '0';
269		}
270
271	1	public function getNumberOfExecutedMigrations() : int
272		{
273	1	$this->configuration->connect();
274	1	$this->configuration->createMigrationTable();
275
276	1	$sql = sprintf(
277	1	'SELECT COUNT(%s) FROM %s',
278	1	$this->configuration->getQuotedMigrationsColumnName(),
279	1	$this->configuration->getMigrationsTableName()
280		);
281
282	1	$result = $this->connection->fetchColumn($sql);
283
284	1	return $result !== false ? (int) $result : 0;
285		}
286
287	14	public function getRelativeVersion(string $version, int $delta) : ?string
288		{
289	14	$this->loadMigrationsFromDirectory();
290
291	14	$versions = array_map('strval', array_keys($this->versions));
292
293	14	array_unshift($versions, '0');
294
295	14	$offset = array_search($version, $versions, true);
296
297	14	if ($offset === false \|\| ! isset($versions[$offset + $delta])) {
298		// Unknown version or delta out of bounds.
299	10	return null;
300		}
301
302	13	return $versions[$offset + $delta];
303		}
304
305	1	public function getDeltaVersion(string $delta) : ?string
306		{
307	1	$symbol = substr($delta, 0, 1);
308	1	$number = (int) substr($delta, 1);
309
310	1	if ($number <= 0) {
311		return null;
312		}
313
314	1	if ($symbol === '+' \|\| $symbol === '-') {
315	1	return $this->getRelativeVersion($this->getCurrentVersion(), (int) $delta);
316		}
317
318		return null;
319		}
320
321	9	public function getPrevVersion() : ?string
322		{
323	9	return $this->getRelativeVersion($this->getCurrentVersion(), -1);
324		}
325
326	10	public function getNextVersion() : ?string
327		{
328	10	return $this->getRelativeVersion($this->getCurrentVersion(), 1);
329		}
330
331	70	private function loadMigrationsFromDirectory() : void
332		{
333	70	$migrationsDirectory = $this->configuration->getMigrationsDirectory();
334
335	70	if (count($this->versions) !== 0 \|\| $migrationsDirectory === null) {
336	49	return;
337		}
338
339	32	$this->registerMigrationsFromDirectory($migrationsDirectory);
340	32	}
341
342		/** @throws MigrationException */
343	71	private function ensureMigrationClassExists(string $class) : void
344		{
345	71	if (! class_exists($class)) {
346	1	throw MigrationClassNotFound::new(
347	1	$class,
348	1	$this->configuration->getMigrationsNamespace()
349		);
350		}
351	70	}
352		}
353

doctrine / migrations

Push — master ( 368556...6bf94b )

MigrationRepository::getAvailableVersions() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like