Dumper::getDumpCommand() - Code Metrics - Inspection of "Update Dumper" - Codexshaper/database-backup-restore - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( d26594...3115e1 )

by CodexShaper
created 2020-01-01 15:10 UTC
Dumper::getDumpCommand() A

↳ Parent: Dumper
Complexity

Conditions	3
Paths	4
Size

Total Lines	13
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	5
CRAP Score	3
Importance

Changes
Metric	Value
cc	3
eloc	9
nc	4
nop	2
dl	0
loc	13
ccs	5
cts	5
cp	1
crap	3
rs	9.9666
c	0
b	0
f	0
<?php

namespace CodexShaper\Dumper;

use CodexShaper\Dumper\Contracts\Dumper as DumperContract;
use CodexShaper\Dumper\Traits\DumperTrait;
use Symfony\Component\Process\Exception\ProcessFailedException;
use Symfony\Component\Process\Process;

abstract class Dumper implements DumperContract
{
    use DumperTrait;

    public function __construct(array $options = [])
    {
        foreach ($options as $option => $value) {
            if (property_exists($this, $option)) {
                $this->{$option} = $value;
            }
        }
    }
    /**
     * @return $this
     */
    public static function create(array $options = [])
    {
        return new static($options);
    }
    /**
     * @return \Symfony\Component\Process\Process
     */
    protected function prepareProcessCommand()
    {
        $process = Process::fromShellCommandline($this->command);
        $process->setTimeout($this->timeout);
        return $process;
    }
    /**
     * @return \Symfony\Component\Process\Process
     */
    protected function run()
    {
        try {

            $process = Process::fromShellCommandline($this->command);
            $process->setTimeout($this->timeout);

            if ($this->debug) {
                return $process->mustRun();
            }

            return $process->run();


        } catch (ProcessFailedException $e) {
            throw new \Exception($e->getMessage());

        }
    }

    abstract public function dump();
    abstract public function restore();

    public function prepareHost()
    {
        switch (strtolower($this->getClassName())) {
        switch (strtolower($this->/** @scrutinizer ignore-call */ getClassName())) {
            case 'pgsqldumper':
                $host = ($this->socket !== '') ? $this->socket : $this->host;
                break;
            case 'mongodumper';
                $host = !empty($this->host) ? "--host {$this->host}" : "";
                break;
            default:
                $host = $this->host;
                break;
        }
        return $host;
    }

    public function preparePort()
    {
        switch (strtolower($this->getClassName())) {
            case 'pgsqldumper':
                $port = !empty($this->port) ? '-p ' . $this->port : '';
                break;
            case 'mongodumper':
                $port = !empty($this->port) ? "--port {$this->port}" : "";
                break;
            default:
                $port = $this->port;
                break;
        }
        return $port;
    }

    public function prepareSocket()
    {
        switch (strtolower($this->getClassName())) {
            case 'mysqldumper':
                $socket = ($this->socket !== '') ? "--socket={$this->socket}" : '';
                break;
            default:
                $socket = $this->socket;
                break;
        }

        return $socket;
    }

    public function prepareDatabase()
    {
        switch (strtolower($this->getClassName())) {
            case 'mysqldumper':
            case 'pgsqldumper':
                $database = !empty($this->dbName) ? $this->dbName : "";
                break;
            case 'mongodumper';
                $database = !empty($this->dbName) ? "--db {$this->dbName}" : "";
                break;
            default:
                $database = $this->dbName;
                break;
        }
        return $database;
    }

    public function prepareUserName()
    {
        switch (strtolower($this->getClassName())) {
            case 'pgsqldumper':
                $username = !empty($this->username) ? $this->username : "";
                break;
            case 'mongodumper';
                $username = !empty($this->username) ? "--username {$this->username}" : "";
                break;
            default:
                $username = $this->username;
                break;
        }
        return $username;
    }

    public function prepareIncludeTables()
    {
        switch (strtolower($this->getClassName())) {
            case 'mysqldumper':
                $includeTables    = (count($this->tables) > 0) ? implode(' ', $this->tables) : '';
                $includeTablesArg = !empty($includeTables) ? "--tables {$includeTables}" : '';
                break;
            case 'pgsqldumper':
                $includeTablesArg = (count($this->tables) > 0) ? '-t ' . implode(' -t ', $this->tables) : "";
                break;
            default:
                $includeTablesArg = $this->tables;
                break;
        }

        return $includeTablesArg;
    }

    public function prepareIgnoreTables()
    {
        switch (strtolower($this->getClassName())) {
            case 'mysqldumper':
                $ignoreTablesArgs = [];
                foreach ($this->ignoreTables as $tableName) {
                    $ignoreTablesArgs[] = "--ignore-table={$this->dbName}.{$tableName}";
                }
                $ignoreTablesArg = (count($ignoreTablesArgs) > 0) ? implode(' ', $ignoreTablesArgs) : '';
                break;
            case 'pgsqldumper';
                $ignoreTablesArg = (count($this->ignoreTables) > 0) ? '-T ' . implode(' -T ', $this->ignoreTables) : '';
                break;
            default:
                $ignoreTablesArg = $this->ignoreTables;
                break;
        }

        return $ignoreTablesArg;
    }

    public function prepareCreateTables()
    {
        switch (strtolower($this->getClassName())) {
            case 'mysqldumper':
                $createTables = !$this->createTables ? '--no-create-info' : '';
                break;
            case 'pgsqldumper':
                $createTables = (!$this->createTables) ? '--data-only' : '';
                break;
            default:
                $createTables = $this->createTables;
                break;
        }
        return $createTables;
    }

    public function getDumpCommand(string $credentialFile = '', $destinationPath = '')
    {
        $destinationPath = !empty($destinationPath) ? $destinationPath : $this->destinationPath;
        switch (strtolower($this->getDumperClassName())) {
            case 'mysqldumper':
                $dumpCommand = $this->prepareDumpCommand($credentialFile, $destinationPath);
                $dumpCommand = $this->prepareDumpCommand($credentialFile, $destinationPath);
                break;
            default:
                $dumpCommand = $this->prepareDumpCommand($destinationPath);
                break;
        }

        return $this->removeExtraSpaces($dumpCommand);
    }

    public function getRestoreCommand(string $credentialFile = '', string $filePath = '')
    {
        $filePath = !empty($filePath) ? '"' . $filePath : $this->restorePath;
        switch (strtolower($this->getDumperClassName())) {
            case 'mysqldumper':
                $restoreCommand = $this->prepareRestoreCommand($credentialFile, $filePath);
                $restoreCommand = $this->prepareRestoreCommand($credentialFile, $filePath);
                break;
            default:
                $restoreCommand = $this->prepareRestoreCommand($filePath);
                break;
        }

        return $this->removeExtraSpaces($restoreCommand);
    }

    public function removeExtraSpaces(string $str)
    {
        return preg_replace('/\s+/', ' ', $str);
    }

    public static function isWindows()
    {
        return strcasecmp(substr(PHP_OS, 0, 3), 'WIN') == 0 ? true : false;
    }

    public function quoteCommand(string $command)
    {
        return static::isWindows() ? "\"{$command}\"" : "'{$command}'";
    }

    public function getDumperClassName()
    {
        $classWithNamespace = static::class;
        $partials           = explode("\\", $classWithNamespace);
        $className          = end($partials);
        return $className;
    }
}

Codexshaper / database-backup-restore

Push — master ( d26594...3115e1 )

Dumper::getDumpCommand() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
