CodexShaper\Dumper\Traits\DumperTrait

Complexity

Total Complexity

42

Size/Duplication

Total Lines	274
Duplicated Lines	0 %

Test Coverage

Coverage

25.81%

Importance

Changes	3
Bugs	0	Features	0

32 Methods

Rating	Name	Duplication	Size	Complexity
A	setUserName()	0	5	1
A	setHost()	0	5	1
A	setTimeOut()	0	5	1
A	setDbName()	0	4	1
A	setPassword()	0	5	1
A	setSocket()	0	5	1
A	setPort()	0	5	1
A	setCompressBinaryPath()	0	4	1
A	isWindows()	0	3	2
A	getPassword()	0	3	1
A	setDestinationPath()	0	5	1
A	setCommandBinaryPath()	0	5	1
A	getHost()	0	3	1
A	getDbName()	0	3	1
A	getTimeOut()	0	3	1
A	removeExtraSpaces()	0	3	1
A	getRestorePath()	0	3	1
A	setRestorePath()	0	5	1
A	getRestoreCommand()	0	13	3
A	setCompressExtension()	0	4	1
A	enableDebug()	0	4	1
A	getSocket()	0	3	1
A	getCommandBinaryPath()	0	3	1
A	getPort()	0	3	1
A	setCompressCommand()	0	5	1
A	getUserName()	0	3	1
A	setTables()	0	13	3
A	getDumpCommand()	0	13	3
A	setIgnoreTables()	0	14	3
A	quoteCommand()	0	3	2
A	getDestinationPath()	0	3	1
A	useCompress()	0	8	1

<?php

namespace CodexShaper\Dumper\Traits;

trait DumperTrait
{
    /*@var string*/
    protected $dbName;
    /*@var string*/
    protected $username;
    /*@var string*/
    protected $password;
    /*@var string*/
    protected $host = 'localhost';
    /*@var int*/
    protected $port = 3306;
    /*@var string*/
    protected $socket = '';
    /*@var string*/
    protected $commandBinaryPath = '';
    /*@var int*/
    protected $timeout = 0;
    /*@var array*/
    protected $tables = [];
    /*@var array*/
    protected $ignoreTables = [];
    /*@var string*/
    protected $destinationPath = 'dump.sql';
    /*@var string*/
    protected $restorePath = 'dump.sql';
    /*@var bool*/
    protected $isCompress = false;
    /*@var string*/
    protected $compressCommand = "gzip";
    /*@var string*/
    protected $compressBinaryPath = "";
    /*@var string*/
    protected $compressExtension = ".gz";
    /*@var bool*/
    protected $debug = false;
    /*@var string*/
    protected $command = "";

    public function setDbName(string $name)
    {
        $this->dbName = $name;
        return $this;
    }

    public function setUserName(string $username)
    {
        $this->username = $username;

        return $this;
    }

    public function setPassword(string $password)
    {
        $this->password = $password;

        return $this;
    }

    public function setHost(string $host)
    {
        $this->host = $host;

        return $this;
    }

    public function setPort(int $port)
    {
        $this->port = $port;

        return $this;
    }

    public function setSocket(string $socket)
    {
        $this->socket = $socket;

        return $this;
    }

    public function setTimeOut(int $timeout)
    {
        $this->timeout = $timeout;

        return $this;
    }
    /**
     * @param string|array $tables
     * @throws \Exception
     */
    public function setTables($tables)
    {
        if (!empty($this->ignoreTables)) {
            throw new \Exception("You can choose only once between tables and ignoreTables at a time");
        }

        if (is_string($tables)) {
            $tables = [$tables];
        }

        $this->tables = $tables;

        return $this;
    }
    /**
     * @param string|array $tables
     * @throws \Exception
     */
    public function setIgnoreTables($tables)
    {
        if (!empty($this->tables)) {
            throw new \Exception("You can choose only once between tables and ignoreTables at a time");

        }

        if (is_string($tables)) {
            $tables = [$tables];
        }

        $this->ignoreTables = $tables;

        return $this;
    }

    public function setCommandBinaryPath(string $path)
    {
        $this->commandBinaryPath = $path;

        return $this;
    }

    public function setDestinationPath(string $path)
    {
        $this->destinationPath = $path;

        return $this;
    }

    public function setRestorePath(string $path)
    {
        $this->restorePath = $path;

        return $this;
    }

    // Compress
    public function setCompressBinaryPath(string $path)
    {
        $this->compressBinaryPath = $path;
        return $this;
    }

    public function setCompressCommand(string $command)
    {
        $this->compressCommand = $command;
        $this->isCompress      = true;
        return $this;
    }

    public function setCompressExtension(string $extension)
    {
        $this->compressExtension = $extension;
        return $this;
    }

    public function useCompress(string $command = "gzip", string $extension = ".gz", string $binary_path = "")
    {
        $this->compressCommand    = $command;
        $this->compressExtension  = $extension;
        $this->compressBinaryPath = $binary_path;
        $this->isCompress         = true;

        return $this;
    }

    public function enableDebug()
    {
        $this->debug = true;
        return $this;
    }

    public function getDbName()
    {
        return $this->dbName;
    }

    public function getUserName()
    {
        return $this->username;
    }

    public function getPassword()
    {
        return $this->password;
    }

    public function getHost()
    {
        return $this->host;
    }

    public function getPort()
    {
        return $this->port;
    }

    public function getSocket()
    {
        return $this->socket;
    }

    public function getTimeOut()
    {
        return $this->timeout;
    }

    public function getCommandBinaryPath()
    {
        return $this->commandBinaryPath;
    }

    public function getDestinationPath()
    {
        return $this->destinationPath;
    }

    public function getRestorePath()
    {
        return $this->restorePath;
    }

    public function getDumpCommand(string $credentialFile = '', $destinationPath = '')
    {
        $destinationPath = !empty($destinationPath) ? $destinationPath : $this->destinationPath;
        switch (strtolower($this->getDumperClassName())) {

It seems like getDumperClassName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            case 'mysqldumper':
                $dumpCommand = $this->prepareDumpCommand($credentialFile, $destinationPath);

It seems like prepareDumpCommand() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                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);

It seems like prepareRestoreCommand() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                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}'";
    }
}