SeederMakeCommand::getStreams() - Code Metrics - Inspection of "Added `make:seeder` artisan command" - anomalylabs/streams-platform - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#340)

unknown

created 2017-01-01 19:59 UTC

SeederMakeCommand::getStreams() A

↳ Parent: SeederMakeCommand

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	1
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0

<?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\Command\GetStreams;
use Anomaly\Streams\Platform\Addon\Console\Command\WriteAddonSeeder;
use Anomaly\Streams\Platform\Stream\Console\Command\WriteEntitySeeder;

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';

    /**
     * The type of class being generated.
     *
     * @var string
     */
    protected $type = 'Seeder';

    /**
     * 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

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


        $this->composer = $composer;
    }

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

        {
            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!!!');
        }

        /* @var StreamCollection $streams */
        $streams = $this->getStreams($slug)->each(
            function ($stream) use ($addon)
            {
                $this->dispatch(new WriteEntitySeeder(
                    $addon,
                    $stream->getSlug(),
                    $stream->getNamespace()
                ));
            }
        );

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

        $this->composer->dumpAutoloads();

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

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

    {
        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'],
        ];
    }

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

        if (!str_is('*.*.*', $namespace))
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        {
            throw new \Exception('The namespace should be snake case and formatted like: {vendor}.{type}.{slug}');
        }

        return $namespace;
    }

    /**
     * Gets the streams.
     *
     * @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(), '_');
            }
        );
    }
}


1		<?php namespace Anomaly\Streams\Platform\Database\Seeder\Console;
2
3		use \Illuminate\Support\Composer;
4		use \Illuminate\Filesystem\Filesystem;
5		use Illuminate\Foundation\Bus\DispatchesJobs;
6		use Symfony\Component\Console\Input\InputOption;
7		use Symfony\Component\Console\Input\InputArgument;
8		use Anomaly\Streams\Platform\Addon\Command\GetAddon;
9		use Anomaly\Streams\Platform\Stream\Command\GetStreams;
10		use Anomaly\Streams\Platform\Addon\Console\Command\WriteAddonSeeder;
11		use Anomaly\Streams\Platform\Stream\Console\Command\WriteEntitySeeder;
12
13		class SeederMakeCommand extends \Illuminate\Console\Command
14		{
15		use DispatchesJobs;
16
17		/**
18		* The console command name.
19		*
20		* @var string
21		*/
22		protected $name = 'make:seeder';
23
24		/**
25		* The console command description.
26		*
27		* @var string
28		*/
29		protected $description = 'Create a new seeder class for addon';
30
31		/**
32		* The type of class being generated.
33		*
34		* @var string
35		*/
36		protected $type = 'Seeder';
37
38		/**
39		* The Composer instance.
40		*
41		* @var \Illuminate\Support\Composer
42		*/
43		protected $composer;
44
45		/**
46		* Create a new command instance.
47		*
48		* @param \Illuminate\Filesystem\Filesystem $files
49		* @param \Illuminate\Support\Composer $composer
50		* @return void
		0 ignored issues – show Comprehensibility Best Practice introduced 2017-01-01 20:04 UTC by Report Bug Copy Issue Report Adding a `@return` annotation to constructors is generally not recommended as a constructor does not have a meaningful return value. Adding a `@return` annotation to a constructor is not recommended, since a constructor does not have a meaningful return value. Please refer to the PHP core documentation on constructors. Loading history...
51		*/
52		public function __construct(Filesystem $files, Composer $composer)
53		{
54		parent::__construct($files);
		0 ignored issues – show Unused Code introduced 2017-01-01 20:04 UTC by Report Bug Copy Issue Report The call to `Command::__construct()` has too many arguments starting with `$files`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
55
56		$this->composer = $composer;
57		}
58
59		/**
60		* Execute the console command.
61		*
62		* @return void
63		*/
64		public function fire()
65		{
66		/* @var Addon $addon */
67		if (!$addon = $this->dispatch(new GetAddon($this->getAddonNamespace())))
		0 ignored issues – show Bug introduced 2017-01-01 20:04 UTC by Report Bug Copy Issue Report It seems like `$this->getAddonNamespace()` targeting `Anomaly\Streams\Platform...nd::getAddonNamespace()` can also be of type `array`; however, `Anomaly\Streams\Platform...GetAddon::__construct()` does only seem to accept `string`, maybe add an additional type check? This check looks at variables that are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
68		{
69		throw new \Exception('Addon could not be found.');
70		}
71
72		$path = $addon->getPath();
73		$type = $addon->getType();
74		$slug = $addon->getSlug();
75		$vendor = $addon->getVendor();
76
77		if ($type != 'module' && $type != 'extension')
78		{
79		throw new \Exception('Only {module} and {extension} addon types are allowed!!!');
80		}
81
82		/* @var StreamCollection $streams */
83		$streams = $this->getStreams($slug)->each(
84		function ($stream) use ($addon)
85		{
86		$this->dispatch(new WriteEntitySeeder(
87		$addon,
88		$stream->getSlug(),
89		$stream->getNamespace()
90		));
91		}
92		);
93
94		$this->dispatch(new WriteAddonSeeder($path, $type, $slug, $vendor, $streams));
95
96		$this->composer->dumpAutoloads();
97
98		$this->info($this->type.' created successfully.');
99		}
100
101		/**
102		* Get the options.
103		*
104		* @return array
105		*/
106	View Code Duplication	protected function getOptions()
		0 ignored issues – show Duplication introduced 2017-01-01 20:05 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
107		{
108		return array_merge(
109		parent::getOptions(),
110		[
111		['stream', null, InputOption::VALUE_OPTIONAL, 'The stream slug.'],
112		['shared', null, InputOption::VALUE_NONE, 'Indicates if the addon should be created in shared addons.'],
113		]
114		);
115		}
116
117		/**
118		* Get the console command arguments.
119		*
120		* @return array
121		*/
122		protected function getArguments()
123		{
124		return [
125		['namespace', InputArgument::REQUIRED, 'The namespace of the addon'],
126		];
127		}
128
129		/**
130		* Gets the stream namespace.
131		*
132		* @throws \Exception
133		* @return string The stream namespace.
134		*/
135		public function getAddonNamespace()
136		{
137		$namespace = $this->argument('namespace');
138
139		if (!str_is('..*', $namespace))
		0 ignored issues – show Bug introduced 2017-01-01 20:04 UTC by Report Bug Copy Issue Report It seems like `$namespace` defined by `$this->argument('namespace')` on line `137` can also be of type `array`; however, `str_is()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
140		{
141		throw new \Exception('The namespace should be snake case and formatted like: {vendor}.{type}.{slug}');
142		}
143
144		return $namespace;
145		}
146
147		/**
148		* Gets the streams.
149		*
150		* @param string $slug The addon slug
151		* @return StreamCollection
152		*/
153		public function getStreams($slug)
154		{
155		return $this->dispatch(new GetStreams($slug))->filter(
156		function ($stream)
157		{
158		return !str_contains($stream->getSlug(), '_');
159		}
160		);
161		}
162		}
163

anomalylabs / streams-platform

Pull Request — master (#340)

SeederMakeCommand::getStreams() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like