Bluzman\Command\Generate\AbstractGenerateCommand

Complexity

Total Complexity

20

Size/Duplication

Total Lines	207
Duplicated Lines	6.76 %

Coupling/Cohesion

Components	2
Dependencies	13

Test Coverage

Coverage

69.33%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
	verify()	0	1	?
A	addForceOption()	0	5	1
A	addModelArgument()	0	5	1
A	validateModelArgument()	0	14	3
A	addTableArgument()	0	5	1
A	validateTableArgument()	14	14	3
A	getTableInstance()	0	15	3
A	getTemplate()	0	5	1
A	generateFile()	0	14	3
A	getControllerPath()	0	7	1
A	getViewPath()	0	7	1
A	getPrimaryKey()	0	15	1
A	getColumns()	0	16	1

<?php
/**
 * @copyright Bluz PHP Team
 * @link https://github.com/bluzphp/bluzman
 */

namespace Bluzman\Command\Generate;

use Bluz\Db\Table;
use Bluz\Proxy\Db;
use Bluz\Validator\Validator;
use Bluzman\Command\AbstractCommand;
use Bluzman\Generator\Generator;
use Bluzman\Generator\GeneratorException;
use Bluzman\Input\InputArgument;
use Bluzman\Input\InputException;
use Bluzman\Input\InputOption;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * AbstractCommand
 *
 * @package  Bluzman\Command\Generate
 */
abstract class AbstractGenerateCommand extends AbstractCommand
{
    /**
     * @param InputInterface $input
     * @param OutputInterface $output
     * @return mixed
     */
    abstract public function verify(InputInterface $input, OutputInterface $output) : void;

    /**
     * Add Force Option
     *
     * @return void
     */
    protected function addForceOption() : void
    {
        $force = new InputOption('--force', '-f', InputOption::VALUE_NONE, 'Rewrite previously generated files');
        $this->getDefinition()->addOption($force);
    }

    /**
     * Add Model Argument
     *
     * @return void
     */
    protected function addModelArgument() : void
    {
        $model = new InputArgument('model', InputArgument::REQUIRED, 'Model name is required');
        $this->getDefinition()->addArgument($model);
    }

    /**
     * Validate Model Argument
     *
     * @return void
     * @throws \Bluzman\Input\InputException
     */
    protected function validateModelArgument() : void
    {
        $model = $this->getInput()->getArgument('model');

        $validator = Validator::create()
            ->string()
            ->alphaNumeric()
            ->noWhitespace();

        if ($this->getDefinition()->getArgument('model')->isRequired()
            && !$validator->validate($model)) {
            throw new InputException($validator->getError());
        }
    }

    /**
     * Add Table Argument
     *
     * @return void
     */
    protected function addTableArgument() : void
    {
        $table = new InputArgument('table', InputArgument::REQUIRED, 'Table name is required');
        $this->getDefinition()->addArgument($table);
    }

    /**
     * Validate Table Argument
     *
     * @return void
     * @throws \Bluzman\Input\InputException
     */
    protected function validateTableArgument() : void

This method seems to be duplicated in your project.

    {
        $table = $this->getInput()->getArgument('table');

        $validator = Validator::create()
            ->string()
            ->alphaNumeric('_')
            ->noWhitespace();

        if ($this->getDefinition()->getArgument('table')->isRequired()
            && !$validator->validate($table)) {
            throw new InputException($validator->getError());
        }
    }

    /**
     * Get Table instance
     *
     * @param  string $model
     *
     * @return Table
     * @throws \Bluzman\Generator\GeneratorException
     */
    protected function getTableInstance($model) : Table
    {
        $file = $this->getApplication()->getModelPath($model) . DS . 'Table.php';
        if (!file_exists($file)) {
            throw new GeneratorException(
                "Model $model is not exist, run command `bluzman generate:model $model` before"
            );
        }
        include_once $file;
        $class = '\\Application\\' . ucfirst($model) . '\\Table';
        if (!class_exists($class)) {
            throw new GeneratorException("Bluzman can't found `Table` class for model `$model`");
        }
        return $class::getInstance();
    }

    /**
     * Required for correct mock it
     *
     * @param  string $class
     * @return mixed
     */
    protected function getTemplate($class)
    {
        $class = '\\Bluzman\\Generator\\Template\\' . $class;
        return new $class;
    }

    /**
     * Small wrapper for simplify code
     *
     * @param  string $class
     * @param  string $file
     * @param  array  $data
     *
     * @return void
     */
    protected function generateFile($class, $file, array $data = []) : void
    {
        if (file_exists($file) && !$this->getInput()->getOption('force')) {
            $this->comment(" |> File <info>$file</info> already exists");
            return;
        }

        $template = $this->getTemplate($class);
        $template->setFilePath($file);
        $template->setTemplateData($data);

        $generator = new Generator($template);
        $generator->make();
    }

    /**
     * @return string
     */
    protected function getControllerPath($module, $controller) : string
    {
        return $this->getApplication()->getModulePath($module)
            . DS . 'controllers'
            . DS . $controller
            . '.php';
    }

    /**
     * @return string
     */
    protected function getViewPath($module, $controller) : string
    {
        return $this->getApplication()->getModulePath($module)
            . DS . 'views'
            . DS . $controller
            . '.phtml';
    }

    /**
     * @todo move it to DB class
     * @return array
     */
    protected function getPrimaryKey($table)
    {
        $connect = Db::getOption('connect');

        return Db::fetchColumn(
            '
            SELECT COLUMN_NAME
            FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
            WHERE TABLE_SCHEMA = ?
              AND TABLE_NAME = ?
             AND CONSTRAINT_NAME = ?
            ',
            [$connect['name'], $table, 'PRIMARY']
        );
    }

    /**
     * @todo move it to DB class
     * @return array
     */
    protected function getColumns($table)
    {
        $connect = Db::getOption('connect');

        return Db::fetchAll(
            '
            SELECT 
              COLUMN_NAME as name,
              COLUMN_TYPE as type
            FROM INFORMATION_SCHEMA.COLUMNS
            WHERE TABLE_SCHEMA = ?
              AND TABLE_NAME = ?
            ',
            [$connect['name'], $table]
        );
    }
}