Rawilk\LaravelModules\Commands\Generators\ModelMakeCommand

Complexity

Total Complexity

14

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getModelName()	0	3	1
A	getDefaultNamespace()	0	6	2
A	handleOptionalMigration()	0	8	2
A	createMigrationName()	0	25	4
A	getTemplateContents()	0	17	1
A	getDestinationFilePath()	0	7	1
A	getFillable()	0	9	2
A	handle()	0	5	1

<?php

namespace Rawilk\LaravelModules\Commands\Generators;

use Illuminate\Support\Str;
use Rawilk\LaravelModules\Support\Config\GenerateConfigReader;
use Rawilk\LaravelModules\Support\Stub;
use Rawilk\LaravelModules\Traits\ModuleCommands;

class ModelMakeCommand extends GeneratorCommand
{
    use ModuleCommands;

    /** @var string */
    protected $argumentName = 'model';

    /** @var string */
    protected $signature = 'module:make-model
                            {model : The name of the model}
                            {module? : The name of the module to create the model for}
                            {--fillable= : The fillable attributes}
                            {--base_class= : Override the default base model class (from config)}
                            {--table= : The name of the database table}
                            {--m|migration : Create a migration for the model as well}';

    /** @var string */
    protected $description = 'Create a new model for the specified module.';

    public function handle(): void
    {
        parent::handle();

        $this->handleOptionalMigration();
    }

    protected function getDefaultNamespace(): string
    {
        /** @var \Rawilk\LaravelModules\Contracts\Repository $module */
        $module = $this->laravel['modules'];

        return $module->config('paths.generator.model.namespace') ?: $module->config('paths.generator.model.path', 'Models');
    }

    protected function getDestinationFilePath(): string
    {
        $path = $this->laravel['modules']->getModulePath($this->getModuleName());

        $modelPath = GenerateConfigReader::read('model');

        return $path . $modelPath->getPath() . '/' . $this->getModelName() . '.php';
    }

    protected function getTemplateContents(): string
    {
        /** @var \Rawilk\LaravelModules\Module $module */
        $module = $this->laravel['modules']->findOrFail($this->getModuleName());

        return (new Stub('/model.stub', [
            'FILLABLE'         => $this->getFillable(),
            'NAME'             => $this->getModelName(),
            'NAMESPACE'        => $this->getClassNamespace($module),
            'CLASS'            => $this->getClass(),
            'LOWER_NAME'       => $module->getLowerName(),
            'STUDLY_NAME'      => $module->getStudlyName(),
            'MODULE_NAMESPACE' => $this->laravel['modules']->config('namespace'),
            'TABLE'            => $this->createMigrationName(),
            'BASE_CLASS'       => $this->getBaseClass('model'),
            'BASE_CLASS_SHORT' => $this->getBaseClass('model', true),
        ]))->render();
    }

    private function createMigrationName(): string
    {
        if ($table = $this->option('table')) {
            return $table;
        }

        $pieces = preg_split(
            '/(?=[A-Z])/',
            class_basename($this->argument('model')),

It seems like $this->argument('model') can also be of type string[]; however, parameter $class of class_basename() does only seem to accept object|string, maybe add an additional type check?

            -1,
            PREG_SPLIT_NO_EMPTY
        );

        $name = '';
        $count = count($pieces);

It seems like $pieces can also be of type false; however, parameter $var of count() does only seem to accept Countable|array, maybe add an additional type check?

        foreach ($pieces as $index => $piece) {
            if ($index + 1 < $count) {
                $name .= strtolower($piece) . '_';
            } else {
                $name .= Str::plural(strtolower($piece));
            }
        }

        return $name;
    }

    private function getFillable(): string
    {
        $fillable = $this->option('fillable');

        if ($fillable !== null) {

The condition $fillable !== null is always true.

            return str_replace(['"', ','], ["'", ', '], json_encode(explode(',', $fillable)));
        }

        return '[]';
    }

    private function getModelName(): string
    {
        return Str::studly($this->argument($this->argumentName));

It seems like $this->argument($this->argumentName) can also be of type string[]; however, parameter $value of Illuminate\Support\Str::studly() does only seem to accept string, maybe add an additional type check?

    }

    private function handleOptionalMigration(): void
    {
        if ($this->option('migration')) {
            $migrationName = 'create_' . $this->createMigrationName() . '_table';

            $this->call('module:make-migration', [
                'name'   => $migrationName,
                'module' => $this->argument('module')
            ]);
        }
    }
}