Viewing file:  ArtisanServiceProvider.php (27.71 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
<?php
namespace Illuminate\Foundation\Providers;
use Illuminate\Auth\Console\ClearResetsCommand;
use Illuminate\Cache\Console\CacheTableCommand;
use Illuminate\Cache\Console\ClearCommand as CacheClearCommand;
use Illuminate\Cache\Console\ForgetCommand as CacheForgetCommand;
use Illuminate\Console\Scheduling\ScheduleFinishCommand;
use Illuminate\Console\Scheduling\ScheduleListCommand;
use Illuminate\Console\Scheduling\ScheduleRunCommand;
use Illuminate\Console\Scheduling\ScheduleTestCommand;
use Illuminate\Console\Scheduling\ScheduleWorkCommand;
use Illuminate\Contracts\Support\DeferrableProvider;
use Illuminate\Database\Console\DbCommand;
use Illuminate\Database\Console\DumpCommand;
use Illuminate\Database\Console\Factories\FactoryMakeCommand;
use Illuminate\Database\Console\Seeds\SeedCommand;
use Illuminate\Database\Console\Seeds\SeederMakeCommand;
use Illuminate\Database\Console\WipeCommand;
use Illuminate\Foundation\Console\CastMakeCommand;
use Illuminate\Foundation\Console\ChannelMakeCommand;
use Illuminate\Foundation\Console\ClearCompiledCommand;
use Illuminate\Foundation\Console\ComponentMakeCommand;
use Illuminate\Foundation\Console\ConfigCacheCommand;
use Illuminate\Foundation\Console\ConfigClearCommand;
use Illuminate\Foundation\Console\ConsoleMakeCommand;
use Illuminate\Foundation\Console\DownCommand;
use Illuminate\Foundation\Console\EnvironmentCommand;
use Illuminate\Foundation\Console\EventCacheCommand;
use Illuminate\Foundation\Console\EventClearCommand;
use Illuminate\Foundation\Console\EventGenerateCommand;
use Illuminate\Foundation\Console\EventListCommand;
use Illuminate\Foundation\Console\EventMakeCommand;
use Illuminate\Foundation\Console\ExceptionMakeCommand;
use Illuminate\Foundation\Console\JobMakeCommand;
use Illuminate\Foundation\Console\KeyGenerateCommand;
use Illuminate\Foundation\Console\ListenerMakeCommand;
use Illuminate\Foundation\Console\MailMakeCommand;
use Illuminate\Foundation\Console\ModelMakeCommand;
use Illuminate\Foundation\Console\NotificationMakeCommand;
use Illuminate\Foundation\Console\ObserverMakeCommand;
use Illuminate\Foundation\Console\OptimizeClearCommand;
use Illuminate\Foundation\Console\OptimizeCommand;
use Illuminate\Foundation\Console\PackageDiscoverCommand;
use Illuminate\Foundation\Console\PolicyMakeCommand;
use Illuminate\Foundation\Console\ProviderMakeCommand;
use Illuminate\Foundation\Console\RequestMakeCommand;
use Illuminate\Foundation\Console\ResourceMakeCommand;
use Illuminate\Foundation\Console\RouteCacheCommand;
use Illuminate\Foundation\Console\RouteClearCommand;
use Illuminate\Foundation\Console\RouteListCommand;
use Illuminate\Foundation\Console\RuleMakeCommand;
use Illuminate\Foundation\Console\ServeCommand;
use Illuminate\Foundation\Console\StorageLinkCommand;
use Illuminate\Foundation\Console\StubPublishCommand;
use Illuminate\Foundation\Console\TestMakeCommand;
use Illuminate\Foundation\Console\UpCommand;
use Illuminate\Foundation\Console\VendorPublishCommand;
use Illuminate\Foundation\Console\ViewCacheCommand;
use Illuminate\Foundation\Console\ViewClearCommand;
use Illuminate\Notifications\Console\NotificationTableCommand;
use Illuminate\Queue\Console\BatchesTableCommand;
use Illuminate\Queue\Console\ClearCommand as QueueClearCommand;
use Illuminate\Queue\Console\FailedTableCommand;
use Illuminate\Queue\Console\FlushFailedCommand as FlushFailedQueueCommand;
use Illuminate\Queue\Console\ForgetFailedCommand as ForgetFailedQueueCommand;
use Illuminate\Queue\Console\ListenCommand as QueueListenCommand;
use Illuminate\Queue\Console\ListFailedCommand as ListFailedQueueCommand;
use Illuminate\Queue\Console\PruneBatchesCommand as PruneBatchesQueueCommand;
use Illuminate\Queue\Console\RestartCommand as QueueRestartCommand;
use Illuminate\Queue\Console\RetryBatchCommand as QueueRetryBatchCommand;
use Illuminate\Queue\Console\RetryCommand as QueueRetryCommand;
use Illuminate\Queue\Console\TableCommand;
use Illuminate\Queue\Console\WorkCommand as QueueWorkCommand;
use Illuminate\Routing\Console\ControllerMakeCommand;
use Illuminate\Routing\Console\MiddlewareMakeCommand;
use Illuminate\Session\Console\SessionTableCommand;
use Illuminate\Support\ServiceProvider;
class ArtisanServiceProvider extends ServiceProvider implements DeferrableProvider
{
/**
* The commands to be registered.
*
* @var array
*/
protected $commands = [
'CacheClear' => 'command.cache.clear',
'CacheForget' => 'command.cache.forget',
'ClearCompiled' => 'command.clear-compiled',
'ClearResets' => 'command.auth.resets.clear',
'ConfigCache' => 'command.config.cache',
'ConfigClear' => 'command.config.clear',
'Db' => DbCommand::class,
'DbWipe' => 'command.db.wipe',
'Down' => 'command.down',
'Environment' => 'command.environment',
'EventCache' => 'command.event.cache',
'EventClear' => 'command.event.clear',
'EventList' => 'command.event.list',
'KeyGenerate' => 'command.key.generate',
'Optimize' => 'command.optimize',
'OptimizeClear' => 'command.optimize.clear',
'PackageDiscover' => 'command.package.discover',
'QueueClear' => 'command.queue.clear',
'QueueFailed' => 'command.queue.failed',
'QueueFlush' => 'command.queue.flush',
'QueueForget' => 'command.queue.forget',
'QueueListen' => 'command.queue.listen',
'QueuePruneBatches' => 'command.queue.prune-batches',
'QueueRestart' => 'command.queue.restart',
'QueueRetry' => 'command.queue.retry',
'QueueRetryBatch' => 'command.queue.retry-batch',
'QueueWork' => 'command.queue.work',
'RouteCache' => 'command.route.cache',
'RouteClear' => 'command.route.clear',
'RouteList' => 'command.route.list',
'SchemaDump' => 'command.schema.dump',
'Seed' => 'command.seed',
'ScheduleFinish' => ScheduleFinishCommand::class,
'ScheduleList' => ScheduleListCommand::class,
'ScheduleRun' => ScheduleRunCommand::class,
'ScheduleTest' => ScheduleTestCommand::class,
'ScheduleWork' => ScheduleWorkCommand::class,
'StorageLink' => 'command.storage.link',
'Up' => 'command.up',
'ViewCache' => 'command.view.cache',
'ViewClear' => 'command.view.clear',
];
/**
* The commands to be registered.
*
* @var array
*/
protected $devCommands = [
'CacheTable' => 'command.cache.table',
'CastMake' => 'command.cast.make',
'ChannelMake' => 'command.channel.make',
'ComponentMake' => 'command.component.make',
'ConsoleMake' => 'command.console.make',
'ControllerMake' => 'command.controller.make',
'EventGenerate' => 'command.event.generate',
'EventMake' => 'command.event.make',
'ExceptionMake' => 'command.exception.make',
'FactoryMake' => 'command.factory.make',
'JobMake' => 'command.job.make',
'ListenerMake' => 'command.listener.make',
'MailMake' => 'command.mail.make',
'MiddlewareMake' => 'command.middleware.make',
'ModelMake' => 'command.model.make',
'NotificationMake' => 'command.notification.make',
'NotificationTable' => 'command.notification.table',
'ObserverMake' => 'command.observer.make',
'PolicyMake' => 'command.policy.make',
'ProviderMake' => 'command.provider.make',
'QueueFailedTable' => 'command.queue.failed-table',
'QueueTable' => 'command.queue.table',
'QueueBatchesTable' => 'command.queue.batches-table',
'RequestMake' => 'command.request.make',
'ResourceMake' => 'command.resource.make',
'RuleMake' => 'command.rule.make',
'SeederMake' => 'command.seeder.make',
'SessionTable' => 'command.session.table',
'Serve' => 'command.serve',
'StubPublish' => 'command.stub.publish',
'TestMake' => 'command.test.make',
'VendorPublish' => 'command.vendor.publish',
];
/**
* Register the service provider.
*
* @return void
*/
public function register()
{
$this->registerCommands(array_merge(
$this->commands, $this->devCommands
));
}
/**
* Register the given commands.
*
* @param array $commands
* @return void
*/
protected function registerCommands(array $commands)
{
foreach (array_keys($commands) as $command) {
$this->{"register{$command}Command"}();
}
$this->commands(array_values($commands));
}
/**
* Register the command.
*
* @return void
*/
protected function registerCacheClearCommand()
{
$this->app->singleton('command.cache.clear', function ($app) {
return new CacheClearCommand($app['cache'], $app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerCacheForgetCommand()
{
$this->app->singleton('command.cache.forget', function ($app) {
return new CacheForgetCommand($app['cache']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerCacheTableCommand()
{
$this->app->singleton('command.cache.table', function ($app) {
return new CacheTableCommand($app['files'], $app['composer']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerCastMakeCommand()
{
$this->app->singleton('command.cast.make', function ($app) {
return new CastMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerChannelMakeCommand()
{
$this->app->singleton('command.channel.make', function ($app) {
return new ChannelMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerClearCompiledCommand()
{
$this->app->singleton('command.clear-compiled', function () {
return new ClearCompiledCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerClearResetsCommand()
{
$this->app->singleton('command.auth.resets.clear', function () {
return new ClearResetsCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerComponentMakeCommand()
{
$this->app->singleton('command.component.make', function ($app) {
return new ComponentMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerConfigCacheCommand()
{
$this->app->singleton('command.config.cache', function ($app) {
return new ConfigCacheCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerConfigClearCommand()
{
$this->app->singleton('command.config.clear', function ($app) {
return new ConfigClearCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerConsoleMakeCommand()
{
$this->app->singleton('command.console.make', function ($app) {
return new ConsoleMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerControllerMakeCommand()
{
$this->app->singleton('command.controller.make', function ($app) {
return new ControllerMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerDbCommand()
{
$this->app->singleton(DbCommand::class);
}
/**
* Register the command.
*
* @return void
*/
protected function registerDbWipeCommand()
{
$this->app->singleton('command.db.wipe', function () {
return new WipeCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerEventGenerateCommand()
{
$this->app->singleton('command.event.generate', function () {
return new EventGenerateCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerEventMakeCommand()
{
$this->app->singleton('command.event.make', function ($app) {
return new EventMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerExceptionMakeCommand()
{
$this->app->singleton('command.exception.make', function ($app) {
return new ExceptionMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerFactoryMakeCommand()
{
$this->app->singleton('command.factory.make', function ($app) {
return new FactoryMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerDownCommand()
{
$this->app->singleton('command.down', function () {
return new DownCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerEnvironmentCommand()
{
$this->app->singleton('command.environment', function () {
return new EnvironmentCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerEventCacheCommand()
{
$this->app->singleton('command.event.cache', function () {
return new EventCacheCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerEventClearCommand()
{
$this->app->singleton('command.event.clear', function ($app) {
return new EventClearCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerEventListCommand()
{
$this->app->singleton('command.event.list', function () {
return new EventListCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerJobMakeCommand()
{
$this->app->singleton('command.job.make', function ($app) {
return new JobMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerKeyGenerateCommand()
{
$this->app->singleton('command.key.generate', function () {
return new KeyGenerateCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerListenerMakeCommand()
{
$this->app->singleton('command.listener.make', function ($app) {
return new ListenerMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerMailMakeCommand()
{
$this->app->singleton('command.mail.make', function ($app) {
return new MailMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerMiddlewareMakeCommand()
{
$this->app->singleton('command.middleware.make', function ($app) {
return new MiddlewareMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerModelMakeCommand()
{
$this->app->singleton('command.model.make', function ($app) {
return new ModelMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerNotificationMakeCommand()
{
$this->app->singleton('command.notification.make', function ($app) {
return new NotificationMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerNotificationTableCommand()
{
$this->app->singleton('command.notification.table', function ($app) {
return new NotificationTableCommand($app['files'], $app['composer']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerOptimizeCommand()
{
$this->app->singleton('command.optimize', function () {
return new OptimizeCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerObserverMakeCommand()
{
$this->app->singleton('command.observer.make', function ($app) {
return new ObserverMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerOptimizeClearCommand()
{
$this->app->singleton('command.optimize.clear', function () {
return new OptimizeClearCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerPackageDiscoverCommand()
{
$this->app->singleton('command.package.discover', function () {
return new PackageDiscoverCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerPolicyMakeCommand()
{
$this->app->singleton('command.policy.make', function ($app) {
return new PolicyMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerProviderMakeCommand()
{
$this->app->singleton('command.provider.make', function ($app) {
return new ProviderMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerQueueFailedCommand()
{
$this->app->singleton('command.queue.failed', function () {
return new ListFailedQueueCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerQueueForgetCommand()
{
$this->app->singleton('command.queue.forget', function () {
return new ForgetFailedQueueCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerQueueFlushCommand()
{
$this->app->singleton('command.queue.flush', function () {
return new FlushFailedQueueCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerQueueListenCommand()
{
$this->app->singleton('command.queue.listen', function ($app) {
return new QueueListenCommand($app['queue.listener']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerQueuePruneBatchesCommand()
{
$this->app->singleton('command.queue.prune-batches', function () {
return new PruneBatchesQueueCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerQueueRestartCommand()
{
$this->app->singleton('command.queue.restart', function ($app) {
return new QueueRestartCommand($app['cache.store']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerQueueRetryCommand()
{
$this->app->singleton('command.queue.retry', function () {
return new QueueRetryCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerQueueRetryBatchCommand()
{
$this->app->singleton('command.queue.retry-batch', function () {
return new QueueRetryBatchCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerQueueWorkCommand()
{
$this->app->singleton('command.queue.work', function ($app) {
return new QueueWorkCommand($app['queue.worker'], $app['cache.store']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerQueueClearCommand()
{
$this->app->singleton('command.queue.clear', function () {
return new QueueClearCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerQueueFailedTableCommand()
{
$this->app->singleton('command.queue.failed-table', function ($app) {
return new FailedTableCommand($app['files'], $app['composer']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerQueueTableCommand()
{
$this->app->singleton('command.queue.table', function ($app) {
return new TableCommand($app['files'], $app['composer']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerQueueBatchesTableCommand()
{
$this->app->singleton('command.queue.batches-table', function ($app) {
return new BatchesTableCommand($app['files'], $app['composer']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerRequestMakeCommand()
{
$this->app->singleton('command.request.make', function ($app) {
return new RequestMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerResourceMakeCommand()
{
$this->app->singleton('command.resource.make', function ($app) {
return new ResourceMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerRuleMakeCommand()
{
$this->app->singleton('command.rule.make', function ($app) {
return new RuleMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerSeederMakeCommand()
{
$this->app->singleton('command.seeder.make', function ($app) {
return new SeederMakeCommand($app['files'], $app['composer']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerSessionTableCommand()
{
$this->app->singleton('command.session.table', function ($app) {
return new SessionTableCommand($app['files'], $app['composer']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerStorageLinkCommand()
{
$this->app->singleton('command.storage.link', function () {
return new StorageLinkCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerRouteCacheCommand()
{
$this->app->singleton('command.route.cache', function ($app) {
return new RouteCacheCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerRouteClearCommand()
{
$this->app->singleton('command.route.clear', function ($app) {
return new RouteClearCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerRouteListCommand()
{
$this->app->singleton('command.route.list', function ($app) {
return new RouteListCommand($app['router']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerSchemaDumpCommand()
{
$this->app->singleton('command.schema.dump', function () {
return new DumpCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerSeedCommand()
{
$this->app->singleton('command.seed', function ($app) {
return new SeedCommand($app['db']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerScheduleFinishCommand()
{
$this->app->singleton(ScheduleFinishCommand::class);
}
/**
* Register the command.
*
* @return void
*/
protected function registerScheduleListCommand()
{
$this->app->singleton(ScheduleListCommand::class);
}
/**
* Register the command.
*
* @return void
*/
protected function registerScheduleRunCommand()
{
$this->app->singleton(ScheduleRunCommand::class);
}
/**
* Register the command.
*
* @return void
*/
protected function registerScheduleTestCommand()
{
$this->app->singleton(ScheduleTestCommand::class);
}
/**
* Register the command.
*
* @return void
*/
protected function registerScheduleWorkCommand()
{
$this->app->singleton(ScheduleWorkCommand::class);
}
/**
* Register the command.
*
* @return void
*/
protected function registerServeCommand()
{
$this->app->singleton('command.serve', function () {
return new ServeCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerStubPublishCommand()
{
$this->app->singleton('command.stub.publish', function () {
return new StubPublishCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerTestMakeCommand()
{
$this->app->singleton('command.test.make', function ($app) {
return new TestMakeCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerUpCommand()
{
$this->app->singleton('command.up', function () {
return new UpCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerVendorPublishCommand()
{
$this->app->singleton('command.vendor.publish', function ($app) {
return new VendorPublishCommand($app['files']);
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerViewCacheCommand()
{
$this->app->singleton('command.view.cache', function () {
return new ViewCacheCommand;
});
}
/**
* Register the command.
*
* @return void
*/
protected function registerViewClearCommand()
{
$this->app->singleton('command.view.clear', function ($app) {
return new ViewClearCommand($app['files']);
});
}
/**
* Get the services provided by the provider.
*
* @return array
*/
public function provides()
{
return array_merge(array_values($this->commands), array_values($this->devCommands));
}
}
|