Configuration::setName() - Code Metrics - Inspection of "Drop application name as it has no real use case" - doctrine/migrations - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Retried Inspection

Pull Request — master (#933)

by Asmir

created 2020-02-21 07:22 UTC

Configuration::setName() A

↳ Parent: Configuration

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
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	4
ccs	3
cts	3
cp	1
crap	1
rs	10

<?php

declare(strict_types=1);

namespace Doctrine\Migrations\Configuration;

use Doctrine\Migrations\Configuration\Exception\FrozenConfiguration;
use Doctrine\Migrations\Configuration\Exception\MissingNamespaceConfiguration;
use Doctrine\Migrations\Configuration\Exception\UnknownConfigurationValue;
use Doctrine\Migrations\Exception\MigrationException;
use Doctrine\Migrations\Metadata\Storage\MetadataStorageConfiguration;
use function count;
use function strcasecmp;

/**
 * The Configuration class is responsible for defining migration configuration information.
 */
final class Configuration
{
    public const VERSIONS_ORGANIZATION_BY_YEAR           = 'year';
    public const VERSIONS_ORGANIZATION_BY_YEAR_AND_MONTH = 'year_and_month';

    /** @var array<string, string> */
    private $migrationsDirectories = [];

    /** @var string[] */
    private $migrationClasses = [];

    /** @var bool */
    private $migrationsAreOrganizedByYear = false;

    /** @var bool */
    private $migrationsAreOrganizedByYearAndMonth = false;

    /** @var string|null */
    private $customTemplate;

    /** @var bool */
    private $isDryRun = false;

    /** @var bool */
    private $allOrNothing = false;

    /** @var bool */
    private $checkDbPlatform = true;

    /** @var MetadataStorageConfiguration */
    private $metadataStorageConfiguration;

    /** @var bool */
    private $frozen = false;

    public function freeze() : void
    {
        if (! $this->frozen) {
            $this->validate();
        }

        $this->frozen = true;
    }

    private function assertNotFrozen() : void
    {
        if ($this->frozen) {
            throw FrozenConfiguration::new();
        }
    }

    public function setMetadataStorageConfiguration(MetadataStorageConfiguration $metadataStorageConfiguration) : void
    {
        $this->assertNotFrozen();
        $this->metadataStorageConfiguration = $metadataStorageConfiguration;
    }

    /**
     * @return string[]
     */
    public function getMigrationClasses() : array
    {
        return $this->migrationClasses;
    }

    public function addMigrationClass(string $className) : void
    {
        $this->assertNotFrozen();
        $this->migrationClasses[] = $className;
    }

    public function getMetadataStorageConfiguration() : ?MetadataStorageConfiguration
    {
        return $this->metadataStorageConfiguration;
    }

    public function addMigrationsDirectory(string $namespace, string $path) : void
    {
        $this->assertNotFrozen();
        $this->migrationsDirectories[$namespace] = $path;
    }

    /**
     * @return array<string,string>
     */
    public function getMigrationDirectories() : array
    {
        return $this->migrationsDirectories;
    }

    public function setCustomTemplate(?string $customTemplate) : void
    {
        $this->assertNotFrozen();
        $this->customTemplate = $customTemplate;
    }

    public function getCustomTemplate() : ?string
    {
        return $this->customTemplate;
    }

    public function areMigrationsOrganizedByYear() : bool
    {
        return $this->migrationsAreOrganizedByYear;
    }

    /**
     * @throws MigrationException
     */
    public function setMigrationsAreOrganizedByYear(
        bool $migrationsAreOrganizedByYear = true
    ) : void {
        $this->assertNotFrozen();
        $this->migrationsAreOrganizedByYear = $migrationsAreOrganizedByYear;
    }

    /**
     * @throws MigrationException
     */
    public function setMigrationsAreOrganizedByYearAndMonth(
        bool $migrationsAreOrganizedByYearAndMonth = true
    ) : void {
        $this->assertNotFrozen();
        $this->migrationsAreOrganizedByYear         = $migrationsAreOrganizedByYearAndMonth;
        $this->migrationsAreOrganizedByYearAndMonth = $migrationsAreOrganizedByYearAndMonth;
    }

    public function areMigrationsOrganizedByYearAndMonth() : bool
    {
        return $this->migrationsAreOrganizedByYearAndMonth;
    }

    private function validate() : void
    {
        if (count($this->migrationsDirectories) === 0) {
            throw MissingNamespaceConfiguration::new();
        }
    }

    public function setIsDryRun(bool $isDryRun) : void
    {
        $this->assertNotFrozen();
        $this->isDryRun = $isDryRun;
    }

    public function isDryRun() : bool
    {
        return $this->isDryRun;
    }

    public function setAllOrNothing(bool $allOrNothing) : void
    {
        $this->assertNotFrozen();
        $this->allOrNothing = $allOrNothing;
    }

    public function isAllOrNothing() : bool
    {
        return $this->allOrNothing;
    }

    public function setCheckDatabasePlatform(bool $checkDbPlatform) : void
    {
        $this->checkDbPlatform = $checkDbPlatform;
    }

    public function isDatabasePlatformChecked() : bool
    {
        return $this->checkDbPlatform;
    }

    public function setMigrationOrganization(string $migrationOrganization) : void
    {
        $this->assertNotFrozen();
        if (strcasecmp($migrationOrganization, self::VERSIONS_ORGANIZATION_BY_YEAR) === 0) {
            $this->setMigrationsAreOrganizedByYear();
        } elseif (strcasecmp($migrationOrganization, self::VERSIONS_ORGANIZATION_BY_YEAR_AND_MONTH) === 0) {
            $this->setMigrationsAreOrganizedByYearAndMonth();
        } else {
            throw UnknownConfigurationValue::new('organize_migrations', $migrationOrganization);
        }
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Doctrine\Migrations\Configuration;
6
7		use Doctrine\Migrations\Configuration\Exception\FrozenConfiguration;
8		use Doctrine\Migrations\Configuration\Exception\MissingNamespaceConfiguration;
9		use Doctrine\Migrations\Configuration\Exception\UnknownConfigurationValue;
10		use Doctrine\Migrations\Exception\MigrationException;
11		use Doctrine\Migrations\Metadata\Storage\MetadataStorageConfiguration;
12		use function count;
13		use function strcasecmp;
14
15		/**
16		* The Configuration class is responsible for defining migration configuration information.
17		*/
18		final class Configuration
19		{
20		public const VERSIONS_ORGANIZATION_BY_YEAR = 'year';
21		public const VERSIONS_ORGANIZATION_BY_YEAR_AND_MONTH = 'year_and_month';
22
23		/** @var array<string, string> */
24		private $migrationsDirectories = [];
25
26		/** @var string[] */
27		private $migrationClasses = [];
28
29		/** @var bool */
30		private $migrationsAreOrganizedByYear = false;
31
32		/** @var bool */
33		private $migrationsAreOrganizedByYearAndMonth = false;
34
35		/** @var string\|null */
36		private $customTemplate;
37
38		/** @var bool */
39		private $isDryRun = false;
40
41		/** @var bool */
42		private $allOrNothing = false;
43
44		/** @var bool */
45		private $checkDbPlatform = true;
46
47		/** @var MetadataStorageConfiguration */
48		private $metadataStorageConfiguration;
49
50		/** @var bool */
51		private $frozen = false;
52
53	38	public function freeze() : void
54		{
55	38	if (! $this->frozen) {
56	38	$this->validate();
57		}
58
59	37	$this->frozen = true;
60	37	}
61
62	115	private function assertNotFrozen() : void
63		{
64	115	if ($this->frozen) {
65	1	throw FrozenConfiguration::new();
66		}
67	115	}
68
69	63	public function setMetadataStorageConfiguration(MetadataStorageConfiguration $metadataStorageConfiguration) : void
70		{
71	63	$this->assertNotFrozen();
72	63	$this->metadataStorageConfiguration = $metadataStorageConfiguration;
73	63	}
74
75		/**
76		* @return string[]
77		*/
78	44	public function getMigrationClasses() : array
79		{
80	44	return $this->migrationClasses;
81		}
82
83	10	public function addMigrationClass(string $className) : void
84		{
85	10	$this->assertNotFrozen();
86	10	$this->migrationClasses[] = $className;
87	10	}
88
89	31	public function getMetadataStorageConfiguration() : ?MetadataStorageConfiguration
90		{
91	31	return $this->metadataStorageConfiguration;
92		}
93
94	91	public function addMigrationsDirectory(string $namespace, string $path) : void
95		{
96	91	$this->assertNotFrozen();
97	91	$this->migrationsDirectories[$namespace] = $path;
98	91	}
99
100		/**
101		* @return array<string,string>
102		*/
103	56	public function getMigrationDirectories() : array
104		{
105	56	return $this->migrationsDirectories;
106		}
107
108	10	public function setCustomTemplate(?string $customTemplate) : void
109		{
110	10	$this->assertNotFrozen();
111	10	$this->customTemplate = $customTemplate;
112	10	}
113
114	12	public function getCustomTemplate() : ?string
115		{
116	12	return $this->customTemplate;
117		}
118
119	58	public function areMigrationsOrganizedByYear() : bool
120		{
121	58	return $this->migrationsAreOrganizedByYear;
122		}
123
124		/**
125		* @throws MigrationException
126		*/
127	7	public function setMigrationsAreOrganizedByYear(
128		bool $migrationsAreOrganizedByYear = true
129		) : void {
130	7	$this->assertNotFrozen();
131	7	$this->migrationsAreOrganizedByYear = $migrationsAreOrganizedByYear;
132	7	}
133
134		/**
135		* @throws MigrationException
136		*/
137	7	public function setMigrationsAreOrganizedByYearAndMonth(
138		bool $migrationsAreOrganizedByYearAndMonth = true
139		) : void {
140	7	$this->assertNotFrozen();
141	7	$this->migrationsAreOrganizedByYear = $migrationsAreOrganizedByYearAndMonth;
142	7	$this->migrationsAreOrganizedByYearAndMonth = $migrationsAreOrganizedByYearAndMonth;
143	7	}
144
145	56	public function areMigrationsOrganizedByYearAndMonth() : bool
146		{
147	56	return $this->migrationsAreOrganizedByYearAndMonth;
148		}
149
150	38	private function validate() : void
151		{
152	38	if (count($this->migrationsDirectories) === 0) {
153	1	throw MissingNamespaceConfiguration::new();
154		}
155	37	}
156
157	1	public function setIsDryRun(bool $isDryRun) : void
158		{
159	1	$this->assertNotFrozen();
160	1	$this->isDryRun = $isDryRun;
161	1	}
162
163	1	public function isDryRun() : bool
164		{
165	1	return $this->isDryRun;
166		}
167
168	11	public function setAllOrNothing(bool $allOrNothing) : void
169		{
170	11	$this->assertNotFrozen();
171	10	$this->allOrNothing = $allOrNothing;
172	10	}
173
174	6	public function isAllOrNothing() : bool
175		{
176	6	return $this->allOrNothing;
177		}
178
179	11	public function setCheckDatabasePlatform(bool $checkDbPlatform) : void
180		{
181	11	$this->checkDbPlatform = $checkDbPlatform;
182	11	}
183
184	3	public function isDatabasePlatformChecked() : bool
185		{
186	3	return $this->checkDbPlatform;
187		}
188
189	14	public function setMigrationOrganization(string $migrationOrganization) : void
190		{
191	14	$this->assertNotFrozen();
192	14	if (strcasecmp($migrationOrganization, self::VERSIONS_ORGANIZATION_BY_YEAR) === 0) {
193	5	$this->setMigrationsAreOrganizedByYear();
194	9	} elseif (strcasecmp($migrationOrganization, self::VERSIONS_ORGANIZATION_BY_YEAR_AND_MONTH) === 0) {
195	5	$this->setMigrationsAreOrganizedByYearAndMonth();
196		} else {
197	4	throw UnknownConfigurationValue::new('organize_migrations', $migrationOrganization);
198		}
199	10	}
200		}
201

doctrine / migrations

Pull Request — master (#933)

Configuration::setName() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like