Registers settings
@return void
977640
public function register()
    {
        $postTypes = get_post_types(array(), 'objects');

        add_settings_section(
            'wp_page_for_post_type',
            __('Page and template for post type archives', 'wp-page-for-post-type'),
            '__return_false',
            'reading'
        );

        $postTypes = array_filter($postTypes, function ($item) {
            return $item->has_archive;
        });

        foreach ($postTypes as $postType) {
            $id = 'page_for_' . $postType->name;

            register_setting('reading', $id, array($this, 'flush'));
            register_setting('reading', 'page_for_' . $postType->name . '_template');
            register_setting('reading', 'page_for_' . $postType->name . '_content');

            add_settings_field(
                $id,
                $postType->label,
                array($this, 'pageDropDown'),
                'reading',
                'wp_page_for_post_type',
                array(
                    'name' => $id,
                    'post_type' => $postType,
                    'value'     => get_option($id)
                )
            );
        }
    }
35387
public function register()
    {
        $this->publishes([
            __DIR__.'/../config/laravel-conf.php' => config_path('laravel-conf.php'),
        ], 'config');

        $this->app->singleton('conf', function ($app) {
            return new ConfManager($app);
        });

        $this->publishes([
            __DIR__.'/../database/migrations/' => database_path('migrations'),
        ], 'migrations');

        require_once __DIR__.'/helper.php';
    }
1018281
public function register()
    {
        $this->mergeConfigFrom(
            __DIR__ . '/../../config/config.php', 'settings'
        );
        $this->app->singleton('settings', function ($app) {
            $config = $app->config->get('settings', [
                'cache_file' => storage_path('settings.json'),
                'db_table'   => 'settings'
            ]);

            return new Settings($app['db'], new Cache($config['cache_file']), $config);
        });
    }
169047
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/config/config.php', 'tactician');

        $this->registerLocator();
        $this->registerExtractor();
        $this->registerInflector();
        $this->registerCommandHandler();
        $this->registerMiddleware();
        $this->registerCommandBus();
        $this->registerDispatcher();
    }
148162
protected function registerRegistry()
    {
        $app = app();

		$this->app->singleton('registry', function ($app) {

			$config = $app->config->get('registry', array());

			return new Registry($app['db'], $app['registry.cache'], $config);

		});

    }
561546
public function register()
    {
        $this->registerConfigurationMapper();
        $this->registerCacheManager();
        $this->registerEntityManager();
        $this->registerClassMetadataFactory();
        $this->registerValidationVerifier();

        $this->commands([
            'Mitch\LaravelDoctrine\Console\GenerateProxiesCommand',
            'Mitch\LaravelDoctrine\Console\SchemaCreateCommand',
            'Mitch\LaravelDoctrine\Console\SchemaUpdateCommand',
            'Mitch\LaravelDoctrine\Console\SchemaDropCommand'
        ]);
    }
161758
public function register()
	{
		$method = version_compare(Application::VERSION, '5.2', '>=') ? 'singleton' : 'bindShared';

		// Bind the manager as a singleton on the container.
		$this->app->$method('anlutro\LaravelSettings\SettingsManager', function($app) {
			// When the class has been resolved once, make sure that settings
			// are saved when the application shuts down.
			if (version_compare(Application::VERSION, '5.0', '<')) {
				$app->shutdown(function($app) {
					$app->make('anlutro\LaravelSettings\SettingStore')->save();
				});
			}
			
			/**
			 * Construct the actual manager.
			 */
			return new SettingsManager($app);
		});

		// Provide a shortcut to the SettingStore for injecting into classes.
		$this->app->bind('anlutro\LaravelSettings\SettingStore', function($app) {
			return $app->make('anlutro\LaravelSettings\SettingsManager')->driver();
		});

		$this->app->alias('anlutro\LaravelSettings\SettingStore', 'setting');

		if (version_compare(Application::VERSION, '5.0', '>=')) {
			$this->mergeConfigFrom(__DIR__ . '/config/config.php', 'settings');
		}
	}
361369
private function registerSettingsStore()
    {
        $this->bind('arcanedev.settings.store', function(Application $app) {
            return $app->make('arcanedev.settings.manager')->driver();
        });

        $this->bind(
            \Arcanedev\Settings\Contracts\Store::class,
            'arcanedev.settings.store'
        );
    }
110521
public function register()
	{
		$this->laraclipNull = sha1(time());

		if (!defined('LARACLIP_NULL')) {
			define('LARACLIP_NULL', $this->laraclipNull);
		}
		
		$this->registerResizer();
		$this->registerIOWrapper();
		$this->registerConfig();
		$this->registerValidator();
		$this->registerInterpolator();
		$this->registerGD();
		$this->registerImagick();
		$this->registerGmagick();
		$this->registerFilesystemStorage();
		$this->registerS3Storage();
		$this->registerS3ClientManager();
		$this->registerAttachment();
		
		// commands
		$this->registerLaraClipFastenCommand();
		$this->registerLaraClipRefreshCommand();
		
		// services
		$this->registerImageRefreshService();

		$this->commands('laraclip.fasten');
		$this->commands('laraclip.refresh');
	}
843845
public function register()
    {
        //Load helpers
        load_module_helpers(__DIR__);

        //Merge configs
        $configs = split_files_with_basename($this->app['files']->glob(__DIR__ . '/../../config/*.php'));

        foreach ($configs as $key => $row) {
            $this->mergeConfigFrom($row, $key);
        }

        $this->app->register(RouteServiceProvider::class);
        $this->app->register(BootstrapModuleServiceProvider::class);
        $this->app->register(ViewComposerServiceProvider::class);
    }
12594
public function register()
	{
		$params = array(
			'database'  => DB_NAME,
			'username'  => DB_USER,
			'password'  => DB_PASSWORD,
			'prefix'    => $GLOBALS['table_prefix']
		);

		if(class_exists('Corcel\Database'))
		{
			Database::connect($params);
		}

	}
457602
public function register()
    {
        $configPath = __DIR__.DIRECTORY_SEPARATOR.'config'.DIRECTORY_SEPARATOR.'transliterate.php';

        $this->mergeConfigFrom($configPath, 'transliterate');

        $this->app->bind('Transliterate', function () {
            return new Transliterator();
        });
    }
1073639
protected function registerConfigFiles()
    {
        if (isset($this->dir) and isset($this->configFiles) and is_array($this->configFiles)) {
            foreach ($this->configFiles as $key) {
                $path = $this->getConfigFilePath($key);
                //$this->mergeConfigFrom($this->getConfigFilePath($filename), $filename);
                $config = $this->app->make('config')->get($key, [ ]);
                $this->app->make('config')->set($key, array_replace_recursive(require $path, $config));
            }
        }
    }
116053
public static function registerSettings()
    {
        if (!Gate::allows('settings_read')) {
            return;
        }

        Agencms::appendRoute(
            Route::load('settings')
                ->addGroup(
                    Group::full('Site')->key('site')->addField(
                        Field::string('title', 'Website Title'),
                        Field::string('title_prefix', 'Title Prefix'),
                        Field::string('title_suffix', 'Title Suffix')
                    )
                )
                ->addGroup(
                    Group::full('Analytics')->key('analytics')->addField(
                        Field::string('ga_code', 'Google Analytics Id')
                    )
                )
        );
    }
1372743
protected function registerCommands()
    {
        $this->commands(Commands\SetupCommand::class);
        $this->commands(Commands\MakeCommand::class);
        $this->commands(Commands\InstallCommand::class);
        $this->commands(Commands\UninstallCommand::class);
        $this->commands(Commands\UpdateCommand::class);
        $this->commands(Commands\CheckCommand::class);
        $this->commands(Commands\EnableCommand::class);
        $this->commands(Commands\DisableCommand::class);
        $this->commands(Commands\InfoCommand::class);
        $this->commands(Commands\ListCommand::class);
    }
349738
public function register()
    {
        $this->registerInstallCommand();
        $this->registerAuthSettingsInstallCommand();
        $this->registerAuthFilesInstallCommand();
        $this->registerAuthModelInstallCommand();
        $this->registerAuthViewsInstallCommand();
        //$this->registerInstallMiddlewareCommand();
    }
1021062
public function register() {
        foreach(Boot::$configs as $path_config => $is_deploy) {
            $path_config = str_replace('\\', '/', $path_config);
            $files       = rglob('*.php', 0, $path_config);
            
            foreach($files as $path) {
                $path = str_replace('\\', '/', $path);
                //                dump($path);
                $file = ltrim(str_replace([$path_config], [''], $path), '/');
                
                $key    = str_replace(['.php', '/',], ['', '.'], $file);
                $config = app('config')->get($key, []);
                //                dd($path, require $path);
                //                dump(require $path, $config, array_merge(require $path, $config));
                app('config')->set($key, array_merge(require $path, $config));
                if($is_deploy) {
                    $this->publishes([$path => config_path($file),], 'config');
                }
            }
        }
        foreach(Boot::$migrations as $path) {
            $this->publishes([
                $path => base_path('database/migrations'),
            ], 'migrations');
        }
    }