MigrationRepository::hasMigration() - Code Metrics - Inspection of "Moved migration sorting from MigrationRepository t..." - doctrine/migrations - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#969)

by Asmir

created 2020-04-23 06:49 UTC

MigrationRepository::hasMigration() A

↳ Parent: MigrationRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

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

<?php

declare(strict_types=1);

namespace Doctrine\Migrations;

use Doctrine\Migrations\Exception\DuplicateMigrationVersion;
use Doctrine\Migrations\Exception\MigrationClassNotFound;
use Doctrine\Migrations\Exception\MigrationException;
use Doctrine\Migrations\Finder\MigrationFinder;
use Doctrine\Migrations\Metadata\AvailableMigration;
use Doctrine\Migrations\Metadata\AvailableMigrationsList;
use Doctrine\Migrations\Version\MigrationFactory;
use Doctrine\Migrations\Version\Version;
use function class_exists;

/**
 * The MigrationRepository class is responsible for retrieving migrations, determining what the current migration
 * version, etc.
 *
 * @internal
 */
class MigrationRepository
{
    /** @var bool */
    private $migrationsLoaded = false;

    /** @var array<string, string> */
    private $migrationDirectories;

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

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

    /** @var AvailableMigration[] */
    private $migrations = [];

    /**
     * @param string[]              $classes
     * @param array<string, string> $migrationDirectories
     * @param MigrationFinder       $migrationFinder

     * @param MigrationFactory      $versionFactory

     */
    public function __construct(
        array $classes,
        array $migrationDirectories,
        MigrationFinder $migrationFinder,
        MigrationFactory $versionFactory
    ) {
        $this->migrationDirectories = $migrationDirectories;
        $this->migrationFinder      = $migrationFinder;
        $this->versionFactory       = $versionFactory;

        $this->registerMigrations($classes);
    }

    private function registerMigrationInstance(Version $version, AbstractMigration $migration) : AvailableMigration
    {
        if (isset($this->migrations[(string) $version])) {
            throw DuplicateMigrationVersion::new(
                (string) $version,
                (string) $version
            );
        }

        $this->migrations[(string) $version] = new AvailableMigration($version, $migration);

        return $this->migrations[(string) $version];
    }

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

        $version   = new Version($migrationClassName);
        $migration = $this->versionFactory->createVersion($migrationClassName);

        return $this->registerMigrationInstance($version, $migration);
    }

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

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

        return $versions;
    }

    public function hasMigration(string $version) : bool
    {
        $this->loadMigrationsFromDirectories();

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

    public function getMigration(Version $version) : AvailableMigration
    {
        $this->loadMigrationsFromDirectories();

        if (! isset($this->migrations[(string) $version])) {
            throw MigrationClassNotFound::new((string) $version);
        }

        return $this->migrations[(string) $version];
    }

    public function getMigrations() : AvailableMigrationsList
    {
        $this->loadMigrationsFromDirectories();

        return new AvailableMigrationsList($this->migrations);
    }

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

    private function loadMigrationsFromDirectories() : void
    {
        $migrationDirectories = $this->migrationDirectories;

        if ($this->migrationsLoaded) {
            return;
        }

        $this->migrationsLoaded = true;

        foreach ($migrationDirectories as $namespace => $path) {
                $migrations = $this->migrationFinder->findMigrations(
                    $path,
                    $namespace
                );
                $this->registerMigrations($migrations);
        }
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Doctrine\Migrations;
6
7		use Doctrine\Migrations\Exception\DuplicateMigrationVersion;
8		use Doctrine\Migrations\Exception\MigrationClassNotFound;
9		use Doctrine\Migrations\Exception\MigrationException;
10		use Doctrine\Migrations\Finder\MigrationFinder;
11		use Doctrine\Migrations\Metadata\AvailableMigration;
12		use Doctrine\Migrations\Metadata\AvailableMigrationsList;
13		use Doctrine\Migrations\Version\MigrationFactory;
14		use Doctrine\Migrations\Version\Version;
15		use function class_exists;
16
17		/**
18		* The MigrationRepository class is responsible for retrieving migrations, determining what the current migration
19		* version, etc.
20		*
21		* @internal
22		*/
23		class MigrationRepository
24		{
25		/** @var bool */
26		private $migrationsLoaded = false;
27
28		/** @var array<string, string> */
29		private $migrationDirectories;
30
31		/** @var MigrationFinder */
32		private $migrationFinder;
33
34		/** @var MigrationFactory */
35		private $versionFactory;
36
37		/** @var AvailableMigration[] */
38		private $migrations = [];
39
40		/**
41		* @param string[] $classes
42		* @param array<string, string> $migrationDirectories
43		* @param MigrationFinder $migrationFinder
		0 ignored issues – show introduced 2020-04-23 06:51 UTC by Report Bug Copy Issue Report Method \Doctrine\Migrations\MigrationRepository::__construct() has useless @param annotation for parameter $migrationFinder. Loading history...
44		* @param MigrationFactory $versionFactory
		0 ignored issues – show introduced 2020-04-23 06:51 UTC by Report Bug Copy Issue Report Method \Doctrine\Migrations\MigrationRepository::__construct() has useless @param annotation for parameter $versionFactory. Loading history...
45		*/
46	72	public function __construct(
47		array $classes,
48		array $migrationDirectories,
49		MigrationFinder $migrationFinder,
50		MigrationFactory $versionFactory
51		) {
52	72	$this->migrationDirectories = $migrationDirectories;
53	72	$this->migrationFinder = $migrationFinder;
54	72	$this->versionFactory = $versionFactory;
55
56	72	$this->registerMigrations($classes);
57	72	}
58
59	57	private function registerMigrationInstance(Version $version, AbstractMigration $migration) : AvailableMigration
60		{
61	57	if (isset($this->migrations[(string) $version])) {
62	1	throw DuplicateMigrationVersion::new(
63	1	(string) $version,
64	1	(string) $version
65		);
66		}
67
68	57	$this->migrations[(string) $version] = new AvailableMigration($version, $migration);
69
70	57	return $this->migrations[(string) $version];
71		}
72
73		/** @throws MigrationException */
74	8	public function registerMigration(string $migrationClassName) : AvailableMigration
75		{
76	8	$this->ensureMigrationClassExists($migrationClassName);
77
78	8	$version = new Version($migrationClassName);
79	8	$migration = $this->versionFactory->createVersion($migrationClassName);
80
81	8	return $this->registerMigrationInstance($version, $migration);
82		}
83
84		/**
85		* @param string[] $migrations
86		*
87		* @return AvailableMigration[]
88		*/
89	72	private function registerMigrations(array $migrations) : array
90		{
91	72	$versions = [];
92
93	72	foreach ($migrations as $class) {
94	8	$versions[] = $this->registerMigration($class);
95		}
96
97	72	return $versions;
98		}
99
100	10	public function hasMigration(string $version) : bool
101		{
102	10	$this->loadMigrationsFromDirectories();
103
104	10	return isset($this->migrations[$version]);
105		}
106
107	15	public function getMigration(Version $version) : AvailableMigration
108		{
109	15	$this->loadMigrationsFromDirectories();
110
111	15	if (! isset($this->migrations[(string) $version])) {
112	4	throw MigrationClassNotFound::new((string) $version);
113		}
114
115	12	return $this->migrations[(string) $version];
116		}
117
118	60	public function getMigrations() : AvailableMigrationsList
119		{
120	60	$this->loadMigrationsFromDirectories();
121
122	60	return new AvailableMigrationsList($this->migrations);
123		}
124
125		/** @throws MigrationException */
126	8	private function ensureMigrationClassExists(string $class) : void
127		{
128	8	if (! class_exists($class)) {
129		throw MigrationClassNotFound::new($class);
130		}
131	8	}
132
133	63	private function loadMigrationsFromDirectories() : void
134		{
135	63	$migrationDirectories = $this->migrationDirectories;
136
137	63	if ($this->migrationsLoaded) {
138	38	return;
139		}
140
141	63	$this->migrationsLoaded = true;
142
143	63	foreach ($migrationDirectories as $namespace => $path) {
144	43	$migrations = $this->migrationFinder->findMigrations(
145	43	$path,
146	43	$namespace
147		);
148	43	$this->registerMigrations($migrations);
149		}
150	63	}
151		}
152

doctrine / migrations

Pull Request — master (#969)

MigrationRepository::hasMigration() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like