Anomaly\Streams\Platform\Database\Seeder\Console\SeederMakeCommand

Complexity

Total Complexity

14

Size/Duplication

Total Lines	211
Duplicated Lines	4.74 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	fire()	0	66	6
A	getAddonNamespace()	0	11	2
A	getStreams()	0	9	1
A	getAllChoice()	0	4	1
A	makeQuestion()	0	14	1
A	getOptions()	10	10	1
A	getArguments()	0	6	1

<?php namespace Anomaly\Streams\Platform\Database\Seeder\Console;

use \Illuminate\Support\Composer;
use \Illuminate\Filesystem\Filesystem;
use Illuminate\Foundation\Bus\DispatchesJobs;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Input\InputArgument;
use Anomaly\Streams\Platform\Addon\Command\GetAddon;
use Anomaly\Streams\Platform\Stream\StreamCollection;
use Anomaly\Streams\Platform\Stream\Command\GetStreams;
use Anomaly\Streams\Platform\Addon\Console\Command\WriteAddonSeeder;
use Anomaly\Streams\Platform\Stream\Console\Command\WriteEntitySeeder;

/**
 * Class SeederMakeCommand
 */
class SeederMakeCommand extends \Illuminate\Console\Command
{
    use DispatchesJobs;

    /**
     * The console command name.
     *
     * @var string
     */
    protected $name = 'make:seeder';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Create a new seeder class for addon';

    /**
     * All streams string value
     *
     * @var string
     */
    protected $allChoice = 'All streams';

    /**
     * The Composer instance.
     *
     * @var \Illuminate\Support\Composer
     */
    protected $composer;

    /**
     * Create a new command instance.
     *
     * @param  \Illuminate\Filesystem\Filesystem $files
     * @param  \Illuminate\Support\Composer      $composer
     * @return void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct(Filesystem $files, Composer $composer)
    {
        parent::__construct($files);

The call to Command::__construct() has too many arguments starting with $files.

        $this->composer = $composer;
    }

    /**
     * Execute the console command.
     *
     * @return void
     */
    public function fire()
    {
        /* @var Addon $addon */
        if (!$addon = $this->dispatch(new GetAddon($this->getAddonNamespace())))

It seems like $this->getAddonNamespace() targeting Anomaly\Streams\Platform\Database\Seeder\Console\SeederMakeCommand::getAddonNamespace() can also be of type array; however, Anomaly\Streams\Platform\Addon\Command\GetAddon::__construct() does only seem to accept string, maybe add an additional type check?

        {
            throw new \Exception('Addon could not be found.');
        }

        $path   = $addon->getPath();
        $type   = $addon->getType();
        $slug   = $addon->getSlug();
        $vendor = $addon->getVendor();

        if ($type != 'module' && $type != 'extension')
        {
            throw new \Exception('Only {module} and {extension} addon types are allowed!!!');
        }

        if (!$this->confirm('Next action will OVERWRITE existing seeders which you would set! Do you agree?'))
        {
            $this->error('Exiting...');

            exit;

The method fire() contains an exit expression.

        }
        
        /* @var StreamCollection $streams */
        $streams = $this->getStreams($slug);

        $answers = $this->makeQuestion($streams);

        if (array_search($this->getAllChoice(), $answers) === false)
        {
            $streams = $streams->filter(
                function ($stream) use ($answers)
                {
                    return array_search(ucfirst($stream->getSlug()), $answers) !== false;
                }
            );
        }

        $streams->each(
            function ($stream) use ($addon)
            {
                $slug = $stream->getSlug();

                $this->dispatch(new WriteEntitySeeder(
                    $addon,
                    $slug,
                    $stream->getNamespace()
                ));

                $singular = ucfirst(str_singular($slug));
                $path = "{$addon->getPath()}/src/{$singular}/{$singular}Seeder.php";

                $this->comment("Seeder for {$slug} created successfully.");
                $this->line("Path: {$path}");
                $this->line('');
            }
        );

        $this->dispatch(new WriteAddonSeeder($path, $type, $slug, $vendor, $streams));

        $this->composer->dumpAutoloads();

        $this->info('Seeders created successfully.');
    }

    /**
     * Gets the addon's stream namespace.
     *
     * @throws \Exception
     * @return string       The stream namespace.
     */
    public function getAddonNamespace()
    {
        $namespace = $this->argument('namespace');

        if (!str_is('*.*.*', $namespace))

It seems like $namespace defined by $this->argument('namespace') on line 143 can also be of type array; however, str_is() does only seem to accept string, maybe add an additional type check?

        {
            throw new \Exception('The namespace should be snake case and formatted like: {vendor}.{type}.{slug}');
        }

        return $namespace;
    }

    /**
     * Gets the root streams of addon.
     *
     * @param  string             $slug The addon slug
     * @return StreamCollection
     */
    public function getStreams($slug)
    {
        return $this->dispatch(new GetStreams($slug))->filter(
            function ($stream)
            {
                return !str_contains($stream->getSlug(), '_');
            }
        );
    }

    /**
     * Get `all` value.
     *
     * @return string All value.
     */
    public function getAllChoice()
    {
        return $this->allChoice;
    }

    /**
     * Makes a question about streams to make seeders for.
     *
     * @param  StreamCollection $streams  The streams
     * @return array            Answers
     */
    public function makeQuestion(StreamCollection $streams)
    {
        $choices = $streams->map(
            function ($stream)
            {
                return ucfirst($stream->getSlug());
            }
        )->prepend($this->getAllChoice())->toArray();

        return $this->choice(
            'Please choose the addon\'s streams to create seeders for (common separated if multiple)',
            $choices, 0, null, true
        );
    }

    /**
     * Get the options.
     *
     * @return array
     */
    protected function getOptions()

This method seems to be duplicated in your project.

    {
        return array_merge(
            parent::getOptions(),
            [
                ['stream', null, InputOption::VALUE_OPTIONAL, 'The stream slug.'],
                ['shared', null, InputOption::VALUE_NONE, 'Indicates if the addon should be created in shared addons.'],
            ]
        );
    }

    /**
     * Get the console command arguments.
     *
     * @return array
     */
    protected function getArguments()
    {
        return [
            ['namespace', InputArgument::REQUIRED, 'The namespace of the addon'],
        ];
    }
}