Register the cache related console commands.
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',
        ]);
    }
1368991
protected function registerOptimizeCommand()
	{
		$this->app->bindShared('command.optimize', function($app)
		{
			return new \Weloquent\Core\Console\OptimizeCommand($app['composer']);
		});
	}
967812
protected function registerCommands()
    {
        $this->app['command.revisable.cleanup'] = $this->app->share(function($app)
        {
            return new CleanupCommand($app);
        });

        $this->commands(
            'command.revisable.cleanup'
        );
    }
124695
private function registerCommands()
    {
        $this->app['command.assetprocessor.cleanup'] = $this->app->share(function($app)
        {
            return new CleanupCommand($app);
        });

        $this->commands(
            'command.assetprocessor.cleanup'
        );

        $this->app['command.assetprocessor.process'] = $this->app->share(function($app)
        {
            return new ProcessCommand($app);
        });

        $this->commands(
            'command.assetprocessor.process'
        );
    }
506278
public function registerCustomCommands()
    {
        try {
            $this->readCustomCommandsFromConfig();
        } catch (ConfigurationException $e) {
            if ($e->getCode() === 404) {
                return;
            }
            $this->renderException($e, new ConsoleOutput());
            exit(1);
        } catch (\Exception $e) {
            $this->renderException($e, new ConsoleOutput());
            exit(1);
        }
    }
547549
protected function registerCommands()
    {
        $this->app['iverberk.larasearch.commands.reindex'] = $this->app->share(function ($app)
        {
            return new ReindexCommand();
        });

        $this->app['iverberk.larasearch.commands.paths'] = $this->app->share(function ($app)
        {
            return new PathsCommand();
        });

        $this->commands('iverberk.larasearch.commands.reindex');
        $this->commands('iverberk.larasearch.commands.paths');
    }
220401
protected function registerCustomCommands()
    {
        // Keep the core default commands to have the HelpCommand
        // which is used when using the --help option
        $defaultCommands = parent::getDefaultCommands();

        // Automatically register commands by scanning namespaces for a 'DroidPlugin' class.
        //print_r($this->autoLoader);
        $prefixes = $this->autoLoader->getPrefixesPsr4();

        foreach ($prefixes as $namespace => $paths) {
            $className = $namespace . 'DroidPlugin';
            if (class_exists($className)) {
                $plugin = new $className($this);
                $commands = $plugin->getCommands();
                foreach ($commands as $command) {
                    $this->add($command);
                }
            }
        }

        foreach ($this->all() as $command) {
            if (method_exists($command, 'setInventory')) {
                $command->setInventory($this->inventory);
            }
        }

        if ($this->hasProject()) {
            $runner = new TaskRunner(
                $this,
                $this->transformer,
                new LoggerFactory,
                new ExpressionLanguage,
                $this->buildLegacyTransformer()
            );
            $enabler = $this->configureHostEnabler();
            if (! $enabler) {
                # TODO output a warning about not being able to run remote cmds
            } else {
                $runner->setEnabler($enabler);
            }
            foreach ($this->getProject()->getTargets() as $target) {
                $command = new BaseTargetCommand;
                $command->setName($target->getName());
                $command->setDescription("Run target: " . $target->getName());
                $command->setTarget($target->getName());
                $command->setTaskRunner($runner);
                foreach ($target->getArguments() as $argument) {

                    $required = InputArgument::OPTIONAL;
                    if ($argument->getRequired()) {
                        $required = InputArgument::REQUIRED;
                    }

                    $command->addArgument(
                        $argument->getName(),
                        $required,
                        $argument->getDescription()
                    );
                }
                $this->add($command);
            }
        }
    }
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,
            ]);
    }
766367
protected function registerCommands(): void
    {
        // Register artisan commands
        foreach ($this->commands as $key => $value) {
            $this->app->singleton($value, $key);
        }

        $this->commands(array_values($this->commands));
    }
690620
def register(self, command):
        
        command = command()
        if command.name in self.commands:
            raise ConsoleError(
                "Command %s already registered!" % command.name
            )

        command.create_parser(self.subparsers)
        self.commands[command.name] = command
212778
protected function registerCommands()
    {
        $this->add(new \Daedalus\Command\DumpContainerCommand($this->kernel->getContainer()));
        $this->add(new \Daedalus\Command\HelpCommand($this->kernel->getContainer()));
    }
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');
    }
1244227
public function registerCommands(Console $console)
    {
        $commands = (array) $this->get('console.commands');

        foreach ($commands as $class) {
            if (class_exists($class) && is_subclass_of($class, Command::class)) {
                $console->addCommand($this->container->createObject($class));
            }
        }
    }
334091
protected function registerCommands()
    {
        $this->app->bind('command.log-reader.delete', 'Jackiedo\LogReader\Console\Commands\LogReaderDeleteCommand');
        $this->app->bind('command.log-reader.detail', 'Jackiedo\LogReader\Console\Commands\LogReaderDetailCommand');
        $this->app->bind('command.log-reader.file-list', 'Jackiedo\LogReader\Console\Commands\LogReaderFileListCommand');
        $this->app->bind('command.log-reader.get', 'Jackiedo\LogReader\Console\Commands\LogReaderGetCommand');
        $this->app->bind('command.log-reader.remove-file', 'Jackiedo\LogReader\Console\Commands\LogReaderRemoveFileCommand');

        $this->commands('command.log-reader.delete');
        $this->commands('command.log-reader.detail');
        $this->commands('command.log-reader.file-list');
        $this->commands('command.log-reader.get');
        $this->commands('command.log-reader.remove-file');
    }
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'
        );
    }
466077
protected function registerListCommand()
    {
        $this->app->singleton('command.module.list', function ($app) {
            return new \Caffeinated\Modules\Console\Commands\ModuleListCommand($app['modules']);
        });

        $this->commands('command.module.list');
    }
687946
public function registerCacheRepository()
    {
        $this->app->singleton('translation.cache.repository', function ($app) {
            $cacheStore = $app['cache']->getStore();
            return CacheRepositoryFactory::make($cacheStore, $app['config']->get('translator.cache.suffix'));
        });
    }