This project does not seem to handle request data directly as such no vulnerable execution paths were found.
include
, or for example
via PHP's auto-loading mechanism.
These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more
1 | <?php |
||
2 | |||
3 | namespace LaravelPlus\Extension\Providers; |
||
4 | |||
5 | use Illuminate\Foundation\Providers\ArtisanServiceProvider as ServiceProvider; |
||
6 | use Illuminate\Console\Scheduling\Schedule; |
||
7 | use Illuminate\Console\Scheduling\ScheduleRunCommand; |
||
8 | use Illuminate\Console\Scheduling\ScheduleFinishCommand; |
||
9 | use LaravelPlus\Extension\Commands; |
||
10 | use LaravelPlus\Extension\Addons; |
||
11 | use LaravelPlus\Extension\Database; |
||
12 | use LaravelPlus\Extension\Generators; |
||
13 | |||
14 | class ArtisanServiceProvider extends ServiceProvider |
||
15 | { |
||
16 | /** |
||
17 | * Indicates if loading of the provider is deferred. |
||
18 | * |
||
19 | * @var bool |
||
20 | */ |
||
21 | protected $defer = true; |
||
22 | |||
23 | /** |
||
24 | * The commands to be registered. |
||
25 | * |
||
26 | * @var array |
||
27 | */ |
||
28 | protected $commands = [ |
||
29 | 'CacheClear' => 'command.cache.clear', |
||
30 | 'CacheForget' => 'command.cache.forget', |
||
31 | 'ClearCompiled' => 'command.clear-compiled', |
||
32 | 'ClearResets' => 'command.auth.resets.clear', |
||
33 | 'ConfigCache' => 'command.config.cache', |
||
34 | 'ConfigClear' => 'command.config.clear', |
||
35 | 'Down' => 'command.down', |
||
36 | 'Environment' => 'command.environment', |
||
37 | 'KeyGenerate' => 'command.key.generate', |
||
38 | // 'Migrate' => 'command.migrate', |
||
39 | // 'MigrateFresh' => 'command.migrate.fresh', |
||
40 | // 'MigrateInstall' => 'command.migrate.install', |
||
41 | // 'MigrateRefresh' => 'command.migrate.refresh', |
||
42 | // 'MigrateReset' => 'command.migrate.reset', |
||
43 | // 'MigrateRollback' => 'command.migrate.rollback', |
||
44 | // 'MigrateStatus' => 'command.migrate.status', |
||
45 | 'Optimize' => 'command.optimize', |
||
46 | 'PackageDiscover' => 'command.package.discover', |
||
47 | 'QueueFailed' => 'command.queue.failed', |
||
48 | 'QueueFlush' => 'command.queue.flush', |
||
49 | 'QueueForget' => 'command.queue.forget', |
||
50 | 'QueueListen' => 'command.queue.listen', |
||
51 | 'QueueRestart' => 'command.queue.restart', |
||
52 | 'QueueRetry' => 'command.queue.retry', |
||
53 | 'QueueWork' => 'command.queue.work', |
||
54 | 'RouteCache' => 'command.route.cache', |
||
55 | 'RouteClear' => 'command.route.clear', |
||
56 | 'RouteList' => 'command.route.list', |
||
57 | // 'Seed' => 'command.seed', |
||
58 | 'ScheduleFinish' => ScheduleFinishCommand::class, |
||
59 | 'ScheduleRun' => ScheduleRunCommand::class, |
||
60 | 'StorageLink' => 'command.storage.link', |
||
61 | 'Up' => 'command.up', |
||
62 | 'ViewClear' => 'command.view.clear', |
||
63 | |||
64 | 'Route' => 'command+.route', |
||
65 | 'Tail' => 'command+.tail', |
||
66 | 'AddonList' => 'command+.addon.list', |
||
67 | 'AddonStatus' => 'command+.addon.status', |
||
68 | 'DatabaseStatus' => 'command+.database.status', |
||
69 | 'DatabaseUpgrade' => 'command+.database.upgrade', |
||
70 | 'DatabaseClean' => 'command+.database.clean', |
||
71 | 'DatabaseRefresh' => 'command+.database.refresh', |
||
72 | 'DatabaseRollback' => 'command+.database.rollback', |
||
73 | 'DatabaseAgain' => 'command+.database.again', |
||
74 | 'DatabaseSeed' => 'command+.database.seed', |
||
75 | 'HashMake' => 'command+.hash.make', |
||
76 | 'HashCheck' => 'command+.hash.check', |
||
77 | ]; |
||
78 | |||
79 | /** |
||
80 | * The commands to be registered. |
||
81 | * |
||
82 | * @var array |
||
83 | */ |
||
84 | protected $devCommands = [ |
||
85 | 'AppName' => 'command.app.name', |
||
86 | // 'AuthMake' => 'command.auth.make', |
||
87 | // 'CacheTable' => 'command.cache.table', |
||
88 | // 'ConsoleMake' => 'command.console.make', |
||
89 | // 'ControllerMake' => 'command.controller.make', |
||
90 | 'EventGenerate' => 'command.event.generate', |
||
91 | // 'EventMake' => 'command.event.make', |
||
92 | // 'FactoryMake' => 'command.factory.make', |
||
93 | // 'JobMake' => 'command.job.make', |
||
94 | // 'ListenerMake' => 'command.listener.make', |
||
95 | // 'MailMake' => 'command.mail.make', |
||
96 | // 'MiddlewareMake' => 'command.middleware.make', |
||
97 | // 'MigrateMake' => 'command.migrate.make', |
||
98 | // 'ModelMake' => 'command.model.make', |
||
99 | // 'NotificationMake' => 'command.notification.make', |
||
100 | // 'NotificationTable' => 'command.notification.table', |
||
101 | // 'PolicyMake' => 'command.policy.make', |
||
102 | // 'ProviderMake' => 'command.provider.make', |
||
103 | // 'QueueFailedTable' => 'command.queue.failed-table', |
||
104 | // 'QueueTable' => 'command.queue.table', |
||
105 | // 'RequestMake' => 'command.request.make', |
||
106 | // 'ResourceMake' => 'command.resource.make', |
||
107 | // 'RuletMake' => 'command.rule.make', |
||
108 | // 'SeederMake' => 'command.seeder.make', |
||
109 | // 'SessionTable' => 'command.session.table', |
||
110 | // 'TestMake' => 'command.test.make', |
||
111 | 'Preset' => 'command.preset', |
||
112 | 'Serve' => 'command.serve', |
||
113 | 'VendorPublish' => 'command.vendor.publish', |
||
114 | |||
115 | 'AppContainer' => 'command+.app.container', |
||
116 | 'AddonName' => 'command+.addon.name', |
||
117 | 'AddonRemove' => 'command+.addon.remove', |
||
118 | |||
119 | 'MakeAddon' => 'command+.addon.make', |
||
120 | 'MakeCommand' => 'command+.command.make', |
||
121 | 'MakeController' => 'command+.controller.make', |
||
122 | 'MakeEvent' => 'command+.event.make', |
||
123 | 'MakeJob' => 'command+.job.make', |
||
124 | 'MakeListener' => 'command+.listener.make', |
||
125 | 'MakeMail' => 'command+.mail.make', |
||
126 | 'MakeMiddleware' => 'command+.middleware.make', |
||
127 | 'MakeMigration' => 'command+.migration.make', |
||
128 | 'MakeModel' => 'command+.model.make', |
||
129 | 'MakeNotification' => 'command+.notification.make', |
||
130 | 'MakePolicy' => 'command+.policy.make', |
||
131 | 'MakeProvider' => 'command+.provider.make', |
||
132 | 'MakeRequest' => 'command+.request.make', |
||
133 | 'MakeResource' => 'command+.resource.make', |
||
134 | 'MakeRule' => 'command+.rule.make', |
||
135 | 'MakeSeeder' => 'command+.seeder.make', |
||
136 | 'MakeTest' => 'command+.test.make', |
||
137 | ]; |
||
138 | |||
139 | /** |
||
140 | * Register the service provider. |
||
141 | * |
||
142 | * @return void |
||
143 | */ |
||
144 | 12 | public function register() |
|
145 | { |
||
146 | 12 | $this->registerCommands($this->availableCommands()); |
|
147 | 12 | } |
|
148 | |||
149 | /** |
||
150 | * Get the services provided by the provider. |
||
151 | * |
||
152 | * @return array |
||
153 | */ |
||
154 | public function provides() |
||
155 | { |
||
156 | return array_values($this->availableCommands()); |
||
157 | } |
||
158 | |||
159 | /** |
||
160 | * @return array |
||
161 | */ |
||
162 | 12 | protected function availableCommands() |
|
163 | { |
||
164 | 12 | $commands = $this->commands; |
|
165 | |||
166 | 12 | if ($this->app->environment() != 'production') { |
|
167 | 12 | $commands = array_merge($commands, $this->devCommands); |
|
168 | } |
||
169 | |||
170 | 12 | return $commands; |
|
171 | } |
||
172 | |||
173 | /** |
||
174 | * Register the given commands. |
||
175 | * |
||
176 | * @param array $commands |
||
177 | * @return void |
||
178 | */ |
||
179 | 12 | protected function registerCommands(array $commands) |
|
180 | { |
||
181 | 12 | foreach ($commands as $name => $command) { |
|
182 | 12 | $this->{"register{$name}Command"}($command); |
|
183 | } |
||
184 | |||
185 | 12 | $this->commands(array_values($commands)); |
|
186 | 12 | } |
|
187 | |||
188 | /** |
||
189 | * Register the command. |
||
190 | * |
||
191 | * @param string $command |
||
192 | * @return void |
||
193 | */ |
||
194 | protected function registerRouteCommand($command) |
||
195 | { |
||
196 | 12 | $this->app->singleton($command, function ($app) { |
|
197 | 1 | return new Commands\RouteListCommand($app); |
|
198 | 12 | }); |
|
199 | 12 | } |
|
200 | |||
201 | /** |
||
202 | * Register the command. |
||
203 | * |
||
204 | * @param string $command |
||
205 | * @return void |
||
206 | */ |
||
207 | protected function registerTailCommand($command) |
||
208 | { |
||
209 | 12 | $this->app->singleton($command, function ($app) { |
|
210 | 1 | return new Commands\TailCommand($app); |
|
0 ignored issues
–
show
|
|||
211 | 12 | }); |
|
212 | 12 | } |
|
213 | |||
214 | /** |
||
215 | * Register the command. |
||
216 | * |
||
217 | * @param string $command |
||
218 | * @return void |
||
219 | */ |
||
220 | protected function registerAppContainerCommand($command) |
||
221 | { |
||
222 | 12 | $this->app->singleton($command, function ($app) { |
|
223 | 1 | return new Commands\AppContainerCommand($app); |
|
0 ignored issues
–
show
The call to
AppContainerCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
224 | 12 | }); |
|
225 | 12 | } |
|
226 | |||
227 | /** |
||
228 | * Register the command. |
||
229 | * |
||
230 | * @param string $command |
||
231 | * @return void |
||
232 | */ |
||
233 | protected function registerAddonListCommand($command) |
||
234 | { |
||
235 | 12 | $this->app->singleton($command, function ($app) { |
|
236 | 1 | return new Addons\Commands\AddonListCommand($app); |
|
0 ignored issues
–
show
The call to
AddonListCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
237 | 12 | }); |
|
238 | 12 | } |
|
239 | |||
240 | /** |
||
241 | * Register the command. |
||
242 | * |
||
243 | * @param string $command |
||
244 | * @return void |
||
245 | */ |
||
246 | protected function registerAddonStatusCommand($command) |
||
247 | { |
||
248 | 12 | $this->app->singleton($command, function ($app) { |
|
249 | 1 | return new Addons\Commands\AddonStatusCommand($app); |
|
0 ignored issues
–
show
The call to
AddonStatusCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
250 | 12 | }); |
|
251 | 12 | } |
|
252 | |||
253 | /** |
||
254 | * Register the command. |
||
255 | * |
||
256 | * @param string $command |
||
257 | * @return void |
||
258 | */ |
||
259 | protected function registerAddonNameCommand($command) |
||
260 | { |
||
261 | 12 | $this->app->singleton($command, function ($app) { |
|
262 | 1 | return new Addons\Commands\AddonNameCommand($app); |
|
0 ignored issues
–
show
The call to
AddonNameCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
263 | 12 | }); |
|
264 | 12 | } |
|
265 | |||
266 | /** |
||
267 | * Register the command. |
||
268 | * |
||
269 | * @param string $command |
||
270 | * @return void |
||
271 | */ |
||
272 | protected function registerAddonRemoveCommand($command) |
||
273 | { |
||
274 | 12 | $this->app->singleton($command, function ($app) { |
|
275 | 1 | return new Addons\Commands\AddonRemoveCommand($app); |
|
0 ignored issues
–
show
The call to
AddonRemoveCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
276 | 12 | }); |
|
277 | 12 | } |
|
278 | |||
279 | /** |
||
280 | * Register the command. |
||
281 | * |
||
282 | * @param string $command |
||
283 | * @return void |
||
284 | */ |
||
285 | protected function registerDatabaseStatusCommand($command) |
||
286 | { |
||
287 | 12 | $this->app->singleton($command, function ($app) { |
|
288 | 1 | return new Database\Commands\DatabaseStatusCommand($app); |
|
0 ignored issues
–
show
The call to
DatabaseStatusCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
289 | 12 | }); |
|
290 | 12 | } |
|
291 | |||
292 | /** |
||
293 | * Register the command. |
||
294 | * |
||
295 | * @param string $command |
||
296 | * @return void |
||
297 | */ |
||
298 | protected function registerDatabaseUpgradeCommand($command) |
||
299 | { |
||
300 | 12 | $this->app->singleton($command, function ($app) { |
|
301 | 1 | return new Database\Commands\DatabaseUpgradeCommand($app); |
|
0 ignored issues
–
show
The call to
DatabaseUpgradeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
302 | 12 | }); |
|
303 | 12 | } |
|
304 | |||
305 | /** |
||
306 | * Register the command. |
||
307 | * |
||
308 | * @param string $command |
||
309 | * @return void |
||
310 | */ |
||
311 | protected function registerDatabaseCleanCommand($command) |
||
312 | { |
||
313 | 12 | $this->app->singleton($command, function ($app) { |
|
314 | 1 | return new Database\Commands\DatabaseCleanCommand($app); |
|
0 ignored issues
–
show
The call to
DatabaseCleanCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
315 | 12 | }); |
|
316 | 12 | } |
|
317 | |||
318 | /** |
||
319 | * Register the command. |
||
320 | * |
||
321 | * @param string $command |
||
322 | * @return void |
||
323 | */ |
||
324 | protected function registerDatabaseRefreshCommand($command) |
||
325 | { |
||
326 | 12 | $this->app->singleton($command, function ($app) { |
|
327 | 1 | return new Database\Commands\DatabaseRefreshCommand($app); |
|
0 ignored issues
–
show
The call to
DatabaseRefreshCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
328 | 12 | }); |
|
329 | 12 | } |
|
330 | |||
331 | /** |
||
332 | * Register the command. |
||
333 | * |
||
334 | * @param string $command |
||
335 | * @return void |
||
336 | */ |
||
337 | protected function registerDatabaseRollbackCommand($command) |
||
338 | { |
||
339 | 12 | $this->app->singleton($command, function ($app) { |
|
340 | 1 | return new Database\Commands\DatabaseRollbackCommand($app); |
|
0 ignored issues
–
show
The call to
DatabaseRollbackCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
341 | 12 | }); |
|
342 | 12 | } |
|
343 | |||
344 | /** |
||
345 | * Register the command. |
||
346 | * |
||
347 | * @param string $command |
||
348 | * @return void |
||
349 | */ |
||
350 | protected function registerDatabaseAgainCommand($command) |
||
351 | { |
||
352 | 12 | $this->app->singleton($command, function ($app) { |
|
353 | 1 | return new Database\Commands\DatabaseAgainCommand($app); |
|
0 ignored issues
–
show
The call to
DatabaseAgainCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
354 | 12 | }); |
|
355 | 12 | } |
|
356 | |||
357 | /** |
||
358 | * Register the command. |
||
359 | * |
||
360 | * @param string $command |
||
361 | * @return void |
||
362 | */ |
||
363 | protected function registerDatabaseSeedCommand($command) |
||
364 | { |
||
365 | 12 | $this->app->singleton($command, function ($app) { |
|
366 | 1 | return new Database\Commands\DatabaseSeedCommand($app); |
|
0 ignored issues
–
show
The call to
DatabaseSeedCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
367 | 12 | }); |
|
368 | 12 | } |
|
369 | |||
370 | /** |
||
371 | * Register the command. |
||
372 | * |
||
373 | * @param string $command |
||
374 | * @return void |
||
375 | */ |
||
376 | protected function registerHashMakeCommand($command) |
||
377 | { |
||
378 | 12 | $this->app->singleton($command, function ($app) { |
|
379 | 1 | return new Commands\HashMakeCommand($app); |
|
0 ignored issues
–
show
The call to
HashMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
380 | 12 | }); |
|
381 | 12 | } |
|
382 | |||
383 | /** |
||
384 | * Register the command. |
||
385 | * |
||
386 | * @param string $command |
||
387 | * @return void |
||
388 | */ |
||
389 | protected function registerHashCheckCommand($command) |
||
390 | { |
||
391 | 12 | $this->app->singleton($command, function ($app) { |
|
392 | 1 | return new Commands\HashCheckCommand($app); |
|
0 ignored issues
–
show
The call to
HashCheckCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
393 | 12 | }); |
|
394 | 12 | } |
|
395 | |||
396 | /** |
||
397 | * Register the command. |
||
398 | * |
||
399 | * @param string $command |
||
400 | * @return void |
||
401 | */ |
||
402 | protected function registerMakeAddonCommand($command) |
||
403 | { |
||
404 | 12 | $this->app->singleton($command, function ($app) { |
|
405 | 1 | return new Addons\Commands\AddonMakeCommand($app); |
|
0 ignored issues
–
show
The call to
AddonMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
406 | 12 | }); |
|
407 | 12 | } |
|
408 | |||
409 | /** |
||
410 | * Register the command. |
||
411 | * |
||
412 | * @param string $command |
||
413 | * @return void |
||
414 | */ |
||
415 | protected function registerMakeCommandCommand($command) |
||
416 | { |
||
417 | 12 | $this->app->singleton($command, function ($app) { |
|
418 | 1 | return new Generators\Commands\CommandMakeCommand($app); |
|
0 ignored issues
–
show
The call to
CommandMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
419 | 12 | }); |
|
420 | 12 | } |
|
421 | |||
422 | /** |
||
423 | * Register the command. |
||
424 | * |
||
425 | * @param string $command |
||
426 | * @return void |
||
427 | */ |
||
428 | protected function registerMakeControllerCommand($command) |
||
429 | { |
||
430 | 12 | $this->app->singleton($command, function ($app) { |
|
431 | 1 | return new Generators\Commands\ControllerMakeCommand($app); |
|
0 ignored issues
–
show
The call to
ControllerMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
432 | 12 | }); |
|
433 | 12 | } |
|
434 | |||
435 | /** |
||
436 | * Register the command. |
||
437 | * |
||
438 | * @param string $command |
||
439 | * @return void |
||
440 | */ |
||
441 | protected function registerMakeEventCommand($command) |
||
442 | { |
||
443 | 12 | $this->app->singleton($command, function ($app) { |
|
444 | 1 | return new Generators\Commands\EventMakeCommand($app); |
|
0 ignored issues
–
show
The call to
EventMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
445 | 12 | }); |
|
446 | 12 | } |
|
447 | |||
448 | /** |
||
449 | * Register the command. |
||
450 | * |
||
451 | * @param string $command |
||
452 | * @return void |
||
453 | */ |
||
454 | protected function registerMakeJobCommand($command) |
||
455 | { |
||
456 | 12 | $this->app->singleton($command, function ($app) { |
|
457 | 1 | return new Generators\Commands\JobMakeCommand($app); |
|
0 ignored issues
–
show
The call to
JobMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
458 | 12 | }); |
|
459 | 12 | } |
|
460 | |||
461 | /** |
||
462 | * Register the command. |
||
463 | * |
||
464 | * @param string $command |
||
465 | * @return void |
||
466 | */ |
||
467 | protected function registerMakeListenerCommand($command) |
||
468 | { |
||
469 | 12 | $this->app->singleton($command, function ($app) { |
|
470 | 1 | return new Generators\Commands\ListenerMakeCommand($app); |
|
0 ignored issues
–
show
The call to
ListenerMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
471 | 12 | }); |
|
472 | 12 | } |
|
473 | |||
474 | /** |
||
475 | * Register the command. |
||
476 | * |
||
477 | * @param string $command |
||
478 | * @return void |
||
479 | */ |
||
480 | protected function registerMakeMailCommand($command) |
||
481 | { |
||
482 | 12 | $this->app->singleton($command, function ($app) { |
|
483 | 1 | return new Generators\Commands\MailMakeCommand($app); |
|
0 ignored issues
–
show
The call to
MailMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
484 | 12 | }); |
|
485 | 12 | } |
|
486 | |||
487 | |||
488 | /** |
||
489 | * Register the command. |
||
490 | * |
||
491 | * @param string $command |
||
492 | * @return void |
||
493 | */ |
||
494 | protected function registerMakeMiddlewareCommand($command) |
||
495 | { |
||
496 | 12 | $this->app->singleton($command, function ($app) { |
|
497 | 1 | return new Generators\Commands\MiddlewareMakeCommand($app); |
|
0 ignored issues
–
show
The call to
MiddlewareMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
498 | 12 | }); |
|
499 | 12 | } |
|
500 | |||
501 | /** |
||
502 | * Register the command. |
||
503 | * |
||
504 | * @param string $command |
||
505 | * @return void |
||
506 | */ |
||
507 | protected function registerMakeMigrationCommand($command) |
||
508 | { |
||
509 | 12 | $this->app->singleton($command, function ($app) { |
|
510 | 1 | return new Database\Commands\MigrationMakeCommand($app); |
|
0 ignored issues
–
show
The call to
MigrationMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
511 | 12 | }); |
|
512 | 12 | } |
|
513 | |||
514 | /** |
||
515 | * Register the command. |
||
516 | * |
||
517 | * @param string $command |
||
518 | * @return void |
||
519 | */ |
||
520 | protected function registerMakeModelCommand($command) |
||
521 | { |
||
522 | 12 | $this->app->singleton($command, function ($app) { |
|
523 | 1 | return new Generators\Commands\ModelMakeCommand($app); |
|
0 ignored issues
–
show
The call to
ModelMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
524 | 12 | }); |
|
525 | 12 | } |
|
526 | |||
527 | /** |
||
528 | * Register the command. |
||
529 | * |
||
530 | * @param string $command |
||
531 | * @return void |
||
532 | */ |
||
533 | protected function registerMakeNotificationCommand($command) |
||
534 | { |
||
535 | 12 | $this->app->singleton($command, function ($app) { |
|
536 | 1 | return new Generators\Commands\NotificationMakeCommand($app); |
|
0 ignored issues
–
show
The call to
NotificationMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
537 | 12 | }); |
|
538 | 12 | } |
|
539 | |||
540 | /** |
||
541 | * Register the command. |
||
542 | * |
||
543 | * @param string $command |
||
544 | * @return void |
||
545 | */ |
||
546 | protected function registerMakePolicyCommand($command) |
||
547 | { |
||
548 | 12 | $this->app->singleton($command, function ($app) { |
|
549 | 1 | return new Generators\Commands\PolicyMakeCommand($app); |
|
0 ignored issues
–
show
The call to
PolicyMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
550 | 12 | }); |
|
551 | 12 | } |
|
552 | |||
553 | /** |
||
554 | * Register the command. |
||
555 | * |
||
556 | * @param string $command |
||
557 | * @return void |
||
558 | */ |
||
559 | protected function registerMakeProviderCommand($command) |
||
560 | { |
||
561 | 12 | $this->app->singleton($command, function ($app) { |
|
562 | 1 | return new Generators\Commands\ProviderMakeCommand($app); |
|
0 ignored issues
–
show
The call to
ProviderMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
563 | 12 | }); |
|
564 | 12 | } |
|
565 | |||
566 | /** |
||
567 | * Register the command. |
||
568 | * |
||
569 | * @param string $command |
||
570 | * @return void |
||
571 | */ |
||
572 | protected function registerMakeRequestCommand($command) |
||
573 | { |
||
574 | 12 | $this->app->singleton($command, function ($app) { |
|
575 | 1 | return new Generators\Commands\RequestMakeCommand($app); |
|
0 ignored issues
–
show
The call to
RequestMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
576 | 12 | }); |
|
577 | 12 | } |
|
578 | |||
579 | /** |
||
580 | * Register the command. |
||
581 | * |
||
582 | * @param string $command |
||
583 | * @return void |
||
584 | */ |
||
585 | protected function registerMakeResourceCommand($command) |
||
586 | { |
||
587 | 12 | $this->app->singleton($command, function ($app) { |
|
588 | return new Generators\Commands\ResourceMakeCommand($app); |
||
0 ignored issues
–
show
The call to
ResourceMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
589 | 12 | }); |
|
590 | 12 | } |
|
591 | |||
592 | /** |
||
593 | * Register the command. |
||
594 | * |
||
595 | * @param string $command |
||
596 | * @return void |
||
597 | */ |
||
598 | protected function registerMakeRuleCommand($command) |
||
599 | { |
||
600 | 12 | $this->app->singleton($command, function ($app) { |
|
601 | return new Generators\Commands\RuleMakeCommand($app); |
||
0 ignored issues
–
show
The call to
RuleMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
602 | 12 | }); |
|
603 | 12 | } |
|
604 | |||
605 | /** |
||
606 | * Register the command. |
||
607 | * |
||
608 | * @param string $command |
||
609 | * @return void |
||
610 | */ |
||
611 | protected function registerMakeSeederCommand($command) |
||
612 | { |
||
613 | 12 | $this->app->singleton($command, function ($app) { |
|
614 | 1 | return new Database\Commands\SeederMakeCommand($app); |
|
0 ignored issues
–
show
The call to
SeederMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
615 | 12 | }); |
|
616 | 12 | } |
|
617 | |||
618 | /** |
||
619 | * Register the command. |
||
620 | * |
||
621 | * @param string $command |
||
622 | * @return void |
||
623 | */ |
||
624 | protected function registerMakeTestCommand($command) |
||
625 | { |
||
626 | 12 | $this->app->singleton($command, function ($app) { |
|
627 | 1 | return new Generators\Commands\TestMakeCommand($app); |
|
0 ignored issues
–
show
The call to
TestMakeCommand::__construct() has too many arguments starting with $app .
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
Loading history...
|
|||
628 | 12 | }); |
|
629 | } |
||
630 | } |
||
631 |
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.