Register the "install" migration command.

@return void
195191
protected function registerMigrateMakeCommand()
    {
        $this->app->singleton('migration.neoeloquent.creator', function($app) {
            return new MigrationCreator($app['files']);
        });

        $this->app->singleton('command.neoeloquent.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.neoeloquent.creator'];

            $packagePath = $app->basePath().'/vendor';

            $composer = $app->make('Illuminate\Support\Composer');

            return new MigrateMakeCommand($creator, $composer, $packagePath);
        });
    }
1076956
protected function registerPackageMigrateResetCommand()
    {
        $this->app->singleton('command.package.migrate.reset', function ($app)
        {
            return new PackageMigrateResetCommand($app['packages'], $app['files'], $app['migrator']);
        });

        $this->commands('command.package.migrate.reset');
    }
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);
        });
    }
12417
private function registerRepository()
    {
        $this->app->singleton('migration.repository', function ($app) {
            $table = $app['config']['database.migrations'];

            return new DatabaseMigrationRepository($app['db'], $table);
        });
    }
77930
protected function registerMakeMigrationCommand($command)
    {
        $this->app->singleton($command, function ($app) {
            return new Database\Commands\MigrationMakeCommand($app);
        });
    }
474954
public function register()
    {
        $commands = array(
            'PackageList',
            'PackageMigrate',
            'PackageMigrateRefresh',
            'PackageMigrateReset',
            'PackageMigrateRollback',
            'PackageMigrateStatus',
            'PackageSeed',
            'PackageOptimize',

            //
            'PackageMake',
            'ConsoleMake',
            'ControllerMake',
            'EventMake',
            'JobMake',
            'ListenerMake',
            'MiddlewareMake',
            'ModelMake',
            'NotificationMake',
            'PolicyMake',
            'ProviderMake',
            'MigrationMake',
            'RequestMake',
            'SeederMake',
        );

        foreach ($commands as $command) {
            $method = 'register' .$command .'Command';

            call_user_func(array($this, $method));
        }
    }
416719
def setup_migrate(app):
    """"""
    directory = path.join(path.dirname(__file__), 'migrations')
    migrate.init_app(app, db, directory=directory)
45669
public function register()
    {
        
          if ($this->app->runningInConsole()) {
                $this->commands([
                    Commands\CrudCommand::class,
                    Commands\CrudControllerCommand::class,
                    Commands\CrudModelCommand::class,
                    Commands\CrudMigrationCommand::class,
                    Commands\CrudViewCommand::class,
                    Commands\PivotMigrationCommand::class,
                    
                ]);
            }

     }
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');
    }
1115428
public function init()
    {
        $this->addCommand(Migration\CreateCommand::class);
        $this->addCommand(Migration\StatusCommand::class);
        $this->addCommand(Migration\MigrateCommand::class);
        $this->addCommand(Migration\ResetCommand::class);
        $this->addCommand(Migration\DropAllCommand::class);

        $this->addGlobalOption('d')
            ->alias('dir')
            ->description('Set migration file directory.');

        $this->addGlobalOption('p')
            ->alias('package')
            ->description('Package to run migration.');
    }
724318
public function registerCommands() : void {
		// Register a command for basset
		$this->app->singleton('command.basset', function($app) {
			return new BuildCommand($app['basset'], $app['basset.builder'], $app['basset.builder.cleaner']);
		});

		$this->commands('command.basset');
	}
1218949
public function migrate()
	{
		// Set our group arg & call migration
		$this->arguments->setOpt('group', $this->group->get('cn'));
		\App::get('client')->call('migration', 'run', $this->arguments, $this->output);
	}
1259241
public function register()
    {
        $this->mergeConfigFrom(
            __DIR__.'/../config/wink.php', 'wink'
        );

        $this->commands([
            Console\InstallCommand::class,
            Console\MigrateCommand::class,
        ]);
    }
378766
protected function setupMigrations()
    {
        $migrations = realpath(__DIR__.'/../database/migrations');

        $this->publishes([
            $migrations    => $this->app->databasePath() . '/migrations',
        ]);
    }
299005
protected function registerMigration()
    {
        $this->app->singleton('orchestra.publisher.migrate', function (Application $app) {
            // In order to use migration, we need to boot 'migration.repository'
            // instance.
            $app->make('migration.repository');

            return new MigrateManager($app, $app->make('migrator'));
        });
    }
636462
protected function registerInstallCommand(): void
    {
        $this->app->singleton('orchestra.commands.tenanti.install', function (Application $app) {
            return new InstallCommand($app->make('orchestra.tenanti'));
        });
    }
1117466
protected function registerMigrations()
    {
        $migrationsPath = __DIR__.'/../../database/migrations';

        $this->loadMigrationsFrom($migrationsPath);

        $this->publishes(
            [$migrationsPath => database_path('migrations')],
            'migrations'
        );
    }