Register the artisan commands.

@return void
967812
protected function registerCommands()
    {
        $this->app['command.revisable.cleanup'] = $this->app->share(function($app)
        {
            return new CleanupCommand($app);
        });

        $this->commands(
            'command.revisable.cleanup'
        );
    }
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);
        });
    }
955511
public function registerCommands()
    {
        $this->app['command.cpanel.install'] = $this->app->share(function()
        {
            return new InstallCommand();
        });

        $this->app['command.cpanel.user'] = $this->app->share(function()
        {
            return new UserSeedCommand();
        });

        $this->commands('command.cpanel.install','command.cpanel.user');
    }
33783
protected function registerCommand()
    {
        $this->app->singleton(
            'command.laroute.generate',
            function ($app) {
                $config     = $app['config'];
                $routes     = new Routes($app['router']->getRoutes(), $config->get('laroute.filter', 'all'), $config->get('laroute.action_namespace', ''));
                $generator  = $app->make('Lord\Laroute\Generators\GeneratorInterface');

                return new LarouteGeneratorCommand($config, $routes, $generator);
            }
        );

        $this->commands('command.laroute.generate');
    }
1186403
protected function registerRegisterUserCommand()
    {
        $this->app->singleton('command.authentication.user.register', function ($app) {
            return $app->make(RegisterUser::class);
        });
        $this->commands('command.authentication.user.register');
    }
295966
protected function registerCommands()
    {
        $this->app->bindIf('command.twig', function () {
            return new Command\TwigBridge;
        });

        $this->app->bindIf('command.twig.clean', function () {
            return new Command\Clean;
        });

        $this->app->bindIf('command.twig.lint', function () {
            return new Command\Lint;
        });

        $this->commands(
            'command.twig',
            'command.twig.clean',
            'command.twig.lint'
        );
    }
1177098
public function register()
    {
        $this->app->singleton('localization.js', function ($app) {

            $files = $app['files'];
            $langs = $app['path.base'].'/resources/lang';
            $messages = $app['config']->get('localization-js.messages');
            $generator = new Generators\LangJsGenerator($files, $langs, $messages);

            return new Commands\LangJsCommand($generator);
        });

        // Bind the Laravel JS Localization command into Laravel Artisan.
        $this->commands('localization.js');
    }
967172
public function register()
    {
        $this->app->singleton('command.models.generate', function($app) {
            $db = $app['db.connection'];
            $driverClass = __NAMESPACE__.'\Drivers\\'.ucfirst($db->getDriverName()).'Driver';
            $driver = new $driverClass($db->getPdo());

            $builder = new Builder($app['config'], $driver);

            return new Console\GenerateCommand($builder);
        });

        $this->commands([
            'command.models.generate'
        ]);
    }
231328
private function registerArtisanCommands()
    {
        // Register the Scaffold command
        $this->app->singleton('centaur.scaffold', function ($app) {
            return new CentaurScaffold(
                $app->make('files')
            );
        });
        $this->commands('centaur.scaffold');

        // Register the Spruce command
        $this->app->singleton('centaur.spruce', function ($app) {
            return new CentaurSpruce(
                $app->make('files')
            );
        });
        $this->commands('centaur.spruce');
    }
1165205
private function registerCommands()
    {
        $this->app['commands.drawbridge.migrations'] = $this->app->share(function($app)
        {
            return new MigrationsCommand($app);
        });

        $this->commands(
            array(
                 'commands.drawbridge.migrations'
            )
        );
    }
808259
private function registerMigrationMakeCommand()
    {
        $this->app->bindShared('command.make.package.migration', function ($app)
        {
            return new MigrationMakeCommand($app['files'], $app['packages']);
        });

        $this->commands('command.make.package.migration');
    }
224318
protected function registerCommands()
    {
        if ($this->app->runningInConsole()) {
            $this->commands([
                Console\AlphabetGenerateCommand::class,
                Console\OptimusGenerateCommand::class,
            ]);
        }
    }
744606
protected function registerAdminCommand()
    {
        $this->app->singleton('command.authentication.user.admin', function ($app) {
            return $app->make(Admin::class);
        });
        $this->commands('command.authentication.user.admin');
    }
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
      );
    });
  }
325917
public function registerCommands()
    {
        $this->app->singleton('command.addon.list', function ($app) {
            return new Commands\AddonListCommand();
        });

        $this->app->singleton('command.addon.status', function ($app) {
            return new Commands\AddonStatusCommand();
        });

        $this->app->singleton('command.addon.make', function ($app) {
            return new Commands\AddonMakeCommand();
        });

        $this->app->singleton('command.addon.name', function ($app) {
            return new Commands\AddonNameCommand();
        });

        $this->app->singleton('command.addon.remove', function ($app) {
            return new Commands\AddonRemoveCommand();
        });

        $this->commands([
            'command.addon.list',
            'command.addon.status',
            'command.addon.make',
            'command.addon.name',
            'command.addon.remove',
        ]);
    }
140824
protected function registerCommands(array $commands)
    {
        foreach (array_keys($commands) as $command) {
            call_user_func([$this, "register{$command}Command"]);
        }

        $this->commands(array_values($commands));
    }
289799
public function commands($commands)
    {
        $commands = is_array($commands) ? $commands : func_get_args();

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