ImportCommand::checkFilename() - Code Metrics - Inspection of "[BUGFIX] Bugfx in reinit to prevent config already..." - netz98/n98-magerun2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#177)

unknown
created 2016-02-16 06:20 UTC
ImportCommand::checkFilename() A

↳ Parent: ImportCommand
Complexity

Conditions	2
Paths	2
Size

Total Lines	8
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Metric	Value
dl	0
loc	8
rs	9.4285
cc	2
eloc	5
nc	2
nop	1
<?php

namespace N98\Magento\Command\Database;

use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

class ImportCommand extends AbstractDatabaseCommand
{
    protected function configure()
    {
        $this
            ->setName('db:import')
            ->addArgument('filename', InputArgument::OPTIONAL, 'Dump filename')
            ->addOption('compression', 'c', InputOption::VALUE_REQUIRED, 'The compression of the specified file')
            ->addOption('only-command', null, InputOption::VALUE_NONE, 'Print only mysql command. Do not execute')
            ->addOption('only-if-empty', null, InputOption::VALUE_NONE, 'Imports only if database is empty')
            ->addOption('optimize', null, InputOption::VALUE_NONE, 'Convert verbose INSERTs to short ones before import (not working with compression)')

            ->addOption('drop', null, InputOption::VALUE_NONE, 'Drop and recreate database before import')
            ->addOption('drop-tables', null, InputOption::VALUE_NONE, 'Drop tables before import')
            ->setDescription('Imports database with mysql cli client according to database defined in local.xml');

        $help = <<<HELP
Imports an SQL file with mysql cli client into current configured database.

You need to have MySQL client tools installed on your system.
HELP;
        $this->setHelp($help);

    }

    /**
     * @return bool
     */
    public function isEnabled()
    {
        return function_exists('exec');
    }

    /**
     * Optimize a dump by converting single INSERTs per line to INSERTs with multiple lines
     * @param $fileName
     * @return string temporary filename
     */
    protected function optimize($fileName)
    {
        $in = fopen($fileName,'r');
        $result = tempnam(sys_get_temp_dir(), 'dump') . '.sql';
        $out = fopen($result, 'w');

        $currentTable = '';
        $maxlen = 8 * 1024 * 1024; // 8 MB
        $len = 0;
        while ($line = fgets($in)) {
            if (strtolower(substr($line, 0, 11)) == 'insert into') {
                preg_match('/^insert into `(.*)` \(.*\) values (.*);/i', $line, $m);

                if (count($m) < 3) { // fallback for very long lines or other cases where the preg_match fails

                    if ($currentTable != '') {
                        fwrite($out, ";\n");
                    }
                    fwrite($out, $line);
                    $currentTable = '';
                    continue;
                }

                $table = $m[1];
                $values = $m[2];

                if ($table != $currentTable or ($len > $maxlen - 1000)) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                    if ($currentTable != '') {
                        fwrite($out, ";\n\n");
                    }
                    $currentTable = $table;
                    $insert = 'INSERT INTO `' . $table . '` VALUES ' . $values;
                    fwrite($out, $insert);
                    $len = strlen($insert);
                } else {
                    fwrite($out, ',' . $values);
                    $len += strlen($values) + 1;
                }
            } else {

                if ($currentTable != '') {
                    fwrite($out, ";\n");
                    $currentTable = '';
                }
                fwrite($out, $line);
            }

        }
        fclose($in);
        fclose($out);

        return $result;

    }
    /**
     * @param \Symfony\Component\Console\Input\InputInterface $input
     * @param \Symfony\Component\Console\Output\OutputInterface $output
     * @return int|void
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->detectDbSettings($output);
        $this->writeSection($output, 'Import MySQL Database');
        $dbHelper = $this->getHelper('database');

        $fileName = $this->checkFilename($input);

        $compressor = $this->getCompressor($input->getOption('compression'));

        // create import command
        $exec = $compressor->getDecompressingCommand(
            'mysql ' . $dbHelper->getMysqlClientToolConnectionString(),
            $fileName
        );
        if ($input->getOption('only-command')) {
            $output->writeln($exec);

            return;
        } else {
            if ($input->getOption('only-if-empty')
                && count($dbHelper->getTables()) > 0
            ) {
                $output->writeln('<comment>Skip import. Database is not empty</comment>');

                return;
            }
        }

        if ($input->getOption('optimize')) {
            if ($input->getOption('compression')) {
                throw new \Exception('Options --compression and --optimize are not compatible');
            }
            $output->writeln('<comment>Optimizing <info>' . $fileName . '</info> to temporary file');
            $fileName = $this->optimize($fileName);
        }

        if( $input->getOption('drop') ) {
            $dbHelper->dropDatabase($output);
            $dbHelper->createDatabase($output);
        }
        if( $input->getOption('drop-tables') ) {
            $dbHelper->dropTables($output);
        }




            $this->doImport($output, $fileName, $exec);

        if ($input->getOption('optimize')) {
            unlink($fileName);
        }
    }

    public function asText() {
        return parent::asText() . "\n" .

            $this->getCompressionHelp();
    }

    /**
     * @param InputInterface $input
     *
     * @return mixed
     * @throws \InvalidArgumentException
     */
    protected function checkFilename(InputInterface $input)
    {
        $fileName = $input->getArgument('filename');
        if (!file_exists($fileName)) {
            throw new \InvalidArgumentException('File does not exist');
        }
        return $fileName;
    }

    /**
     * @param OutputInterface $output
     * @param string          $fileName
     * @param string          $exec
     *
     * @return void
     */
    protected function doImport(OutputInterface $output, $fileName, $exec)
    {
        $returnValue = null;
        $commandOutput = null;
        $output->writeln(
            '<comment>Importing SQL dump <info>' . $fileName . '</info> to database <info>'
            . $this->dbSettings['dbname'] . '</info>'
        );
        exec($exec, $commandOutput, $returnValue);
        if ($returnValue <> 0) {

            $output->writeln('<error>' . implode(PHP_EOL, $commandOutput) . '</error>');
        }
        $output->writeln('<info>Finished</info>');
    }
}

netz98 / n98-magerun2

Pull Request — master (#177)

ImportCommand::checkFilename() A

Complexity

Size

Duplication

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like
