Register console commands.

@return void
972153
public function registerCommands()
    {
        if (! $this->app->runningInConsole()) {
            return;
        }

        foreach ($this->commands as $command) {
            $this->commands($command);
        }
    }
495590
private function registerArtisanCommands() {
        $this->commands([
            \BackupManager\Laravel\Laravel4DbBackupCommand::class,
            \BackupManager\Laravel\Laravel4DbRestoreCommand::class,
            \BackupManager\Laravel\Laravel4DbListCommand::class
        ]);
    }
1259241
public function register()
    {
        $this->mergeConfigFrom(
            __DIR__.'/../config/wink.php', 'wink'
        );

        $this->commands([
            Console\InstallCommand::class,
            Console\MigrateCommand::class,
        ]);
    }
1129763
public function register()
    {
        // Here we register commands for artisan
        $this->app->singleton('command.closuretable', function ($app) {
            return new ClosureTableCommand;
        });

        $this->app->singleton('command.closuretable.make', function ($app) {
            return $app['Franzose\ClosureTable\Console\MakeCommand'];
        });

        $this->commands('command.closuretable', 'command.closuretable.make');
    }
327657
public function register()
    {
        $this->commands([
            Commands\DeployCommand::class,
            Commands\ListCommand::class,
            Commands\RollbackCommand::class,
            Commands\SyncCommand::class,
        ]);
    }
102498
public function register()
    {
        $this->app->bindShared('command.cache.clear', function ($app)
        {
            return new Console\ClearCommand($app['cache'], $app['files']);
        });

        $this->app->bindShared('command.cache.forget', function ($app)
        {
            return new Console\ForgetCommand($app['cache']);
        });

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

        $this->commands('command.cache.clear', 'command.cache.forget', 'command.cache.table');
    }
68443
protected function registerCommands()
    {
        $this->app->singleton('command.settings.table', function ($app) {
            return new SettingsTableCommand($app['files'], $app['composer']);
        });

        $this->commands('command.settings.table');
    }
104186
public function registerCommands(){

        foreach($this->commands as $name => $class){

            $dotName = str_replace(':', '.', $name);

            $this->app['command.'.$dotName] = $this->app->share(function() use ($class)
            {
                $commandClassName = $class;
                return new $commandClassName();
            });

            $this->commands('command.'.$dotName);
        }
    }
379273
protected function registerScanCommand() {
		
		$this->commands('permacon.scan');
		$bind_method = method_exists($this->app, 'bindShared') ? 'bindShared' : 'singleton';
		$this->app->{$bind_method}('permacon.scan', function($app) {
			return new Console\PermaconScanCommand($this->files);
		});
	}
784372
protected function registerCommands()
    {
        $this->app->singleton('command.verification.make', function ($app) {
            return new MakeVerificationCommand($app['composer']);
        });

        $this->app->singleton('command.verification.clear', function ($app) {
            return new ClearVerificationTokensCommand();
        });

        $this->commands('command.verification.make');
        $this->commands('command.verification.clear');
    }
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'
        );
    }
673329
public function register(){
        //register commands
        $this->commands([
            Commands\CrudCommand::class,
            Commands\ControllerCommand::class,
            Commands\ServiceCommand::class,
            Commands\ContractCommand::class,
            Commands\ViewCommand::class,
        ]);
        //Merge config
        $this->mergeConfigFrom(
            __DIR__.'/../config/crudable.php', 'crudable'
        );
        //Load config
        $config = $this->app->make('config');
        //Check for auto binding
        if($config->get('crudable.use_auto_binding')){
            //Run contextual binding first
            foreach($config->get('crudable.implementations') as $usage){
                $this->app->when($usage['when'])
                    ->needs(isset($usage['needs'])?$usage['needs']:\Flobbos\Crudable\Contracts\Crud::class)
                    ->give($usage['give']);
            }
            //Run fixed bindings
            foreach($config->get('crudable.bindings') as $binding){
                $this->app->bind($binding['contract'],$binding['target']);
            }
        }
    }
1360039
protected function registerCommands(): void
    {
        $this->app->singleton('command.couchbase.indexes', function ($app) {
            return new IndexFinderCommand($app['Illuminate\Database\DatabaseManager']);
        });
        $this->app->singleton('command.couchbase.primary.index.create', function ($app) {
            return new PrimaryIndexCreatorCommand($app['Illuminate\Database\DatabaseManager']);
        });
        $this->app->singleton('command.couchbase.primary.index.drop', function ($app) {
            return new PrimaryIndexRemoverCommand($app['Illuminate\Database\DatabaseManager']);
        });
        $this->app->singleton('command.couchbase.index.create', function ($app) {
            return new IndexCreatorCommand($app['Illuminate\Database\DatabaseManager']);
        });
        $this->app->singleton('command.couchbase.index.drop', function ($app) {
            return new IndexRemoverCommand($app['Illuminate\Database\DatabaseManager']);
        });
        $this->app->singleton('command.couchbase.queue.index.create', function ($app) {
            return new QueueCreatorCommand($app['Illuminate\Database\DatabaseManager']);
        });
        $this->app->singleton('command.couchbase.design.document.create', function ($app) {
            return new DesignCreatorCommand(
                $app['Illuminate\Database\DatabaseManager'],
                $app['config']->get('couchbase.design')
            );
        });
        $this->commands([
            'command.couchbase.indexes',
            'command.couchbase.primary.index.create',
            'command.couchbase.primary.index.drop',
            'command.couchbase.index.create',
            'command.couchbase.index.drop',
            'command.couchbase.queue.index.create',
            'command.couchbase.design.document.create',
        ]);
    }
73959
private function registerConsoleMakeCommand()
    {
        $this->app->bindShared('command.make.package.console', function ($app)
        {
            return new ConsoleMakeCommand($app['files'], $app['packages']);
        });

        $this->commands('command.make.package.console');
    }
720241
protected function registerCommands()
    {
        $this->application->addCommands([
            new BuildCommand($this->viewFactory, $this->filesystem),
            new PostCommand($this->viewFactory, $this->filesystem)
        ]);
    }
961282
public function registerCommands()
    {
        $this->app->bind('mediasort.fasten', function ($app) {
            return new Commands\FastenCommand(
                $app['view'], $app['files']
            );
        });

        // TODO: Get this working
        //$this->app->bind('mediasort.refresh', function ($app) {
        //    return new Commands\RefreshCommand(
        //        new Services\ImageRefreshService()
        //    );
        //});

        $this->commands([
            'mediasort.fasten',
            //'mediasort.refresh',
        ]);
    }
826849
protected function registerCommand()
    {
        $this->app->singleton('orchestra.commands.optimize', function ($app) {
            return new OptimizeCommand($app->make('orchestra.optimize'));
        });

        $this->commands('orchestra.commands.optimize');
    }