Register and publish the config.
559093
protected function publishConfig()
    {
        $path = __DIR__ . '/../config/disqus.php';
        $this->mergeConfigFrom($path, 'disqus');
        $this->publishes([
            $path => config_path('disqus.php'),
        ], 'disqus');
    }
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();
    }
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);
        });
    }
707683
private function registerPublishing()
    {
        if ($this->app->runningInConsole()) {
            $this->publishes([
                __DIR__.'/../public' => public_path('vendor/wink'),
            ], 'wink-assets');

            $this->publishes([
                __DIR__.'/../config/wink.php' => config_path('wink.php'),
            ], 'wink-config');
        }
    }
1030938
protected function registerConfig()
    {
        // Merge project config and default package config
        $this->mergeConfigFrom(realpath(__DIR__.'/../../../config/auth.php'), 'nodes.api.auth');
        $this->mergeConfigFrom(realpath(__DIR__.'/../../../config/errors.php'), 'nodes.api.errors');
        $this->mergeConfigFrom(realpath(__DIR__.'/../../../config/middleware.php'), 'nodes.api.middleware');
        $this->mergeConfigFrom(realpath(__DIR__.'/../../../config/response.php'), 'nodes.api.response');
        $this->mergeConfigFrom(realpath(__DIR__.'/../../../config/settings.php'), 'nodes.api.settings');
        $this->mergeConfigFrom(realpath(__DIR__.'/../../../config/throttling.php'), 'nodes.api.throttling');
        $this->mergeConfigFrom(realpath(__DIR__.'/../../../config/transformer.php'), 'nodes.api.transformer');

        if (! $this->app->runningInConsole() && empty(config('nodes.api.settings.prefix')) && empty(config('nodes.api.settings.domain'))) {
            throw new RuntimeException(sprintf('Unable to boot [%s], configure an API domain or prefix.', 'Nodes\Api\ServiceProvider'));
        }
    }
119854
protected function bootPublishes()
    {
        $configPath = __DIR__ . '/../config';
        $this->mergeConfigFrom($configPath . '/config.php', 'graphql');
        $this->publishes([$configPath . '/config.php' => config_path('graphql.php')], 'config');
    }
1272585
protected function registerConfig()
    {
        $config = $this->config = app('PragmaRX\Tddd\Package\Services\Config');

        $this->app->singleton('tddd.config', function () use ($config) {
            return $config;
        });
    }
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;
    }
886764
public static function register()
    {
        \Deployer\set('release_path_app', function () { return ReleaseConfig::getReleasePathAppDir(); });
        \Deployer\set('shared_path_app', function () { return ReleaseConfig::getSharedPathAppDir(); });

        \Deployer\set('release_name', function () { return GetReleasesNameService::execute(); });
        \Deployer\set('releases_list', function () { return GetReleasesListService::execute(); });
    }
742040
private function registerPublishing()
    {
        if ($this->app->runningInConsole()) {
            $this->publishes([
                __DIR__.'/Storage/migrations' => database_path('migrations'),
            ], 'telescope-migrations');

            $this->publishes([
                __DIR__.'/../public' => public_path('vendor/telescope'),
            ], 'telescope-assets');

            $this->publishes([
                __DIR__.'/../config/telescope.php' => config_path('telescope.php'),
            ], 'telescope-config');

            $this->publishes([
                __DIR__.'/../stubs/TelescopeServiceProvider.stub' => app_path('Providers/TelescopeServiceProvider.php'),
            ], 'telescope-provider');
        }
    }
264718
protected function configure(): void
    {

        $this->register('makeType');
        $this->register('makeValue');
        $this->register('makeArgument');
        $this->register('makeStrong');
        $this->register('makeExceptionHeader');
        $this->register('makeExceptionBody');
        $this->register('makeExceptionTrace');
        $this->register('makeEmpty');
    }
1223911
protected function registerPublishes()
    {
        // Config
        $this->publishes(
            [
                __DIR__ . '/../../../config/config.php' => config_path('gzero.php'),
            ],
            'gzero-core config'
        );

        // Factories
        $this->publishes(
            [
                __DIR__ . '/../../../database/factories/UserFactory.php' => database_path('factories/gzero.php'),
            ],
            'gzero-core factories'
        );

        // Views
        $this->publishes(
            [
                __DIR__ . '/../../../resources/views' => resource_path('views/vendor/gzero-core'),
            ],
            'gzero-core views'
        );
    }
852714
private function registerConfigs()
    {
        foreach ($this->files as $config) {
            $params = array();

            if ($config['_params'] != null) {
                if (isset($this->app[$config['_params']])) {
                    $params = $this->app[$config['_params']];
                }
            }

            $this->app->register(new ConfigServiceProvider($config['file'], $params));
        }

        unset($this->app['_params']);
        unset($this->app['_priority']);
    }
165718
protected function registerConfigPublisher(): void
    {
        $this->app->singleton('config.publisher', function (Application $app) {
            $path = $app->configPath();

            // Once we have created the configuration publisher, we will set the default
            // package path on the object so that it knows where to find the packages
            // that are installed for the application and can move them to the app.
            $publisher = new Config($app->make('files'), $path);

            $publisher->setPackagePath($app->basePath().'/vendor');

            return $publisher;
        });
    }
1085809
private function registerPublishing()
    {
        if ($this->app->runningInConsole()) {
            // Lumen lacks a config_path() helper, so we use base_path()
            $this->publishes([
                __DIR__.'/../config/audit.php' => base_path('config/audit.php'),
            ], 'config');

            $this->publishes([
                __DIR__.'/../database/migrations/audits.stub' => database_path(
                    sprintf('migrations/%s_create_audits_table.php', date('Y_m_d_His'))
                ),
            ], 'migrations');
        }
    }
984246
protected function registerPublisher(): void
    {
        $this->app->singleton('orchestra.publisher', function (Application $app) {
            $memory = $app->make('orchestra.platform.memory');

            return (new PublisherManager($app))->attach($memory);
        });
    }
626022
public function register()
    {
        if (! defined('HORIZON_PATH')) {
            define('HORIZON_PATH', realpath(__DIR__.'/../'));
        }

        $this->configure();
        $this->offerPublishing();
        $this->registerServices();
        $this->registerCommands();
        $this->registerQueueConnectors();
    }