Migrator::getTable() - Code Metrics - Inspection of "Migration table from config." - jumilla/laravel-versionia - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7f191b...9a8f06 )

by Fumio

created 2016-09-03 11:58 UTC

Migrator::getTable() A

↳ Parent: Migrator

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Jumilla\Versionia\Laravel;

use Illuminate\Database\DatabaseManager;
use Illuminate\Contracts\Config\Repository as Config;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class Migrator
{
    const VERSION_NULL = null;

    /**
     * @var \Illuminate\Database\DatabaseManager
     */
    protected $db;

    /**
     * @var string
     */
    protected $table = 'migrations';

    /**
     * @var array
     */
    protected $migrations = [];

    /**
     * @var array
     */
    protected $seeds = [];

    /**
     * @var string
     */
    protected $default_seed;

    /**
     * @param \Illuminate\Contracts\Database\DatabaseManager $db
     * @param \Illuminate\Contracts\Config\Repository $config
     */
    public function __construct(DatabaseManager $db, Config $config = null)
    {
        $this->db = $db;
        if ($config) {
            $this->table = $config->get('database.migrations', $this->table);
        }
    }

    /**
     * @return string
     */
    public function getTable()
    {
        return $this->table;
    }

    /**
     * @param string $a
     * @param string $b
     *
     * @return int
     */
    public function compareMigrationVersion($a, $b)
    {
        return version_compare($a, $b);
    }

    /**
     * @param string $group
     * @param string $version
     * @param string $class
     */
    public function registerMigration($group, $version, $class)
    {
        $this->registerMigrations($group, [
            $version => $class,
        ]);
    }

    /**
     * @param string $group
     * @param array  $versions
     */
    public function registerMigrations($group, array $versions)
    {
        foreach ($versions as $version => $class) {
            $this->migrations[$group][$version] = $class;
        }
    }

    /**
     * @return array
     */
    public function migrationGroups()
    {
        $groups = array_keys($this->migrations);

        sort($groups);

        return $groups;
    }

    /**
     * @param string $group
     * @param bool   $descending
     *
     * @return array
     */
    public function migrationVersions($group, $descending = false)
    {
        $versions = array_get($this->migrations, $group, []);

        uksort($versions, [$this, 'compareMigrationVersion']);

        return $descending ? array_reverse($versions, true) : $versions;
    }

    /**
     * @param string $group
     *
     * @return array
     */
    public function migrationVersionsByDesc($group)
    {
        return $this->migrationVersions($group, true);
    }

    /**
     * @param string $group
     *
     * @return string
     */
    public function migrationLatestVersion($group)
    {
        foreach ($this->migrationVersionsByDesc($group) as $version => $class) {
            return $version;
        }

        return self::VERSION_NULL;
    }

    /**
     * @param string $group
     * @param string $version
     *
     * @return string
     */
    public function migrationClass($group, $version)
    {
        $versions = array_get($this->migrations, $group, []);

        return array_get($versions, $version, null);
    }

    /**
     * @param string $name
     * @param string $class
     */
    public function registerSeed($name, $class)
    {
        $this->registerSeeds([
            $name => $class,
        ]);
    }

    /**
     * @param array $seeds
     */
    public function registerSeeds(array $seeds)
    {
        $this->seeds = array_merge($this->seeds, $seeds);
    }

    /**
     * @return string
     */
    public function defaultSeed()
    {
        return $this->default_seed;
    }

    /**
     * @param string $seed
     */
    public function setDefaultSeed($seed)
    {
        $this->default_seed = $seed;
    }

    /**
     * @return array
     */
    public function seedNames()
    {
        return array_keys($this->seeds);
    }

    /**
     * @param string $name
     *
     * @return string
     */
    public function seedClass($name)
    {
        return array_get($this->seeds, $name);
    }

    /**
     */
    public function makeLogTable()
    {
        if (!Schema::hasTable($this->table)) {
            Schema::create($this->table, function (Blueprint $table) {
                $table->string('group');
                $table->string('version');
                $table->string('class');

                $table->unique(['group', 'version']);
            });
        }
    }

    /**
     * @param bool $descending
     *
     * @return \Illuminate\Support\Collection
     */
    public function installedMigrations($descending = false)
    {
        return collect($this->db->table($this->table)->get())->sort(function ($a, $b) use ($descending) {
            return $this->compareMigrationVersion($a->version, $b->version) * ($descending ? -1 : 1);
        })->groupBy('group');
    }
    /**
     * @return \Illuminate\Support\Collection
     */
    public function installedMigrationsByDesc()
    {
        return $this->installedMigrations(true);
    }

    /**
     * @return \Illuminate\Support\Collection
     */
    public function installedLatestMigrations()
    {
        return collect($this->db->table($this->table)->get())->reduce(function ($result, $item) {
            if (isset($result[$item->group])) {
                if ($this->compareMigrationVersion($item->version, $result[$item->group]->version) > 0) {
                    $result[$item->group] = $item;
                }
            } else {
                $result[$item->group] = $item;
            }

            return $result;
        }, collect());
    }

    /**
     * @param string $group
     * @param string $version
     * @param string $class
     */
    public function addMigrationLog($group, $version, $class)
    {
        $this->db->table($this->table)->insert([
            'group' => $group,
            'version' => $version,
            'class' => $class,
        ]);
    }

    /**
     * @param string $group
     * @param string $version
     */
    public function removeMigrationLog($group, $version)
    {
        $this->db->table($this->table)->where('group', $group)->where('version', $version)->delete();
    }

    /**
     * @param string $group
     * @param string $version
     * @param string $class
     */
    public function doUpgrade($group, $version, $class)
    {
        $migration = new $class();

        $migration->up();

        $this->addMigrationLog($group, $version, $class);
    }

    /**
     * @param string $group
     * @param string $version
     * @param string $class
     */
    public function doDowngrade($group, $version, $class = null)
    {
        if ($class === null) {
            $class = $this->migrationClass($group, $version);
        }

        $migration = new $class();

        $migration->down();

        $this->removeMigrationLog($group, $version);
    }
}


1		<?php
2
3		namespace Jumilla\Versionia\Laravel;
4
5		use Illuminate\Database\DatabaseManager;
6		use Illuminate\Contracts\Config\Repository as Config;
7		use Illuminate\Database\Schema\Blueprint;
8		use Illuminate\Support\Facades\Schema;
9
10		class Migrator
11		{
12		const VERSION_NULL = null;
13
14		/**
15		* @var \Illuminate\Database\DatabaseManager
16		*/
17		protected $db;
18
19		/**
20		* @var string
21		*/
22		protected $table = 'migrations';
23
24		/**
25		* @var array
26		*/
27		protected $migrations = [];
28
29		/**
30		* @var array
31		*/
32		protected $seeds = [];
33
34		/**
35		* @var string
36		*/
37		protected $default_seed;
38
39		/**
40		* @param \Illuminate\Contracts\Database\DatabaseManager $db
41		* @param \Illuminate\Contracts\Config\Repository $config
42		*/
43	45	public function __construct(DatabaseManager $db, Config $config = null)
44		{
45	45	$this->db = $db;
46	45	if ($config) {
47	2	$this->table = $config->get('database.migrations', $this->table);
48	2	}
49	45	}
50
51		/**
52		* @return string
53		*/
54	2	public function getTable()
55		{
56	2	return $this->table;
57		}
58
59		/**
60		* @param string $a
61		* @param string $b
62		*
63		* @return int
64		*/
65	18	public function compareMigrationVersion($a, $b)
66		{
67	18	return version_compare($a, $b);
68		}
69
70		/**
71		* @param string $group
72		* @param string $version
73		* @param string $class
74		*/
75	4	public function registerMigration($group, $version, $class)
76		{
77	4	$this->registerMigrations($group, [
78	4	$version => $class,
79	4	]);
80	4	}
81
82		/**
83		* @param string $group
84		* @param array $versions
85		*/
86	22	public function registerMigrations($group, array $versions)
87		{
88	22	foreach ($versions as $version => $class) {
89	21	$this->migrations[$group][$version] = $class;
90	22	}
91	22	}
92
93		/**
94		* @return array
95		*/
96	22	public function migrationGroups()
97		{
98	22	$groups = array_keys($this->migrations);
99
100	22	sort($groups);
101
102	22	return $groups;
103		}
104
105		/**
106		* @param string $group
107		* @param bool $descending
108		*
109		* @return array
110		*/
111	15	public function migrationVersions($group, $descending = false)
112		{
113	15	$versions = array_get($this->migrations, $group, []);
114
115	15	uksort($versions, [$this, 'compareMigrationVersion']);
116
117	15	return $descending ? array_reverse($versions, true) : $versions;
118		}
119
120		/**
121		* @param string $group
122		*
123		* @return array
124		*/
125	11	public function migrationVersionsByDesc($group)
126		{
127	11	return $this->migrationVersions($group, true);
128		}
129
130		/**
131		* @param string $group
132		*
133		* @return string
134		*/
135	4	public function migrationLatestVersion($group)
136		{
137	4	foreach ($this->migrationVersionsByDesc($group) as $version => $class) {
138	4	return $version;
139	1	}
140
141	1	return self::VERSION_NULL;
142		}
143
144		/**
145		* @param string $group
146		* @param string $version
147		*
148		* @return string
149		*/
150	2	public function migrationClass($group, $version)
151		{
152	2	$versions = array_get($this->migrations, $group, []);
153
154	2	return array_get($versions, $version, null);
155		}
156
157		/**
158		* @param string $name
159		* @param string $class
160		*/
161	2	public function registerSeed($name, $class)
162		{
163	2	$this->registerSeeds([
164	2	$name => $class,
165	2	]);
166	2	}
167
168		/**
169		* @param array $seeds
170		*/
171	9	public function registerSeeds(array $seeds)
172		{
173	9	$this->seeds = array_merge($this->seeds, $seeds);
174	9	}
175
176		/**
177		* @return string
178		*/
179	7	public function defaultSeed()
180		{
181	7	return $this->default_seed;
182		}
183
184		/**
185		* @param string $seed
186		*/
187	7	public function setDefaultSeed($seed)
188		{
189	7	$this->default_seed = $seed;
190	7	}
191
192		/**
193		* @return array
194		*/
195	5	public function seedNames()
196		{
197	5	return array_keys($this->seeds);
198		}
199
200		/**
201		* @param string $name
202		*
203		* @return string
204		*/
205	9	public function seedClass($name)
206		{
207	9	return array_get($this->seeds, $name);
208		}
209
210		/**
211		*/
212	2	public function makeLogTable()
213		{
214	2	if (!Schema::hasTable($this->table)) {
215		Schema::create($this->table, function (Blueprint $table) {
216	1	$table->string('group');
217	1	$table->string('version');
218	1	$table->string('class');
219
220	1	$table->unique(['group', 'version']);
221	1	});
222	1	}
223	2	}
224
225		/**
226		* @param bool $descending
227		*
228		* @return \Illuminate\Support\Collection
229		*/
230	1	public function installedMigrations($descending = false)
231		{
232		return collect($this->db->table($this->table)->get())->sort(function ($a, $b) use ($descending) {
233	1	return $this->compareMigrationVersion($a->version, $b->version) * ($descending ? -1 : 1);
234	1	})->groupBy('group');
235		}
236		/**
237		* @return \Illuminate\Support\Collection
238		*/
239	1	public function installedMigrationsByDesc()
240		{
241	1	return $this->installedMigrations(true);
242		}
243
244		/**
245		* @return \Illuminate\Support\Collection
246		*/
247		public function installedLatestMigrations()
248		{
249	1	return collect($this->db->table($this->table)->get())->reduce(function ($result, $item) {
250	1	if (isset($result[$item->group])) {
251	1	if ($this->compareMigrationVersion($item->version, $result[$item->group]->version) > 0) {
252	1	$result[$item->group] = $item;
253	1	}
254	1	} else {
255	1	$result[$item->group] = $item;
256		}
257
258	1	return $result;
259	1	}, collect());
260		}
261
262		/**
263		* @param string $group
264		* @param string $version
265		* @param string $class
266		*/
267	1	public function addMigrationLog($group, $version, $class)
268		{
269	1	$this->db->table($this->table)->insert([
270	1	'group' => $group,
271	1	'version' => $version,
272	1	'class' => $class,
273	1	]);
274	1	}
275
276		/**
277		* @param string $group
278		* @param string $version
279		*/
280	1	public function removeMigrationLog($group, $version)
281		{
282	1	$this->db->table($this->table)->where('group', $group)->where('version', $version)->delete();
283	1	}
284
285		/**
286		* @param string $group
287		* @param string $version
288		* @param string $class
289		*/
290	1	public function doUpgrade($group, $version, $class)
291		{
292	1	$migration = new $class();
293
294	1	$migration->up();
295
296	1	$this->addMigrationLog($group, $version, $class);
297	1	}
298
299		/**
300		* @param string $group
301		* @param string $version
302		* @param string $class
303		*/
304	2	public function doDowngrade($group, $version, $class = null)
305		{
306	2	if ($class === null) {
307	1	$class = $this->migrationClass($group, $version);
308	1	}
309
310	2	$migration = new $class();
311
312	2	$migration->down();
313
314	2	$this->removeMigrationLog($group, $version);
315	2	}
316		}
317

jumilla / laravel-versionia

Push — master ( 7f191b...9a8f06 )

Migrator::getTable() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like