Configuration::areMigrationsOrganizedByYearAndMonth() - Code Metrics - Inspection of "Merge pull request #959 from goetas/allow-custom-c..." - doctrine/migrations - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 53133f...79ff97 )

by Asmir

created 2020-04-23 21:07 UTC

areMigrationsOrganizedByYearAndMonth() A

↳ Parent: Configuration

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	0
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\Configuration;

use Doctrine\Migrations\Configuration\Exception\FrozenConfiguration;
use Doctrine\Migrations\Configuration\Exception\UnknownConfigurationValue;
use Doctrine\Migrations\Exception\MigrationException;
use Doctrine\Migrations\Metadata\Storage\MetadataStorageConfiguration;
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
    {
        $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;
    }

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

doctrine / migrations

Push — master ( 53133f...79ff97 )

areMigrationsOrganizedByYearAndMonth() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like