Spatie\ModelCleanup\CleanUpModelsCommand

Complexity

Total Complexity

9

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	handle()	0	10	1
A	getModelsThatShouldBeCleanedUp()	0	12	1
A	cleanUp()	0	13	2
A	getAllModelsFromEachDirectory()	0	8	1
A	getClassNamesInDirectory()	0	8	1
A	getFullyQualifiedClassNameFromFile()	0	23	1
A	fireEvent()	0	5	1

<?php

namespace Spatie\ModelCleanup;

use Illuminate\Console\Command;
use Illuminate\Support\Collection;
use Illuminate\Filesystem\Filesystem;
use PhpParser\Node\Stmt\Class_;
use PhpParser\ParserFactory;
use ClassPreloader\Parser\NodeTraverser;
use PhpParser\NodeVisitor\NameResolver;

class CleanUpModelsCommand extends Command
{
    /**
     * The console command name.
     *
     * @var string
     */
    protected $signature = 'clean:models';
    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Clean up models.';

    protected $filesystem;

    public function __construct(Filesystem $filesystem)
    {
        parent::__construct();

        $this->filesystem = $filesystem;
    }

    public function handle()
    {
        $this->comment('Cleaning models...');

        $cleanableModels = $this->getModelsThatShouldBeCleanedUp();

        $this->cleanUp($cleanableModels);

        $this->comment('All done!');
    }

    protected function getModelsThatShouldBeCleanedUp() : Collection
    {
        $directories = config('laravel-model-cleanup.directories');

        $modelsFromDirectories = $this->getAllModelsFromEachDirectory($directories);

        return $modelsFromDirectories
            ->merge(collect(config('laravel-model-cleanup.models')))
            ->filter(function ($modelClass) {
                return in_array(GetsCleanedUp::class, class_implements($modelClass));
            });
    }

    protected function cleanUp(Collection $cleanableModels)
    {
        $cleanableModels->each(function (string $class) {

            $numberOfDeletedRecords = $class::cleanUp($class::query())->delete();

            if($numberOfDeletedRecords > 0)
                $this->fireEvent($class, $numberOfDeletedRecords);

            $this->info("Deleted {$numberOfDeletedRecords} record(s) from {$class}.");

        });
    }

    protected function getAllModelsFromEachDirectory(array $directories) : Collection
    {
        return collect($directories)
            ->map(function ($directory) {
                return $this->getClassNamesInDirectory($directory)->all();
            })
            ->flatten();
    }

    protected function getClassNamesInDirectory(string $directory) : Collection
    {
        return collect($this->filesystem->files($directory))->map(function ($path) {

            return $this->getFullyQualifiedClassNameFromFile($path);

        });
    }

    protected function getFullyQualifiedClassNameFromFile(string $path) : string
    {
        $parser = (new ParserFactory())->create(ParserFactory::PREFER_PHP7);

        $traverser = new NodeTraverser();

        $traverser->addVisitor(new NameResolver());

        $code = file_get_contents($path);

        $statements = $parser->parse($code);

        $statements = $traverser->traverse($statements);

It seems like $statements can also be of type null; however, PhpParser\NodeTraverser::traverse() does only seem to accept array<integer,object<PhpParser\Node>>, maybe add an additional type check?

        return collect($statements[0]->stmts)

Accessing stmts on the interface PhpParser\Node suggest that you code against a concrete implementation. How about adding an instanceof check?

            ->filter(function ($statement) {
                return $statement instanceof Class_;
            })
            ->map(function (Class_ $statement) {
                return $statement->namespacedName->toString();

The property namespacedName does not seem to exist in PhpParser\Node\Stmt\Class_.

            })
            ->first();
    }

    protected function fireEvent(string $modelName, int $numberOfDeletedRecords){

        event(new ModelCleanedEvent($modelName, $numberOfDeletedRecords));

    }
}