GeminiLabs\SiteReviews\Modules\Migrate

Complexity

Total Complexity

29

Size/Duplication

Total Lines	188
Duplicated Lines	0 %

Test Coverage

Coverage

83.33%

Importance

Changes	2
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	run()	0	6	2
A	isMigrationNeeded()	0	10	3
A	reset()	0	3	1
A	currentVersion()	0	12	3
A	__construct()	0	5	1
A	availableMigrations()	0	14	4
A	pendingMigrations()	0	7	2
A	storedMigrations()	0	12	3
A	storeMigrations()	0	3	1
A	createMigrations()	0	7	2
A	updateVersionFrom()	0	4	1
A	runAll()	0	4	1
A	runMigrations()	0	21	5

<?php

namespace GeminiLabs\SiteReviews\Modules;

use DirectoryIterator;
use GeminiLabs\SiteReviews\Database;
use GeminiLabs\SiteReviews\Database\OptionManager;
use GeminiLabs\SiteReviews\Helper;
use GeminiLabs\SiteReviews\Helpers\Arr;

class Migrate
{
    /**
     * @var string
     */
    public $currentVersion;

    /**
     * @var string[]
     */
    public $migrations;

    /**
     * @var string
     */
    public $migrationsKey;

    public function __construct()
    {
        $this->currentVersion = $this->currentVersion();
        $this->migrations = $this->availableMigrations();
        $this->migrationsKey = glsr()->prefix.'migrations';
    }

    /**
     * @return bool
     */
    public function isMigrationNeeded()
    {
        if (empty($this->migrations)) {
            return false;
        }
        if (!empty($this->pendingMigrations())) {
            // check if this is a fresh install of the plugin
            return glsr(OptionManager::class)->get('version_upgraded_from') !== '0.0.0';
        }
        return false;
    }

    /**
     * @return void
     */
    public function reset()
    {
        delete_option($this->migrationsKey);
    }

    /**
     * @return void
     */
    public function run()
    {
        if (glsr(Database::class)->isMigrationNeeded()) {
            $this->runAll();
        } else {
            $this->runMigrations();
        }
    }

    /**
     * @return void
     */
    public function runAll()
    {
        $this->reset();
        $this->runMigrations();
    }

    /**
     * @return array
     */
    protected function availableMigrations()
    {
        $migrations = [];
        $dir = glsr()->path('plugin/Modules/Migrations');
        if (is_dir($dir)) {
            $iterator = new DirectoryIterator($dir);
            foreach ($iterator as $fileinfo) {
                if ('file' === $fileinfo->getType()) {
                    $migrations[] = str_replace('.php', '', $fileinfo->getFilename());
                }
            }
            natsort($migrations);
        }
        return Arr::reindex($migrations);
    }

    /**
     * @return array
     */
    protected function createMigrations()
    {
        $migrations = [];
        foreach ($this->migrations as $migration) {
            $migrations[$migration] = false;
        }
        return $migrations;
    }

    /**
     * @return string
     */
    protected function currentVersion()
    {
        $fallback = '0.0.0';
        $majorVersions = range(glsr()->version('major'), 1);
        foreach ($majorVersions as $majorVersion) {
            $settings = get_option(OptionManager::databaseKey($majorVersion));
            $version = Arr::get($settings, 'version', $fallback);
            if (Helper::isGreaterThan($version, $fallback)) {
                return $version;
            }
        }
        return $fallback;
    }

    /**
     * @return string[]
     */
    protected function pendingMigrations(array $migrations = [])
    {
        if (empty($migrations)) {
            $migrations = $this->storedMigrations();
        }
        return array_keys(array_filter($migrations, function ($hasRun) {
            return !$hasRun;
        }));
    }

    /**
     * @return void
     */
    protected function runMigrations()
    {
        wp_raise_memory_limit('admin');
        $migrations = $this->storedMigrations();
        glsr()->action('migration/start', $migrations);
        foreach ($this->pendingMigrations($migrations) as $migration) {
            if (class_exists($classname = __NAMESPACE__.'\Migrations\\'.$migration)) {
                if (glsr($classname)->run()) {
                    $migrations[$migration] = true;
                    glsr_log()->debug("[$migration] has run successfully");
                    continue;
                }
                glsr_log()->error("[$migration] was unsuccessful");
            }
        }
        $this->storeMigrations($migrations);
        if ($this->currentVersion !== glsr()->version) {
            $this->updateVersionFrom($this->currentVersion);
        }
        glsr(OptionManager::class)->set('last_migration_run', current_time('timestamp'));
        glsr()->action('migration/end', $migrations);
    }

    /**
     * @return void
     */
    protected function storeMigrations(array $migrations)
    {
        update_option($this->migrationsKey, $migrations);
    }

    /**
     * @return array
     */
    protected function storedMigrations()
    {
        $migrations = Arr::consolidate(get_option($this->migrationsKey));
        if (!Arr::compare(array_keys($migrations), array_values($this->migrations))) {
            $newMigrations = $this->createMigrations();
            foreach ($newMigrations as $migration => &$hasRun) {
                $hasRun = Arr::get($migrations, $migration, false);
            }
            $migrations = $newMigrations;
            $this->storeMigrations($migrations);
        }
        return array_map('wp_validate_boolean', $migrations);
    }

    /**
     * @param string $previousVersion
     * @return void
     */
    protected function updateVersionFrom($previousVersion)
    {
        glsr(OptionManager::class)->set('version', glsr()->version);
        glsr(OptionManager::class)->set('version_upgraded_from', $previousVersion);
    }
}