Register config.

@return $this
542892
protected function registerConfig()
    {
        $this->publishes([
            realpath(PLATFORM_PATH.'/config/press.php') => config_path('press.php'),
        ], 'config');

        $this->mergeConfigFrom(
            realpath(PLATFORM_PATH.'/config/press.php'), 'press'
        );

        return $this;
    }
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();
    }
424948
protected function registerConfigs()
    {
        $hasNewConfigs = false;

        $yamlConfig = new YamlConfig('', $this->configFiles['config']);
        $parameters = $yamlConfig->read();

        $configs = $this->kernelConfig->getConfigs();

        if (!count($configs)) {
            return;
        }

        foreach ($configs as $config) {
            // Check if the config is already being imported.
            if (VariableUtil::recursiveArraySearch($config, $parameters['imports']) === false) {
                $hasNewConfigs = true;

                // Add the config to the imports
                $parameters['imports'][]['resource'] = $config;
            }
        }

        if (!$hasNewConfigs) {
            return;
        }

        $yamlConfig = new YamlConfig('', $this->configFiles['config']);
        $yamlConfig->write($parameters);
        $yamlConfig->clean();
    }
1010092
public function register()
	{
		// Merge user's configuration
		$this->mergeConfigFrom(__DIR__ . '/config.php', 'tidy');

		// Bind 'stolz.tidy' shared component to the IoC container
		$this->app->singleton('stolz.tidy', function ($app) {
			return new Tidy($app['config']['tidy']);
		});
	}
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';
    }
243767
private function registerPackageConfig()
	{
		if (isLaravel5())
		{
	        $this->app->bindShared($this->packageName.'.config', function($app)
			{
				$configNameSpace = 'vendor.'.$this->packageVendor.'.'.$this->packageName.'.';
		        // Register the corresponding config for package
				return new $this->packageConfigClass($app['config'], $configNameSpace);
			});
			
		}

	}
501534
private function registerConfigs()
    {
        $this->app->singleton('config.framework', function () {
            return new FrameworkConfig($this->getConfigs());
        });

        $this->app->alias('config.framework', FrameworkConfig::class);
    }
200424
public function register()
    {
        $this->mergeConfigFrom(
            __DIR__.'/../config/keycdn.php', 'keycdn'
        );

        $this->app->bind(KeyCDN::class, function() {
            return KeyCDN::create(config('keycdn.key'));
        });

        $this->app->alias(KeyCDN::class, 'keycdn');
    }
950447
public function register()
    {
        // Set convention to use
        $this->app->bind(
                Convention::class,
                $this->resolveConventionClass(
                    $this->app->config->get('concord.convention', 'default')
                )
        );

        // Register interface -> actual class binding as singleton
        // For the sake of flexibility it's possible to replace
        // the actual class by setting `class` in the config
        $this->app->singleton(
            ConcordContract::class,
            $this->app->config->get('concord.class', Concord::class)
        );

        // Make an instance
        $concordInstance = $this->app->make(ConcordContract::class);
        // And make it available as the 'concord' service
        $this->app->instance('concord', $concordInstance);

        $this->registerCommands();

        $modules = config("concord.modules") ?: [];

        foreach ($modules as $key => $value) {
            $module = is_string($key) ? $key : $value;
            $config = is_array($value) ? $value : [];
            $concordInstance->registerModule($module, $config);
        }
    }
93542
public function register()
	{
		$this->mergeConfigFrom(__DIR__ . '/config/settings.php', 'settings');

		$this->app->singleton('settings', function ($app)
		{
			$config = $app->config->get('settings', require __DIR__ . '/config/settings.php');

			return new DatabaseRepository(
				$app['db'],
				new CacheRepository($config['cache_file']),
				$config
			);
		});
	}
530708
public function register()
	{
		$this->app['db'] = function($app)
		{
			// @FIXME: this isn't pretty, but it will shim the removal of the old mysql_* calls from php
			$driver = (Config::get('dbtype') == 'mysql') ? 'pdo' : Config::get('dbtype');

			$options = [
				'driver'   => $driver,
				'host'     => Config::get('host'),
				'user'     => Config::get('user'),
				'password' => Config::get('password'),
				'database' => Config::get('db'),
				'prefix'   => Config::get('dbprefix')
			];

			return Driver::getInstance($options);
		};
	}
1272585
protected function registerConfig()
    {
        $config = $this->config = app('PragmaRX\Tddd\Package\Services\Config');

        $this->app->singleton('tddd.config', function () use ($config) {
            return $config;
        });
    }
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);
    }
199737
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/../../../config/settings.php', 'settings');

        $this->app->singleton('settings.key_generator', function ($app) {
            return $app->make($app['config']['settings.key_generator']);
        });

        $this->app->singleton('settings.context_serializer', function ($app) {
            return $app->make($app['config']['settings.context_serializer']);
        });

        $this->app->singleton('settings.value_serializer', function ($app) {
            return $app->make($app['config']['settings.value_serializer']);
        });

        $this->app->singleton('settings.factory', function ($app) {
            return new Factory($app);
        });

        $this->app->singleton('settings.repository', function ($app) {
            return $app['settings.factory']->driver();
        });

        $this->app->singleton('settings', function ($app) {
            $settings = new Settings(
                $app['settings.repository'],
                $app['settings.key_generator'],
                $app['settings.value_serializer']
            );

            $settings->setCache($app['cache.store']);
            $settings->setEncrypter($app['encrypter']);
            $settings->setDispatcher($app['events']);

            $app['config']['settings.cache'] ? $settings->enableCache() : $settings->disableCache();
            $app['config']['settings.encryption'] ? $settings->enableEncryption() : $settings->disableEncryption();
            $app['config']['settings.events'] ? $settings->enableEvents() : $settings->disableEvents();

            return $settings;
        });

        $this->registerAliases();

        $this->registerCommands();
    }
845453
public function register()
    {
        $this->app['string'] = $this->app->share(function($app) {
            return new String($app['config']->get('app.locale'));
        });
    }
662940
public function register()
    {
        $configPath = __DIR__.'/../config/theme.php';

        // Merge config to allow user overwrite.
        $this->mergeConfigFrom($configPath, 'theme');

        // Temp to use in closure.
        $app = $this->app;

        // Add view extension.
        $this->app['view']->addExtension('twig.php', 'twig', function() use ($app)
        {
            return new Engines\TwigEngine($app);
        });

        // Register providers.
        $this->registerAsset();
        $this->registerTheme();
        //$this->registerWidget();
        $this->registerBreadcrumb();

        // Register commands.
        $this->registerThemeGenerator();
        $this->registerWidgetGenerator();
        $this->registerThemeDestroy();

        // Assign commands.
        $this->commands(
            'theme.create',
            'theme.widget',
            'theme.destroy'
        );
    }
303060
private function registerBase()
    {
        if (!empty($this['config']['cache']) && $this['config']['cache'] instanceof CacheInterface) {
            $this['cache'] = $this['config']['cache'];
        } else {
            $this['cache'] = function () {
                return new FilesystemCache(sys_get_temp_dir());
            };
        }

        $this['access_token'] = function () {
            return new AccessToken(
                $this['config']['appID'],
                $this['config']['appKey'],
                $this['config']['custID']
            );
        };

    }