ModelariumCodeCommand::generateFromModel() - Code Metrics - Corollarium/modelarium - Measure and Improve Code Quality continuously with Scrutinizer

ModelariumCodeCommand::generateFromModel() C
last analyzed 2021-09-29 18:11 UTC

↳ Parent: ModelariumCodeCommand
Complexity

Conditions	13
Paths	41
Size

Total Lines	91
Code Lines	58
Duplication

Lines	0
Ratio	0 %
Importance

Changes	3
Bugs	0	Features	0
Metric	Value
cc	13
eloc	58
c	3
b	0
f	0
nc	41
nop	1
dl	0
loc	91
rs	6.6166
How to fix Long Method Complexity

<?php declare(strict_types=1);

namespace Modelarium\Laravel\Console\Commands;

use Formularium\Factory\CodeGeneratorFactory;
use HaydenPierce\ClassFinder\ClassFinder;
use Illuminate\Console\Command;
use Modelarium\Parser;
use Modelarium\GeneratedCollection;
use Modelarium\GeneratedItem;
use Modelarium\Laravel\Processor as LaravelProcessor;
use Modelarium\Options;

class ModelariumCodeCommand extends Command
{
    use WriterTrait;


    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'modelarium:code
        {name : The model name. Use "*" or "all" for all models}
        {--generator= : The generators to use [SQL, GraphQL, Typescript]}
        {--path= : The output directory. Defaults to `resources/{generator}/`}
        {--lighthouse : use lighthouse directives}
        {--overwrite : overwrite all files if they exist}
        {--prettier : run prettier on files}
        {--eslint : run eslint fix on files}
    ';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Generates code using Modelarium';

    /**
     * @var string CodeGenerator
     */
    protected $generatorName = "";

    /**
     * @var Parser
     */
    protected $parser = null;

    /**
     * @var Options
     */
    protected $modelariumOptions = null;

    /**
     * Create a new command instance.
     *
     * @return void
     */
    public function __construct()
    {
        parent::__construct();

        // read from Options()
        $this->modelariumOptions = new Options();
    }

    /**
     * Execute the console command.
     *
     * @return mixed
     */
    public function handle()
    {
        $name = $this->argument('name');

        // setup stuff
        $generatorName = $this->option('generator');
        if (!is_string($this->generatorName)) {

            $this->error('Please specify a single generator.');
            return;
        }
        if (empty($this->generatorName)) {
            $this->error('Which code format to generate. Example: `--generator=TypeScript`');
            return;
        }
        /**
         * @var string $generatorName
         */
        $this->generatorName = (string)$generatorName;

        $this->loadParser();
        if ($name === '*' || $name === 'all') {
            /** @var array<class-string> $classesInNamespace */
            $classesInNamespace = ClassFinder::getClassesInNamespace('App\\Models');

            foreach ($classesInNamespace as $class) {
                $reflection = new \ReflectionClass($class);
                if (!$reflection->isInstantiable()) {
                    continue;
                }
                $this->generateFromModel($class);
            }
            return;
        } elseif (is_array($name)) {
            // TODO
        } else {
            $this->generateFromModel('\\App\\Models\\' . $name);
        }
        $this->info('Finished frontend.');
    }

    protected function loadParser(): void
    {
        $files = [
            __DIR__ . '/../../../Types/Graphql/scalars.graphql'
        ];
        if ($this->option('lighthouse') || $this->modelariumOptions->getOption('modelarium', 'lighthouse')) {
            $files[] = __DIR__ . '/../../Graphql/definitionsLighthouse.graphql';
        }

        $path = base_path('graphql');
        $path = /** @scrutinizer ignore-call */ base_path('graphql');
        $dir = \Safe\scandir($path);

        // parse directives from lighthouse
        $modelNames = array_diff($dir, array('.', '..'));

        foreach ($modelNames as $n) {
            if (mb_strpos($n, '.graphql') === false) {
                continue;
            }
            $files[] = base_path('graphql/' . $n);
        }
        $this->parser = new Parser();
        $this->parser->setImport('directives.graphql', LaravelProcessor::getDirectivesGraphqlString());
        $this->parser->fromFiles($files);
    }

    protected function generateFromModel(string $name): void
    {
        $generator = CodeGeneratorFactory::factory($this->generatorName);
        $model = $name::getFormularium();
        $this->info("Starting $name...");

        $code = $generator->type($model);

        if (!$code) {
            $this->info('Nothing generated.');
            return;
        }

        $basepath = $this->option('path') ?: base_path('resources/' . $generator->getName());
        $basepath = $this->option('path') ?: /** @scrutinizer ignore-call */ base_path('resources/' . $generator->getName());
        if (!is_dir($basepath)) {
            \Safe\mkdir($basepath, 0777, true);
        }

        $collection = new GeneratedCollection();
        $collection->push(
            new GeneratedItem(
                GeneratedItem::TYPE_FRONTEND,
                $code,
                $generator->getFilename($model->getName())
            )
        );

        $datatypeDeclarations = $generator->datatypeDeclarations();
        if ($datatypeDeclarations) {
            $collection->push(
                new GeneratedItem(
                    GeneratedItem::TYPE_FRONTEND,
                    $datatypeDeclarations,
                    $generator->getFilename('Scalars')
                )
            );
        }

        if (!$collection->count()) {
            $this->info('Nothing generated.');
            return;
        }

        $writtenFiles = $this->writeFiles(
            $collection,
            $basepath,
            function (GeneratedItem $i) {
            function (/** @scrutinizer ignore-unused */ GeneratedItem $i) {
                if ((bool)$this->option('overwrite') === true) {
                    return true;
                }
                return false;
            }
        );
        $this->info('Files generated.');

        if ($this->option('prettier') !== null ?: $this->modelariumOptions->getOption('frontend', 'prettier')) {

            $this->info('Running prettier on generated files.');
            $useYarn = file_exists(base_path('yarn.lock'));
            if ($useYarn) {
                $command = "cd $basepath && npx prettier --write ";
            } else {
                $command = "cd $basepath && yarn prettier --write ";
            }

            // this runs all prettier commands in parallel.
            $run = array_reduce(
                $writtenFiles,
                function ($carry, $f) use ($command) {
                    return $carry . '(' . $command . $f . ') & ';
                }
            );
            shell_exec($run . ' wait');
        }

        if ($this->option('eslint') !== null ?: $this->modelariumOptions->getOption('frontend', 'eslint')) {

            $this->info('Running eslint on generated files.');
            $useYarn = file_exists(base_path('yarn.lock'));
            if ($useYarn) {
                $command = "cd $basepath && npx eslint --fix ";
            } else {
                $command = "cd $basepath && yarn eslint --fix ";
            }

            // this runs all prettier commands in parallel.
            $run = array_reduce(
                $writtenFiles,
                function ($carry, $f) use ($command) {
                    return $carry . '(' . $command . $f . ') & ';
                }
            );
            shell_exec($run . ' wait');
        }
    }
}

Corollarium / modelarium

ModelariumCodeCommand::generateFromModel() C last analyzed 2021-09-29 18:11 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

ModelariumCodeCommand::generateFromModel() C
last analyzed 2021-09-29 18:11 UTC
