Register the migration repository service.

@return void
189745
protected function registerRepository()
    {
        $this->app->singleton('neoeloquent.migration.repository', function($app)
        {
            $model = new MigrationModel;

            $label = $app['config']['database.migrations_node'];

            if (isset($label)) {
                $model->setLabel($label);
            }

            return new DatabaseMigrationRepository(
                $app['db'],
                $app['db']->connection('neo4j')->getSchemaBuilder(),
                $model
            );
        });
    }
1165205
private function registerCommands()
    {
        $this->app['commands.drawbridge.migrations'] = $this->app->share(function($app)
        {
            return new MigrationsCommand($app);
        });

        $this->commands(
            array(
                 'commands.drawbridge.migrations'
            )
        );
    }
249560
protected function registerMigrateCommand()
	{
		$this->app->bindShared('command.migrate', function($app)
		{
			$packagePath = $app['path.base'].'/vendor';

			return new MigrateCommand($app['migrator'], $packagePath);
		});
	}
767590
protected function registerMigrator()
	{
		// The migrator is responsible for actually running and rollback the migration
		// files in the application. We'll pass in our database connection resolver
		// so the migrator can resolve any of these connections when it needs to.
		$this->app->bindShared('migrator', function($app)
		{
			$repository = $app['migration.repository'];

			return new Migrator($repository, $app['db'], $app['files']);
		});
	}
1372230
protected function registerCouchbaseBucketCacheDriver(): void
    {
        $this->app['cache']->extend('couchbase', function ($app, $config) {
            /** @var \Couchbase\Cluster $cluster */
            $cluster = $app['db']->connection($config['driver'])->getCouchbase();
            $password = (isset($config['bucket_password'])) ? $config['bucket_password'] : '';

            return new Repository(
                new CouchbaseStore(
                    $cluster,
                    $config['bucket'],
                    $password,
                    $app['config']->get('cache.prefix')
                )
            );
        });
    }
705399
public function register()
    {
        $app = $this->app;

        // register spec path for app
        $app['path.specs'] = $app->basePath().'/resources/specs';

        // register spec repository
        $app->singleton('specs', function ($app) {
            $loader = new Repository\FileLoader($app['files'], $app['path.specs']);

            return new Repository\NamespacedRepository($loader);
        });

        // register addon environment
        $app->instance('addon', $this->addonEnvironment = new AddonEnvironment($app));
        $app->alias('addon', AddonEnvironment::class);

        // register addon generator
        $app->singleton('addon.generator', function ($app) {
            return new AddonGenerator();
        });
        $app->alias('addon.generator', AddonGenerator::class);

        // register database migrator
        $app->singleton('database.migrator', function ($app) {
            return new Migrator($app['db'], $app['config']);
        });
        $app->alias('database.migrator', Migrator::class);

        $app['events']->fire(new AddonWorldCreated($this->addonEnvironment));

        $this->registerClassResolvers();

        (new AddonRegistrar)->register($app, $this->addonEnvironment->addons());

        $app['events']->fire(new AddonRegistered($this->addonEnvironment));
    }
253107
public function register()
    {
        $loader = $this->app->make(ConfigurationLoader::class);

        $this->app->instance('config', $loader->getConfig());
        $this->app->alias('config', 'Illuminate\Config\Repository');
        $this->app->alias('config', 'Illuminate\Contracts\Config\Repository');
    }
291625
protected function registerDatabaseService(): void
    {
        $this->app->alias('db', \Illuminate\Database\ConnectionResolverInterface::class);
        $this->app->register(\Illuminate\Database\DatabaseServiceProvider::class);

        if (File::exists($this->app->databasePath('seeds'))) {
            collect(File::files($this->app->databasePath('seeds')))->each(
                function ($file) {
                    File::requireOnce($file);
                }
            );
        }
    }
698927
public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/../config/roles.php', 'roles');
        $this->loadMigrationsFrom(__DIR__.'/Database/Migrations');
        $this->publishFiles();
        $this->loadSeedsFrom();
    }
1371397
public function register()
    {
        // Merge our config file with the application's copy of config file, to allow user to
        // just override the configuration that they wanted to make and keep the defaults that are
        // not touched
        $this->mergeConfigFrom(
            __DIR__.'/../../config/pluggables.php', 'pluggables'
        );

        // Register Services
        $this->registerServices();

        // Register Repository
        $this->registerRepository();

        // Register Migrator
        // Once the migrator instance is set, go ahead and register all migration related commands that are
        // used by the artisan commands for easy access
        $this->registerMigrator();

        // Register Console Commands
        $this->registerConsoleCommands();
    }
891417
protected function registerRepository()
    {
        $this->app->singleton(
            'mongolid.migration.repository',
            function ($app) {
                $collection = $app['config']['database.mongodb.default.migrations'] ?? 'migrations';

                return new MongolidMigrationRepository($app[Pool::class], $collection);
            }
        );
    }
1039252
protected function registerConfigBindings()
    {
        $loader = new FileLoader(new Filesystem(), $this->resourcePath('config'));

        $this->singleton('config', function () use ($loader) {
            return new Repository($loader, $this->environment());
        });
    }
309770
public function register()
    {
        $this->app->singleton('themes.view.finder', function ($app) {
            $finder   = new ThemeViewFinder($app['files'], $app['config']['view.paths']);
            $basePath = config('themes.path.frontend', base_path('themes/frontend'));
            $theme    = config('themes.frontend', 'default');
            $finder->setBasePath($basePath . DIRECTORY_SEPARATOR . $theme);

            return $finder;
        });

        $this->app->singleton('themes', function () {
            return new CollectionRepository(new Finder, $this->app['config']);
        });

        $this->app->alias('themes', Repository::class);
    }
1051415
public function register()
    {
        $this->app->register(\Netcore\Translator\ServiceProvider::class);

        $this->commands([
            ImportTranslations::class,
            FindTranslations::class,
        ]);
    }
288618
public function register()
    {
        // merge configs
        $this->mergeConfigFrom(
            __DIR__ . '/config.php', 'ibrand.setting'
        );

        $this->app->singleton(SettingInterface::class, function ($app) {
            $repository = new EloquentSetting(new SystemSetting());

            if (!config('ibrand.setting.cache')) {
                return $repository;
            }

            return new CacheDecorator($repository);
        });

        $this->app->alias(SettingInterface::class, 'system_setting');
    }
602790
protected function registerServices(): void
	{
		// Register core services

		$this->serviceRegistrar('core');

		// Register environment specific services

		if($this->isCommandLine())
		{
			$this->registerCLIServices();
		}
		else
		{
			$this->registerWebServices();
		}
	}
1353195
protected function registerPublishes(): void
    {
        if ($this->app->runningInConsole()) {
            $migrationsPath = __DIR__ . '/../../database/migrations';

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

            $this->loadMigrationsFrom($migrationsPath);
        }
    }