CodexShaper\Dumper\Drivers\PgsqlDumper

Complexity

Total Complexity

15

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	doNotCreateTables()	0	5	1
A	useInserts()	0	4	1
A	runCommand()	0	21	3
A	prepareDumpCommand()	0	20	2
A	prepareUseInserts()	0	3	2
A	restore()	0	6	2
A	dump()	0	6	2
A	prepareRestoreCommand()	0	16	2

<?php

namespace CodexShaper\Dumper\Drivers;

use CodexShaper\Dumper\Dumper;
use Symfony\Component\Process\Exception\ProcessFailedException;

class PgsqlDumper extends Dumper
{
    /*@var int*/
    protected $port = 5432;
    /*@var bool*/
    protected $useInserts = false;
    /*@var bool*/
    protected $createTables = true;

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

    public function doNotCreateTables()
    {
        $this->createTables = false;

        return $this;
    }

    public function dump(string $destinationPath = "")
    {
        $destinationPath = !empty($destinationPath) ? '"' . $destinationPath . '"' : '"' . $this->destinationPath . '"';
        $dumpCommand     = $this->prepareDumpCommand($destinationPath);
        $this->command   = $this->removeExtraSpaces($dumpCommand);
        $this->runCommand();
    }

    public function restore(string $restorePath = "")
    {
        $restorePath    = !empty($restorePath) ? '"' . $restorePath . '"' : '"' . $this->restorePath . '"';
        $restoreCommand = $this->prepareRestoreCommand($restorePath);
        $this->command  = $this->removeExtraSpaces($restoreCommand);
        $this->runCommand();
    }

    protected function prepareDumpCommand(string $destinationPath): string
    {
        $dumpCommand = sprintf(
            '%s -U %s -h %s %s %s %s %s %s %s',
            $this->quoteCommand($this->commandBinaryPath . 'pg_dump'),
            $this->prepareUserName(),
            $this->prepareHost(),
            $this->preparePort(),
            $this->prepareUseInserts(),
            $this->prepareCreateTables(),
            $this->prepareIncludeTables(),
            $this->prepareIgnoreTables(),
            $this->prepareDatabase()
        );

        if ($this->isCompress) {
            $compressCommand = $this->quoteCommand("{$this->compressBinaryPath}{$this->compressCommand}");
            return "{$dumpCommand} | {$compressCommand} > \"{$destinationPath}{$this->compressExtension}\"";
        }
        return "{$dumpCommand} > \"{$destinationPath}\"";
    }

    protected function prepareRestoreCommand(string $filePath): string
    {
        $restoreCommand = sprintf("%s -U %s -h %s %s %s",
            $this->quoteCommand($this->commandBinaryPath . 'psql'),
            $this->prepareUserName(),
            $this->prepareHost(),
            $this->preparePort(),
            $this->prepareDatabase()
        );

        if ($this->isCompress) {
            $compressCommand = $this->quoteCommand("{$this->compressBinaryPath}{$this->compressCommand}");
            return "{$compressCommand} < \"{$filePath}\" | {$restoreCommand}";
        }

        return "{$restoreCommand} < \"{$filePath}\"";
    }

    protected function runCommand()
    {
        try {

            $credentials    = $this->host . ':' . $this->port . ':' . $this->dbName . ':' . $this->username . ':' . $this->password;
            $this->tempFile = tempnam(sys_get_temp_dir(), 'pgsqlpass');

The property tempFile does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

            $handler        = fopen($this->tempFile, 'r+');
            fwrite($handler, $credentials);

It seems like $handler can also be of type false; however, parameter $handle of fwrite() does only seem to accept resource, maybe add an additional type check?

            $env     = ['PGPASSFILE' => $this->tempFile];
            $process = $this->prepareProcessCommand($this->command);

The call to CodexShaper\Dumper\Dumper::prepareProcessCommand() has too many arguments starting with $this->command.

            if ($this->debug) {
                $process->mustRun(null, $env);
            } else {
                $process->run(null, $env);
            }

            fclose($handler);

It seems like $handler can also be of type false; however, parameter $handle of fclose() does only seem to accept resource, maybe add an additional type check?

            unlink($this->tempFile);

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

        }
    }

    public function prepareUseInserts()
    {
        return ($this->useInserts) ? '--inserts' : '';
    }
}