DatabaseRepository - Code Metrics - Inspection of "Feature/database-activator" - nWidart/laravel-modules - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#857)

by Lex

created 2019-10-17 21:58 UTC

DatabaseRepository A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	428
Duplicated Lines	9.58 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

Metric	Value
dl	41
loc	428
rs	9.2
c	0
b	0
f	0
wmc	40
lcom	1
cbo	7

30 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	9	9	1
A	all()	0	8	2
A	getCached()	0	6	1
A	scan()	0	6	1
A	toCollection()	0	4	1
A	getScanPaths()	0	4	1
A	has()	0	4	1
A	allEnabled()	0	4	1
A	allDisabled()	0	4	1
A	count()	0	4	1
A	getOrdered()	0	6	1
A	getByStatus()	0	6	1
A	find()	0	10	2
A	findRequirements()	12	12	2
A	findOrFail()	10	10	2
A	findByNameOrCreate()	0	6	1
A	getModulePath()	0	4	1
A	getFiles()	0	4	1
A	config()	0	4	1
A	getPath()	0	4	2
A	findByAlias()	0	10	3
A	boot()	0	6	2
A	register()	0	6	2
A	assetPath()	0	4	1
A	delete()	0	4	1
A	isEnabled()	0	4	1
A	isDisabled()	0	4	1
A	formatCached()	10	10	2
	createModule()	0	1	?
A	parse()	0	10	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like DatabaseRepository often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use DatabaseRepository, and based on these observations, apply Extract Interface, too.

<?php

namespace Nwidart\Modules;

use Countable;
use Illuminate\Cache\CacheManager;
use Illuminate\Container\Container;
use Illuminate\Contracts\Config\Repository as ConfigRepository;
use Illuminate\Contracts\Routing\UrlGenerator;
use Illuminate\Filesystem\Filesystem;
use Illuminate\Support\Traits\Macroable;
use Nwidart\Modules\Contracts\RepositoryInterface;
use Nwidart\Modules\Entities\Module as ModuleEntity;
use Nwidart\Modules\Exceptions\ModuleNotFoundException;

abstract class DatabaseRepository implements RepositoryInterface, Countable
{
    use Macroable;

    /**
     * Application instance.
     *
     * @var \Illuminate\Contracts\Foundation\Application
     */
    protected $app;

    /**
     * The module path.
     *
     * @var string|null
     */
    protected $path;

    /**
     * The scanned paths.
     *
     * @var array
     */
    protected $paths = [];

    /**
     * @var string
     */
    protected $stubPath;
    /**
     * @var UrlGenerator
     */
    private $url;
    /**
     * @var ConfigRepository
     */
    private $config;
    /**
     * @var Filesystem
     */
    private $files;
    /**
     * @var CacheManager
     */
    private $cache;

    /**
     * The constructor.
     *
     * @param Container   $app
     * @param string|null $path
     */
    public function __construct(Container $app, $path = null)
    {
        $this->app = $app;

        $this->path = $path;
        $this->url = $app['url'];
        $this->config = $app['config'];
        $this->files = $app['files'];
        $this->cache = $app['cache'];
    }

    /**
     * Get all modules.
     *
     * @return mixed
     */
    public function all()
    {
        if (!$this->config('cache.enabled')) {
            return $this->scan();
        }

        return $this->formatCached($this->getCached());
    }

    /**
     * Get cached modules.
     *
     * @return array
     */
    public function getCached()
    {
        return $this->cache->remember($this->config('cache.key'), $this->config('cache.lifetime'), function () {
            return $this->toCollection()->toArray();
        });
    }

    /**
     * Scan & get all available modules.
     *
     * @return array
     */
    public function scan()
    {
        $entities = ModuleEntity::all();

        return $this->parse($entities);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    /**
     * Get modules as modules collection instance.
     *
     * @return \Nwidart\Modules\Collection
     */
    public function toCollection()
    {
        return new Collection($this->scan());
    }

    /**
     * Get scanned paths.
     *
     * @return array
     */
    public function getScanPaths()
    {
        // TODO: Unused thus remove
    }

    /**
     * Determine whether the given module exist.
     *
     * @param $name
     *
     * @return bool
     */
    public function has($name) : bool
    {
        return array_key_exists($name, $this->all());
    }

    /**
     * Get list of enabled modules.
     *
     * @return mixed
     */
    public function allEnabled()
    {
        return $this->getByStatus(true);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Get list of disabled modules.
     *
     * @return mixed
     */
    public function allDisabled()
    {
        return $this->getByStatus(false);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Get count from all modules.
     *
     * @return int
     */
    public function count()
    {
        return count($this->all());
    }

    /**
     * Get all ordered modules.
     *
     * @param string $direction
     * @return mixed
     */
    public function getOrdered($direction = 'asc')
    {
        $entities = ModuleEntity::orderBy('sequence', $direction)->get();

        return $this->parse($entities);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    /**
     * Get modules by the given status.
     *
     * @param int $status
     *
     * @return mixed
     */
    public function getByStatus($status)
    {
        $entities = ModuleEntity::where('is_active', $status)->get();

        return $this->parse($entities);
    }

    /**
     * Find a specific module.
     *
     * @param $name
     * @return Module|null
     */
    public function find(string $name)
    {
        $entity = ModuleEntity::findByName($name);

        if (!$entity) {
            return null;
        }

        return $this->createModule($this->app, $entity->name, $entity->path);
    }

    /**
     * Find all modules that are required by a module. If the module cannot be found, throw an exception.
     *
     * @param $name
     * @return array
     * @throws ModuleNotFoundException
     */
    public function findRequirements($name): array
    {
        $requirements = [];

        $module = $this->findOrFail($name);

        foreach ($module->getRequires() as $requirementName) {
            $requirements[] = $this->findByAlias($requirementName);
        }

        return $requirements;
    }

    /**
     * Find a specific module. If there return that, otherwise throw exception.
     *
     * @param $name
     *
     * @return mixed
     * @throws \Nwidart\Modules\Exceptions\ModuleNotFoundException
     */
    public function findOrFail(string $name)
    {
        $module = $this->find($name);

        if ($module !== null) {
            return $module;
        }

        throw new ModuleNotFoundException("Module [{$name}] does not exist!");
    }

    /**
     * Find a specific module. If there return that, otherwise create it.
     *
     * @param $name
     *
     * @return Module
     */
    public function findByNameOrCreate(string $name)
    {
        $module = $this->find($name);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        return $this->createModule($this->app, $name, $this->getModulePath($name));
    }

    /**
     * @param $name
     * @return string
     */
    public function getModulePath($name)
    {
        return $this->getPath() . '/' . $name;
    }

    /**
     * @return \Illuminate\Filesystem\Filesystem
     */
    public function getFiles()
    {
        return $this->files;
    }

    /**
     * Get a specific config data from a configuration file.
     *
     * @param string      $key
     *
     * @param string|null $default
     * @return mixed
     */
    public function config(string $key, $default = null)
    {
        return $this->config->get('modules.' . $key, $default);
    }

    /**
     * Get a module path.
     *
     * @return string
     */
    public function getPath(): string
    {
        return $this->path ?: $this->config('paths.modules', base_path($this->config->get('paths.modules')));
    }

    /**
     * Find a specific module by its alias.
     *
     * @param string $alias
     * @return Module|void
     */
    public function findByAlias(string $alias)
    {
        foreach ($this->all() as $module) {
            if ($module->getAlias() === $alias) {
                return $module;
            }
        }

        return;
    }

    /**
     * Boot the modules.
     */
    public function boot(): void
    {
        foreach ($this->getOrdered() as $module) {
            $module->boot();
        }
    }

    /**
     * Register the modules.
     */
    public function register(): void
    {
        foreach ($this->getOrdered() as $module) {
            $module->register();
        }
    }

    /**
     * Get asset path for a specific module.
     *
     * @param string $module
     * @return string
     */
    public function assetPath(string $module): string
    {
        return $this->config('paths.assets') . '/' . $module;
    }

    /**
     * Delete a specific module.
     *
     * @param string $module
     * @return bool
     * @throws \Nwidart\Modules\Exceptions\ModuleNotFoundException
     */
    public function delete(string $module): bool
    {
        return $this->findOrFail($module)->delete();
    }

    /**
     * Determine whether the given module is activated.
     *
     * @param string $name
     * @return bool
     * @throws ModuleNotFoundException
     */
    public function isEnabled(string $name): bool
    {
        return $this->findOrFail($name)->isEnabled();
    }

    /**
     * Determine whether the given module is not activated.
     *
     * @param string $name
     * @return bool
     * @throws ModuleNotFoundException
     */
    public function isDisabled(string $name): bool
    {
        return !$this->isEnabled($name);
    }

    /**
     * Format the cached data as array of modules.
     *
     * @param array $cached
     *
     * @return array
     */
    protected function formatCached($cached)
    {
        $modules = [];

        foreach ($cached as $name => $module) {
            $modules[$name] = $this->createModule($this->app, $name, $this->getModulePath($name));
        }

        return $modules;
    }

    /**
     * Creates a new Module instance
     *
     * @param Container $app
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param string $args
     * @param string $path
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return \Nwidart\Modules\Module
     */
    abstract protected function createModule(...$args);

    /**
     * Parse from ModuleEntityCollection to Module array
     *
     * @param \Illuminate\Database\Eloquent\Collection $entities
     * @return array
     */
    protected function parse(\Illuminate\Database\Eloquent\Collection $entities)
    {
        $modules = [];

        foreach ($entities as $entity) {
            $modules[$entity->name] = $this->createModule($this->app, $entity->name, $entity->path);
        }

        return $modules;
    }
}


1		<?php
2
3		namespace Nwidart\Modules;
4
5		use Countable;
6		use Illuminate\Cache\CacheManager;
7		use Illuminate\Container\Container;
8		use Illuminate\Contracts\Config\Repository as ConfigRepository;
9		use Illuminate\Contracts\Routing\UrlGenerator;
10		use Illuminate\Filesystem\Filesystem;
11		use Illuminate\Support\Traits\Macroable;
12		use Nwidart\Modules\Contracts\RepositoryInterface;
13		use Nwidart\Modules\Entities\Module as ModuleEntity;
14		use Nwidart\Modules\Exceptions\ModuleNotFoundException;
15
16		abstract class DatabaseRepository implements RepositoryInterface, Countable
17		{
18		use Macroable;
19
20		/**
21		* Application instance.
22		*
23		* @var \Illuminate\Contracts\Foundation\Application
24		*/
25		protected $app;
26
27		/**
28		* The module path.
29		*
30		* @var string\|null
31		*/
32		protected $path;
33
34		/**
35		* The scanned paths.
36		*
37		* @var array
38		*/
39		protected $paths = [];
40
41		/**
42		* @var string
43		*/
44		protected $stubPath;
45		/**
46		* @var UrlGenerator
47		*/
48		private $url;
49		/**
50		* @var ConfigRepository
51		*/
52		private $config;
53		/**
54		* @var Filesystem
55		*/
56		private $files;
57		/**
58		* @var CacheManager
59		*/
60		private $cache;
61
62		/**
63		* The constructor.
64		*
65		* @param Container $app
66		* @param string\|null $path
67		*/
68	View Code Duplication	public function __construct(Container $app, $path = null)
69		{
70		$this->app = $app;
		0 ignored issues – show Documentation Bug introduced 2019-10-17 22:11 UTC by Report Bug Copy Issue Report It seems like `$app` of type `object<Illuminate\Container\Container>` is incompatible with the declared type `object<Illuminate\Contra...Foundation\Application>` of property `$app`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
71		$this->path = $path;
72		$this->url = $app['url'];
73		$this->config = $app['config'];
74		$this->files = $app['files'];
75		$this->cache = $app['cache'];
76		}
77
78		/**
79		* Get all modules.
80		*
81		* @return mixed
82		*/
83		public function all()
84		{
85		if (!$this->config('cache.enabled')) {
86		return $this->scan();
87		}
88
89		return $this->formatCached($this->getCached());
90		}
91
92		/**
93		* Get cached modules.
94		*
95		* @return array
96		*/
97		public function getCached()
98		{
99		return $this->cache->remember($this->config('cache.key'), $this->config('cache.lifetime'), function () {
100		return $this->toCollection()->toArray();
101		});
102		}
103
104		/**
105		* Scan & get all available modules.
106		*
107		* @return array
108		*/
109		public function scan()
110		{
111		$entities = ModuleEntity::all();
112
113		return $this->parse($entities);
		0 ignored issues – show Bug introduced 2019-10-17 22:11 UTC by Report Bug Copy Issue Report It seems like `$entities` defined by `\Nwidart\Modules\Entities\Module::all()` on line `111` can also be of type `array<integer,object<Ill...base\Eloquent\Builder>>`; however, `Nwidart\Modules\DatabaseRepository::parse()` does only seem to accept `object<Illuminate\Database\Eloquent\Collection>`, 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...
114		}
115
116		/**
117		* Get modules as modules collection instance.
118		*
119		* @return \Nwidart\Modules\Collection
120		*/
121		public function toCollection()
122		{
123		return new Collection($this->scan());
124		}
125
126		/**
127		* Get scanned paths.
128		*
129		* @return array
130		*/
131		public function getScanPaths()
132		{
133		// TODO: Unused thus remove
134		}
135
136		/**
137		* Determine whether the given module exist.
138		*
139		* @param $name
140		*
141		* @return bool
142		*/
143		public function has($name) : bool
144		{
145		return array_key_exists($name, $this->all());
146		}
147
148		/**
149		* Get list of enabled modules.
150		*
151		* @return mixed
152		*/
153		public function allEnabled()
154		{
155		return $this->getByStatus(true);
		0 ignored issues – show Documentation introduced 2019-08-19 15:00 UTC by Report Bug Copy Issue Report `true` is of type `boolean`, but the function expects a `integer`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
156		}
157
158		/**
159		* Get list of disabled modules.
160		*
161		* @return mixed
162		*/
163		public function allDisabled()
164		{
165		return $this->getByStatus(false);
		0 ignored issues – show Documentation introduced 2019-08-19 15:00 UTC by Report Bug Copy Issue Report `false` is of type `boolean`, but the function expects a `integer`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
166		}
167
168		/**
169		* Get count from all modules.
170		*
171		* @return int
172		*/
173		public function count()
174		{
175		return count($this->all());
176		}
177
178		/**
179		* Get all ordered modules.
180		*
181		* @param string $direction
182		* @return mixed
183		*/
184		public function getOrdered($direction = 'asc')
185		{
186		$entities = ModuleEntity::orderBy('sequence', $direction)->get();
187
188		return $this->parse($entities);
		0 ignored issues – show Bug introduced 2019-10-17 22:11 UTC by Report Bug Copy Issue Report It seems like `$entities` defined by `\Nwidart\Modules\Entitie...ce', $direction)->get()` on line `186` can also be of type `array<integer,object<Ill...base\Eloquent\Builder>>`; however, `Nwidart\Modules\DatabaseRepository::parse()` does only seem to accept `object<Illuminate\Database\Eloquent\Collection>`, 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...
189		}
190
191		/**
192		* Get modules by the given status.
193		*
194		* @param int $status
195		*
196		* @return mixed
197		*/
198		public function getByStatus($status)
199		{
200		$entities = ModuleEntity::where('is_active', $status)->get();
201
202		return $this->parse($entities);
203		}
204
205		/**
206		* Find a specific module.
207		*
208		* @param $name
209		* @return Module\|null
210		*/
211		public function find(string $name)
212		{
213		$entity = ModuleEntity::findByName($name);
214
215		if (!$entity) {
216		return null;
217		}
218
219		return $this->createModule($this->app, $entity->name, $entity->path);
220		}
221
222		/**
223		* Find all modules that are required by a module. If the module cannot be found, throw an exception.
224		*
225		* @param $name
226		* @return array
227		* @throws ModuleNotFoundException
228		*/
229	View Code Duplication	public function findRequirements($name): array
230		{
231		$requirements = [];
232
233		$module = $this->findOrFail($name);
234
235		foreach ($module->getRequires() as $requirementName) {
236		$requirements[] = $this->findByAlias($requirementName);
237		}
238
239		return $requirements;
240		}
241
242		/**
243		* Find a specific module. If there return that, otherwise throw exception.
244		*
245		* @param $name
246		*
247		* @return mixed
248		* @throws \Nwidart\Modules\Exceptions\ModuleNotFoundException
249		*/
250	View Code Duplication	public function findOrFail(string $name)
251		{
252		$module = $this->find($name);
253
254		if ($module !== null) {
255		return $module;
256		}
257
258		throw new ModuleNotFoundException("Module [{$name}] does not exist!");
259		}
260
261		/**
262		* Find a specific module. If there return that, otherwise create it.
263		*
264		* @param $name
265		*
266		* @return Module
267		*/
268		public function findByNameOrCreate(string $name)
269		{
270		$module = $this->find($name);
		0 ignored issues – show Unused Code introduced 2019-10-17 22:11 UTC by Report Bug Copy Issue Report `$module` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
271
272		return $this->createModule($this->app, $name, $this->getModulePath($name));
273		}
274
275		/**
276		* @param $name
277		* @return string
278		*/
279		public function getModulePath($name)
280		{
281		return $this->getPath() . '/' . $name;
282		}
283
284		/**
285		* @return \Illuminate\Filesystem\Filesystem
286		*/
287		public function getFiles()
288		{
289		return $this->files;
290		}
291
292		/**
293		* Get a specific config data from a configuration file.
294		*
295		* @param string $key
296		*
297		* @param string\|null $default
298		* @return mixed
299		*/
300		public function config(string $key, $default = null)
301		{
302		return $this->config->get('modules.' . $key, $default);
303		}
304
305		/**
306		* Get a module path.
307		*
308		* @return string
309		*/
310		public function getPath(): string
311		{
312		return $this->path ?: $this->config('paths.modules', base_path($this->config->get('paths.modules')));
313		}
314
315		/**
316		* Find a specific module by its alias.
317		*
318		* @param string $alias
319		* @return Module\|void
320		*/
321		public function findByAlias(string $alias)
322		{
323		foreach ($this->all() as $module) {
324		if ($module->getAlias() === $alias) {
325		return $module;
326		}
327		}
328
329		return;
330		}
331
332		/**
333		* Boot the modules.
334		*/
335		public function boot(): void
336		{
337		foreach ($this->getOrdered() as $module) {
338		$module->boot();
339		}
340		}
341
342		/**
343		* Register the modules.
344		*/
345		public function register(): void
346		{
347		foreach ($this->getOrdered() as $module) {
348		$module->register();
349		}
350		}
351
352		/**
353		* Get asset path for a specific module.
354		*
355		* @param string $module
356		* @return string
357		*/
358		public function assetPath(string $module): string
359		{
360		return $this->config('paths.assets') . '/' . $module;
361		}
362
363		/**
364		* Delete a specific module.
365		*
366		* @param string $module
367		* @return bool
368		* @throws \Nwidart\Modules\Exceptions\ModuleNotFoundException
369		*/
370		public function delete(string $module): bool
371		{
372		return $this->findOrFail($module)->delete();
373		}
374
375		/**
376		* Determine whether the given module is activated.
377		*
378		* @param string $name
379		* @return bool
380		* @throws ModuleNotFoundException
381		*/
382		public function isEnabled(string $name): bool
383		{
384		return $this->findOrFail($name)->isEnabled();
385		}
386
387		/**
388		* Determine whether the given module is not activated.
389		*
390		* @param string $name
391		* @return bool
392		* @throws ModuleNotFoundException
393		*/
394		public function isDisabled(string $name): bool
395		{
396		return !$this->isEnabled($name);
397		}
398
399		/**
400		* Format the cached data as array of modules.
401		*
402		* @param array $cached
403		*
404		* @return array
405		*/
406	View Code Duplication	protected function formatCached($cached)
407		{
408		$modules = [];
409
410		foreach ($cached as $name => $module) {
411		$modules[$name] = $this->createModule($this->app, $name, $this->getModulePath($name));
412		}
413
414		return $modules;
415		}
416
417		/**
418		* Creates a new Module instance
419		*
420		* @param Container $app
		0 ignored issues – show Bug introduced 2019-10-17 22:11 UTC by Report Bug Copy Issue Report There is no parameter named `$app`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
421		* @param string $args
422		* @param string $path
		0 ignored issues – show Bug introduced 2019-10-17 22:11 UTC by Report Bug Copy Issue Report There is no parameter named `$path`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
423		* @return \Nwidart\Modules\Module
424		*/
425		abstract protected function createModule(...$args);
426
427		/**
428		* Parse from ModuleEntityCollection to Module array
429		*
430		* @param \Illuminate\Database\Eloquent\Collection $entities
431		* @return array
432		*/
433		protected function parse(\Illuminate\Database\Eloquent\Collection $entities)
434		{
435		$modules = [];
436
437		foreach ($entities as $entity) {
438		$modules[$entity->name] = $this->createModule($this->app, $entity->name, $entity->path);
439		}
440
441		return $modules;
442		}
443		}
444

nWidart / laravel-modules