Generator::resourceProperty() - Code Metrics - Inspection of "Specify what to generate" - mshamaseen/laravel-repositories - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — main (#8)

by Mohammad
created 2023-07-02 15:51 UTC
Generator::resourceProperty() A

↳ Parent: Generator
Complexity

Conditions	2
Paths	2
Size

Total Lines	10
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	5
c	0
b	0
f	0
nc	2
nop	0
dl	0
loc	10
rs	10
<?php

namespace Shamaseen\Repository\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\Config;
use Illuminate\Support\Str;
use Shamaseen\Generator\Generator as GeneratorService;
use Shamaseen\Repository\Events\RepositoryFilesGenerated;
use Shamaseen\Repository\PathResolver;

/**
 * Class RepositoryGenerator.
 */
class Generator extends Command
{
    const REPOSITORY_OPTION = 'repository';
    const CONTROLLER_OPTION = 'controller';
    const MODEL_OPTION = 'model';
    const RESOURCE_OPTION = 'transformer';
    const POLICY_OPTION = 'policy';
    const REQUEST_OPTION = 'input';

    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'generate:repository
    {name : Class (singular) for example User}
    {--base= : Base path to inject the files\folders in}
    {--f|force : force overwrite files}
    {--no-override : don\'t override any file}
    {--m|model : model only}
    {--c|controller : controller only}
    {--r|repository : repository only}
    {--t|transformer : transformers (API resources) only}
    {--p|policy : policy only}
    {--i|input : input validation (request file) only}';

    protected $description = 'Create repository files';

    protected string $modelName;
    protected string $userPath;
    // relative to project directory
    protected string $basePath;
    private GeneratorService $generator;

    private PathResolver $pathResolver;

    /**
     * Create a new command instance.
     */
    public function __construct(GeneratorService $generator)
    {
        parent::__construct();
        $this->generator = $generator;
    }

    /**
     * Execute the console command.
     */
    public function handle(): int
    {
        // if no file is specified, then generate them all
        if(!$this->option(self::REQUEST_OPTION) && !$this->option(self::CONTROLLER_OPTION)
            && !$this->option(self::REPOSITORY_OPTION) && !$this->option(self::RESOURCE_OPTION)
            && !$this->option(self::MODEL_OPTION) && !$this->option(self::POLICY_OPTION)
        ) {
            $this->input->setOption(self::MODEL_OPTION, true);
            $this->input->setOption(self::CONTROLLER_OPTION, true);
            $this->input->setOption(self::RESOURCE_OPTION, true);
            $this->input->setOption(self::REQUEST_OPTION, true);
            $this->input->setOption(self::REPOSITORY_OPTION, true);
            $this->input->setOption(self::POLICY_OPTION, true);
        }

        $paths = preg_split(' ([/\\\]) ', $this->argument('name'));
        $paths = preg_split(' ([/\\\]) ', /** @scrutinizer ignore-type */ $this->argument('name'));

        if (!$paths) {

            $this->error('Name argument is not correct.');

            return self::FAILURE;
        }

        $this->modelName = array_pop($paths);
        $this->userPath = implode('/', str_replace('\\', '/', $paths));
        $this->basePath = $this->option('base') ? $this->option('base') : Config::get('repository.base_path');

        $this->pathResolver = new PathResolver($this->modelName, $this->userPath, $this->basePath);

        config(['generator.base_path' => base_path($this->basePath)]);

        return $this->makeRepositoryPatternFiles();
    }

    public function makeRepositoryPatternFiles(): int
    {
        // Parent Classes
        $modelParent = Config::get('repository.model_parent');
        $repositoryParent = Config::get('repository.repository_parent');
        $controllerParent = Config::get('repository.controller_parent');
        $requestParent = Config::get('repository.request_parent');
        $resourceParent = Config::get('repository.resource_parent');
        $collectionParent = Config::get('repository.collection_parent');

        if($this->option(self::CONTROLLER_OPTION)) {
            $this->generate('Controller', $controllerParent);
        }

        if($this->option(self::MODEL_OPTION)) {
            $this->generate('Model', $modelParent);
        }

        if($this->option(self::REQUEST_OPTION)) {
            $this->generate('Request', $requestParent);
            $this->generate('Collection', $collectionParent);
        }

        if($this->option(self::REPOSITORY_OPTION)) {
            $this->generate('Repository', $repositoryParent);
        }

        if($this->option(self::RESOURCE_OPTION)) {
            $this->generate('Resource', $resourceParent);
        }

        if($this->option(self::POLICY_OPTION)) {
            $this->generate('Policy');
        }

        RepositoryFilesGenerated::dispatch($this->basePath, $this->userPath, $this->modelName);

        $this->dumpAutoload();

        return self::SUCCESS;
    }

    /**
     * @param string $type define which kind of files should be generated
     */
    protected function generate(string $type, string $parentClass = ''): bool
    {
        $outputPath = $this->pathResolver->outputPath($type);

        if (!$this->option('force') && $realpath = realpath($this->generator->absolutePath($outputPath))) {
            if ($this->option('no-override') || !$this->confirm('File '.$realpath.' is exist, do you want to overwrite it?')) {
                return false;
            }
        }

        $namespace = $this->pathResolver->typeNamespace($type);
        $lcModelName = Str::lower($this->modelName);
        $lcPluralModelName = Str::plural($lcModelName);
        $snackLcPluralModelName = Str::snake($this->modelName);

        $this->generator->stub($this->pathResolver->getStubPath($type))
            ->replace('{{parentClass}}', $parentClass)
            ->replace('{{modelName}}', $this->modelName)
            ->replace('{{lcModelName}}', $lcModelName)
            ->replace('{{lcPluralModelName}}', $lcPluralModelName)
            ->replace('{{snackLcPluralModelName}}', $snackLcPluralModelName)
            ->replace('{{namespace}}', $namespace)
            ->replace('{{RequestsNamespace}}', $this->pathResolver->typeNamespace('Request'))
            ->replace('{{RepositoriesNamespace}}', $this->pathResolver->typeNamespace('Repository'))
            ->replace('{{ResourcesNamespace}}', $this->pathResolver->typeNamespace('Resource'))
            ->replace('{{ModelNamespace}}', $this->pathResolver->typeNamespace('Model'))
            ->replace('{{PoliciesNamespace}}', $this->pathResolver->typeNamespace('Policy'))
            ->replace('{{ResourcesProperties}}', $this->resourceProperty())
            ->replace('{{RequestProperty}}', $this->requestProperty())
            ->replace('{{PolicyProperty}}', $this->policyProperty())
            ->output($outputPath);

        return true;
    }

    function resourceProperty(): string

    {
        $result = '';

        if($this->option(self::RESOURCE_OPTION)) {
            $result .= "\n\t".'public ?string $resourceClass = '. $this->modelName .'Resource::class;'."\n";
            $result .= "\n\t".'public ?string $collectionClass = '. $this->modelName .'Collection::class;'."\n";
        }

        return $result;
    }

    function requestProperty(): string

    {
        $result = '';

        if($this->option(self::RESOURCE_OPTION)) {
            $result .= "\n\t".'public string $requestClass = '. $this->modelName .'Request::class;'."\n";
        }

        return $result;
    }

    function policyProperty(): string

    {
        $result = '';

        if($this->option(self::RESOURCE_OPTION)) {
            $result .= "\n\t".'public ?string $policyClass = '. $this->modelName .'Policy::class;'."\n";
        }

        return $result;
    }

    private function dumpAutoload(): void
    {
        shell_exec('composer dump-autoload');
    }
}

mshamaseen / laravel-repositories

Pull Request — main (#8)

Generator::resourceProperty() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
