Configuration.
@return Void
357391
protected function _setup($config) {
        if (empty($config['column'])) {
            throw new Garp_Model_Behavior_Exception('"column" is a required parameter.');
        }
        $this->_column = $config['column'];

        if (empty($config['url'])) {
            throw new Garp_Model_Behavior_Exception('"url" is a required parameter.');
        }
        $this->_url = $config['url'];

        if (empty($config['targetColumn'])) {
            $config['targetColumn'] = self::COLUMN_NAME;
        }
        $this->_targetColumn = $config['targetColumn'];
    }
1073364
public function bootstrap()
    {
        if (!$this->booted) {
            $config = load($this->path.'/config/app.php');
            $this->name = $config['name'];

            date_default_timezone_set(isset($config['timezone']) ? $config['timezone'] : 'UTC');

            $this->add('config', new Config($config));
            $this->add('logger', new Logger($this->name));

            $this->registerExceptionHandler();
            $this->registerServicesProviders($config['services']);

            unset($config);
            $this->booted = true;
        }
    }
19507
protected function setupConfig()
    {
        $configPath = __DIR__.'/../config/apihelper.php';
        $this->publishes([$configPath => config_path('apihelper.php')], 'config');
        $this->mergeConfigFrom($configPath, 'apihelper');
    }
1326546
protected function initializeConfigs()
    {
        $this->mergeConfigFrom(static::getConfigPath(), static::getConfigRootKeyName());

        $this->publishes([
            realpath(static::getConfigPath()) => config_path(basename(static::getConfigPath())),
        ], 'config');
    }
1082034
function config()
    {
        if (!$this->configuration || !$this->configuration instanceof Entity)
            $this->configuration = new Entity();

        return $this->configuration;
    }
316342
protected function configure()
    {
        $this
            ->setName('detect')
            ->setDefinition(
                [
                    new InputArgument('path', InputArgument::OPTIONAL, 'path of the project', null),
                    new InputOption(
                        'config-file',
                        'c',
                        InputOption::VALUE_REQUIRED,
                        'File path of the configuration file'
                    ),
                    new InputOption(
                        'format',
                        'f',
                        InputOption::VALUE_REQUIRED,
                        sprintf('Output format (%s)', implode(', ', $this->formats)),
                        $this->formats[0]
                    ),
                ]
            )
            ->setDescription('Detect coupling rules')
            ->setHelp($this->loadHelpContent());
    }
1223688
protected function configureUser()
    {
        if (!$this->confirm('Do you want to create an admin user?')) {
            return;
        }

        // We need to refresh the config to get access to the newly connected database.
        $this->getFreshConfiguration();

        // Now we need to install the application.
        // $this->call('cachet:install');

        $user = [
            'username' => $this->ask('Please enter your username'),
            'email'    => $this->ask('Please enter your email'),
            'password' => $this->secret('Please enter your password'),
            'level'    => User::LEVEL_ADMIN,
        ];

        User::create($user);
    }
828398
public function set_config() {

		foreach ( $this->struct['config'] as $key => $setting ) {
			$this->attributes[ 'data-' . $key ] = $setting;
		}

	}
57636
public static function configure(){
        $args = func_get_args();
        $numArgs = func_num_args();

        switch ($numArgs) {
            case 1:{
                if (is_array($args[0])){
                    self::configureWithOptions($args[0]);
                } else {
                    self::configureWithDsnAndOptions($args[0]);
                }
                break;
            }
            case 2:{
                if (is_array($args[0])){
                    self::configureWithOptions($args[0], $args[1]);
                } else {
                    self::configureWithDsnAndOptions($args[0], $args[1]);
                }
                break;
            }
            case 3: {
                self::configureWithDsnAndOptions($args[0], $args[1], $args[2]);
                break;
            }
        }
    }
983144
public function init(?string $configuration = 'project'): void
    {
        $config = Core::i()->config->getConfiguration($configuration);
        if (isset($config['site_name'])) {
            $this->site_name = $config['site_name'];
        }
        if (isset($config['title_format'])) {
            $this->title_format = $config['title_format'];
        }
    }
424497
public function initializeConfigure()
    {
        $config = $this->container->singleton('kernel.config');

        $config->setVariable([
            'root.path' => $this->getRootPath(),
            'env'       => $this->getEnvironment(),
            'debug'     => $this->isDebug(),
            'version'   => AppKernel::VERSION,
        ]);

        $this->registerConfigurationVariable($config);

        if ($this->isDebug()) {
            $this->registerConfiguration($config);
            $debug = $this->getContainer()->singleton('kernel.debug');
            $debug->addConfig($debug->getBar(), $config);
            unset($debug);
        } else {
            $config->load($this->getRootPath() . '/config.cache');
        }
    }
1306170
private function init()
    {
        if(!isset($this->config)) {
            $this->config = Config::getInstance();
            $this->client = new Client(
                $this->generateClientConfiguration()
            );
        }
    }
1230490
protected function configure()
    {
        $this
            ->setName($this->getName())
            ->setDescription($this->getDescription())
            ->addOption(
                'storage',
                null,
                InputOption::VALUE_OPTIONAL,
                'Environment Location Storage',
                $this->getDefaultFileName()
            );
    }
171035
protected function configure()
    {
        $this->addArgument(
            'command-to-run',
            InputArgument::REQUIRED,
            'Command to run'
        );
        $this->addOption(
            'log',
            null,
            Option::VALUE_REQUIRED,
            'Log to file'
        );
        $this->addOption(
            'stage',
            null,
            Option::VALUE_REQUIRED,
            'Stage to deploy'
        );
        $this->addOption(
            'roles',
            null,
            Option::VALUE_REQUIRED,
            'Roles to deploy'
        );
        $this->addOption(
            'hosts',
            null,
            Option::VALUE_REQUIRED,
            'Host to deploy, comma separated, supports ranges [:]'
        );
    }
1266094
protected function configure()
    {
        $this->addArgument(
            'stage',
            InputArgument::OPTIONAL,
            'Stage or hostname'
        );
        $this->addOption(
            'parallel',
            'p',
            Option::VALUE_NONE,
            'Run tasks in parallel'
        );
        $this->addOption(
            'limit',
            'l',
            Option::VALUE_REQUIRED,
            'How many host to run in parallel?'
        );
        $this->addOption(
            'no-hooks',
            null,
            Option::VALUE_NONE,
            'Run task without after/before hooks'
        );
        $this->addOption(
            'log',
            null,
            Option::VALUE_REQUIRED,
            'Log to file'
        );
        $this->addOption(
            'roles',
            null,
            Option::VALUE_REQUIRED,
            'Roles to deploy'
        );
        $this->addOption(
            'hosts',
            null,
            Option::VALUE_REQUIRED,
            'Host to deploy, comma separated, supports ranges [:]'
        );
        $this->addOption(
            'option',
            'o',
            Option::VALUE_REQUIRED | Option::VALUE_IS_ARRAY,
            'Sets configuration option'
        );
    }
1097415
protected function setupConfig()
    {
        $path = realpath(__DIR__."/../../config/gravatar-helper.php");

        $this->publishes([$path => config_path("gravatar-helper.php")]);

        $this->mergeConfigFrom($path, 'gravatar-helper');
    }
998574
protected function loadConfiguration()
    {
        $configPath = __DIR__ . '/../config/onesky.php';

        $this->publishes([
            $configPath => config_path('onesky.php'),
        ], 'config');

        $this->mergeConfigFrom($configPath, 'onesky');
    }