Register Artisan commands
@return void
199565
protected function registerCommands()
    {
        $namespace    =    __NAMESPACE__ . '\\Commands\\';
        $keyPrefix    =    'lockdown.commands.';
        $commands    =    [
            $keyPrefix . 'assign-perm-user'  =>    'AssignPermissionToUser',
            $keyPrefix . 'assign-role-perm'  =>    'AssignPermissionToRole',
            $keyPrefix . 'assign-role-user'  =>    'AssignRoleToUser',
            $keyPrefix . 'create-perm'       =>    'CreatePermission',
            $keyPrefix . 'create-role'       =>    'CreateRole',
            $keyPrefix . 'delete-permission' =>    'DeletePermission',
            $keyPrefix . 'delete-role'       =>    'DeleteRole',
            $keyPrefix . 'remove-perm-user'  =>    'RemovePermissionFromUser',
            $keyPrefix . 'remove-role-perm'  =>    'RemovePermissionFromRole',
            $keyPrefix . 'remove-role-user'  =>    'RemoveRoleFromUser',
            $keyPrefix . 'show-permissions'  =>    'ShowPermissions',
            $keyPrefix . 'show-roles'        =>    'ShowRoles',
        ];

        foreach ($commands as $key => $class) {
            $this->app->bind(
                $key,
                function ($app) use ($class, $namespace) {
                    $classNamespaceFull    =    $namespace . $class;
                    return new $classNamespaceFull($app['lockdown']);
                }
            );
        }

        $this->commands(array_keys($commands));
    }
806563
protected function registerMigrateCommands()
    {
        $this->app->singleton('cms.commands.db-migrate', MigrateCommand::class);
        $this->app->singleton('cms.commands.db-migrate-install', MigrateInstallCommand::class);
        $this->app->singleton('cms.commands.db-migrate-refresh', MigrateRefreshCommand::class);
        $this->app->singleton('cms.commands.db-migrate-reset', MigrateResetCommand::class);
        $this->app->singleton('cms.commands.db-migrate-rollback', MigrateRollbackCommand::class);
        $this->app->singleton('cms.commands.db-migrate-status', MigrateStatusCommand::class);

        $this->commands([
            'cms.commands.db-migrate',
            'cms.commands.db-migrate-install',
            'cms.commands.db-migrate-reset',
            'cms.commands.db-migrate-refresh',
            'cms.commands.db-migrate-rollback',
            'cms.commands.db-migrate-status',
        ]);

        return $this;
    }
1363942
protected function registerMigrateMakeCommand()
    {
        Zilf::$container->register(
            'command.migrate.make', function ($app) {
                // Once we have the migration creator registered, we will create the command
                // and inject the creator. The creator is responsible for the actual file
                // creation of the migrations, and may be extended by these developers.
                $creator = $app['migration.creator'];

                $composer = $app['composer'];

                return new MigrateMakeCommand($creator, $composer);
            }
        );
    }
352542
protected function registerArtisanCommand()
  {
    if (!class_exists('WP_CLI')) {
      return false;
    }
      
    /**
     * Run Laravel Artisan for this plugin
     */
    \WP_CLI::add_command($this->getCLICommandName(), function() {
      $args = [];

      // rebuild args, because WP_CLI does stuff to it...
      if (!empty($_SERVER['argv'])) {
        $args = array_slice($_SERVER['argv'], 2);
        array_unshift($args, $_SERVER['argv'][0]);
      }

      $this->artisan->handle(
        new \Symfony\Component\Console\Input\ArgvInput($args),
        new \Symfony\Component\Console\Output\ConsoleOutput
      );
    });
  }
561546
public function register()
    {
        $this->registerConfigurationMapper();
        $this->registerCacheManager();
        $this->registerEntityManager();
        $this->registerClassMetadataFactory();
        $this->registerValidationVerifier();

        $this->commands([
            'Mitch\LaravelDoctrine\Console\GenerateProxiesCommand',
            'Mitch\LaravelDoctrine\Console\SchemaCreateCommand',
            'Mitch\LaravelDoctrine\Console\SchemaUpdateCommand',
            'Mitch\LaravelDoctrine\Console\SchemaDropCommand'
        ]);
    }
826849
protected function registerCommand()
    {
        $this->app->singleton('orchestra.commands.optimize', function ($app) {
            return new OptimizeCommand($app->make('orchestra.optimize'));
        });

        $this->commands('orchestra.commands.optimize');
    }
1066161
private function registerModelMakeCommand()
    {
        $this->app->bindShared('command.make.package.model', function ($app)
        {
            return new ModelMakeCommand($app['files'], $app['packages']);
        });

        $this->commands('command.make.package.model');
    }
1083224
protected function registerMakeCommand()
    {
        $this->app->bindShared('migration.creator', function($app)
        {
            return new MigrationCreator($app['files']);
        });

        $this->app->bindShared('command.migrate.make', function($app)
        {
            $creator = $app['migration.creator'];

            $packagePath = $app['path.base'] .DS .'vendor';

            return new MakeMigrationCommand($creator, $packagePath);
        });
    }
824478
public function register()
    {
        $this->commands([
                ConsoleMakeCommand::class,
                ControllerMakeCommand::class,
                EnvironmentCommand::class,
                EventMakeCommand::class,
                JobMakeCommand::class,
                KeyGenerateCommand::class,
                ListenerMakeCommand::class,
                MailMakeCommand::class,
                MiddlewareMakeCommand::class,
                ModelMakeCommand::class,
                NotificationMakeCommand::class,
                ProviderMakeCommand::class,
                ResourceMakeCommand::class,
                TestMakeCommand::class,
            ]);
    }
262607
protected function registerConsoleCommands()
    {
        $this->commands([
            InfoCommand::class,
            SchemaCreateCommand::class,
            SchemaUpdateCommand::class,
            SchemaDropCommand::class,
            SchemaValidateCommand::class,
            ClearMetadataCacheCommand::class,
            ClearResultCacheCommand::class,
            ClearQueryCacheCommand::class,
            EnsureProductionSettingsCommand::class,
            GenerateProxiesCommand::class,
            ConvertConfigCommand::class,
            MappingImportCommand::class,
            GenerateEntitiesCommand::class,
            GenerateRepositoriesCommand::class,
            ConvertMappingCommand::class,
            DumpDatabaseCommand::class
        ]);
    }
36857
protected function registerMakeCommand()
    {
        $this->app->singleton('command.repository.make', function ($app) {
            $prefix = $app['config']['repository.prefix'];
            $suffix = $app['config']['repository.suffix'];
            $contract = $app['config']['repository.contract'];
            $namespace = $app['config']['repository.namespace'];
            $creator = $app['repository.creator'];
            $files = $app['files'];

            return new RepositoryMakeCommand($creator, $prefix, $suffix, $contract, $namespace, $files);
        });

        $this->commands('command.repository.make');
    }
691086
public function registerCommands()
	{
		$this->app->singleton('command.cache.clear', function($app)
		{
			return new ClearCommand($app['cache']);
		});

		$this->app->singleton('command.cache.table', function($app)
		{
			return new CacheTableCommand($app['files'], $app['composer']);
		});

		$this->commands('command.cache.clear', 'command.cache.table');
	}
237569
public function registerCommands()
    {
        foreach ($this->commandsStack as $key => $command) {
            $this->resolveConsoleCommand('\\'.$command);
        }

        return $this;
    }
856381
protected function registerCommands(array $commands)
    {
        foreach ($commands as $command) {
            if ( ! $command instanceof SymfonyCommand) {
                $command = $this->container[$command];
            }

            $this->container['console']->add($command);
        }
    }
495590
private function registerArtisanCommands() {
        $this->commands([
            \BackupManager\Laravel\Laravel4DbBackupCommand::class,
            \BackupManager\Laravel\Laravel4DbRestoreCommand::class,
            \BackupManager\Laravel\Laravel4DbListCommand::class
        ]);
    }
859771
protected function registerCommands()
    {
        $this->app->singleton('command.vueg.component', function ($app) {
            return $app[MakeComponent::class];
        });

        $this->app->singleton('command.vueg.mixin', function ($app) {
            return $app[MakeMixin::class];
        });

        $this->commands('command.vueg.component');

        $this->commands('command.vueg.mixin');
    }
289799
public function commands($commands)
    {
        $commands = is_array($commands) ? $commands : func_get_args();

        Artisan::starting(function ($artisan) use ($commands) {
            $artisan->resolveCommands($commands);
        });
    }