Build configuration which we need later into $this->configuration
332324
protected function buildConfiguration()
    {
        $versionAndProjectName = sprintf('%s-%s', str_replace(' ', '_', $this->getOption('projectName')), $this->getOption('version'));
        $this->configuration['versionAndProjectName'] = $versionAndProjectName;

        $this->configuration['zipFile'] = $this->getDeploymentPath() . '/buildArtifacts/' . $versionAndProjectName . '.zip';
        $this->configuration['tarGzFile'] = $this->getDeploymentPath() . '/buildArtifacts/' . $versionAndProjectName . '.tar.gz';
        $this->configuration['tarBz2File'] = $this->getDeploymentPath() . '/buildArtifacts/' . $versionAndProjectName . '.tar.bz2';
    }
1295526
protected function setupConfig()
    {
        $source = realpath(__DIR__ . '/../config/rancher.php');
        if ( class_exists('Illuminate\Foundation\Application', false) )
        {
            $this->publishes([ $source => config_path('rancher.php') ], 'config');
        }
        $this->mergeConfigFrom($source, 'rancher');
    }
1259651
public static function build () {
		//Loop through all sections remaining
		while (count(Router::$sections) > 0) {
			//Get and remove
			$section  = array_shift(Router::$sections);

			//Get options from section
			$name	  = $section[0];
			$options  = $section[1];
			$callback = $section[2];
			$context  = $section[3];

			//Set everything accordling
			Router::$context 		= $context."/".(($context == "root")? "":$name);
			Router::$stackedOptions = $options;

			//Run to search more
			$callback();
		}

		//Sort everything based on key
		ksort(Router::$routes);
	}
1115508
public function configureApplication()
    {
        $config = file_get_contents($this->paths['app'].'/config/config.yml');
        $config = $this->parser->parse($config);

        $this->project_name     = $config['application']['project_name'];
        $this->routeCollection  = $this->bindRouteCollection($this->project_name);

        $this->addDbParams($config['database']['default'], $config['database']['types']);
        $this->createBaseEm($config['application']['environment']);
    }
581239
protected function initConfig(): void
    {
        $configFile = $this->getRootRelatedPath($this->getConfigFileName());

        $this->assertFileIsReadable($configFile);

        self::$config = (array)(include $configFile);
    }
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;
            }
        }
    }
1313105
private function initialize()
    {
        $params = $this->getParameters();

        if ($params) {
            foreach ($params as $param) {
                $setter = 'set' . str_replace(' ', '', ucwords(str_replace('-', ' ', $param->getName())));
                if (FALSE === method_exists($this, $setter)) {
                    $msg = sprintf('Unknown parameter "%s" for LocalConfigurationFilter!', $param->getName());
                    throw new BuildException($msg);
                }

                call_user_func(array($this, $setter), $param->getValue());
            }
        }

        if (NULL === $this->installTool) {
            $this->addInstallTool();
        }
    }
955001
private function callConfiguration() {
		$container = Container::getInstance();
		$className = $this->getConfig('namespace', self::CONF_PROJECT) . 'Configuration';
		if ($container->has($className)) {
			$clazz = $container->get($className);
			$methods = (new ReflectionClass($clazz))->getMethods();
			foreach ($methods as $method) {
				if (strpos($method->name, 'set') !== 0) {
					continue;
				}
				$params = $method->getParameters();
				$init_params = [];
				foreach ($params as $param) {
					$type = $param->getType();
					if (class_exists('ReflectionNamedType') && $type instanceof \ReflectionNamedType) {
						$typeName = $type->getName();
					} else {
						$typeName = $type->__toString();
					}
					if ($type->isBuiltin()) {
						$value = null;
						settype($value, $typeName);
						$init_params[] = $value;
					} else {
						$init_params[] = $container->get($typeName);
					}
				}
				$method->invokeArgs($clazz, $init_params);
			}
		}
	}
390762
static private function bootstrap()
    {
        if (self::$expressions === null) {
            $configuration = new Configuration();
            $parameters = $configuration->getConfig();
            self::$expressions = $configuration->setUp($parameters);
        }
    }
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());
    }
196785
public function build()
    {
        if ($this->container->hasDefinition($this->definitionName())) {
            $this->container->getDefinition(
                $this->definitionName()
            )->replaceArgument(0, array_unique($this->configuration, SORT_REGULAR));
        }
        if ($this->container->hasDefinition($this->definitionApiName())) {
            foreach ($this->configuration as $key => $config) {
                $this->configuration[$key]['enabled'] = $config['api_enabled'];

                if (array_key_exists('type', $config)) {
                    $this->configuration[$key]['type'] = $config['api_type'];
                }
            }

            $this->container->getDefinition(
                $this->definitionApiName()
            )->replaceArgument(0, array_unique($this->configuration, SORT_REGULAR));
        }

        return $this->container;
    }
1164988
private function copyConfig()
    {
        // copy config
        $this->filesystem->copy($this->basePath . "config/config.php", config_path('titan.php'));
        $this->line("Config Copied: " . config_path('titan.php'));
    }
228107
protected function initConfiguration()
    {
        $tsfe = self::getTsfe();

        // Get configuration
        if (!empty($tsfe->tmpl->setup['plugin.']['metaseo.'])) {
            $this->conf = $tsfe->tmpl->setup['plugin.']['metaseo.'];
        }

        // Store blacklist configuration
        if (!empty($this->conf['sitemap.']['index.']['blacklist.'])) {
            $this->blacklistConf = $this->conf['sitemap.']['index.']['blacklist.'];
        }

        // Store blacklist configuration
        if (!empty($this->conf['sitemap.']['index.']['fileExtension.'])) {
            # File extensions can be a comma separated list
            foreach ($this->conf['sitemap.']['index.']['fileExtension.'] as $fileExtListRaw) {
                $fileExtList       = Typo3GeneralUtility::trimExplode(',', $fileExtListRaw);
                $this->fileExtList = array_merge($this->fileExtList, $fileExtList);
            };
        }

        // Get expiration
        $expirationInDays = 60;
        if (!empty($this->conf['sitemap.']['expiration'])) {
            $expirationInDays = abs($this->conf['sitemap.']['expiration']);
        }

        $this->indexExpiration = $_SERVER['REQUEST_TIME'] + ($expirationInDays * 24 * 60 * 60);

        // Init blacklist for doktype (from table pages)
        $this->doktypeBlacklist = SitemapUtility::getDoktypeBlacklist();

        // Init blacklist for PAGE typenum
        $this->pageTypeBlacklist = SitemapUtility::getPageTypeBlacklist();
    }
420342
protected function configure()
    {
        $this->setName('phpjunitmerge')
            ->setDefinition(
                array(
                    new InputArgument(
                        'dir',
                        InputArgument::REQUIRED,
                        'Directory where all files ready to get merged are stored'
                    ),
                    new InputArgument(
                        'file',
                        InputArgument::REQUIRED,
                        'The target file in which the merged result should be written'
                    )
                )
            )
            ->addOption(
                'names',
                null,
                InputOption::VALUE_REQUIRED,
                'A comma-separated list of file names to check',
                '*.xml'
            )
            ->addOption(
                'ignore',
                null,
                InputOption::VALUE_REQUIRED,
                'A comma-separated list of file names to ignore',
                'result.xml'
            )
			->addOption(
				'no-suffix',
				null,
				InputOption::VALUE_NONE,
				'Do not add suffix for test suites with duplicate names',
				null
			);
    }
251050
protected function beforeInit()
	{
	    // load default config
	    Config::setDefault(DefaultConfig::common());
	    
	    // load common config: /common/config/config.php
	    Config::load('config');
	    
	    // autoload common class: /common/src/...
	    $ns = Config::getCommon('commonNamespace', 'Common');
	    $ns = trim($ns, '\\') . '\\';
	    Ioc::loader()->setPsr4($ns, Config::getCommonPath() . 'src');
	    
	    // init namespaces: load or init
	    Ioc::initNamespace();
	}
961626
public function beforeCompile(): void
	{
		$builder = $this->getContainerBuilder();

		// Register console helper only if console is provided
		$application = $builder->getByType(Application::class, false);

		if ($application !== null) {
			$applicationDef = $builder->getDefinition($application);
			$applicationDef->addSetup(
				new Statement('$service->getHelperSet()->set(?)', [$this->prefix('@configurationHelper')])
			);
		}
	}
565494
protected function include_configuration() {
        $configuration = array();
        // We need to allow for late static bindings to allow for class path mudling happending for unit tests.
        $cachefile = static::get_config_file_path();

        if (!file_exists($cachefile)) {
            throw new cache_exception('Default cache config could not be found. It should have already been created by now.');
        }

        if (!include($cachefile)) {
            throw new cache_exception('Unable to load the cache configuration file');
        }

        if (!is_array($configuration)) {
            throw new cache_exception('Invalid cache configuration file');
        }
        if (!array_key_exists('stores', $configuration) || !is_array($configuration['stores'])) {
            $configuration['stores'] = array();
        }
        if (!array_key_exists('modemappings', $configuration) || !is_array($configuration['modemappings'])) {
            $configuration['modemappings'] = array();
        }
        if (!array_key_exists('definitions', $configuration) || !is_array($configuration['definitions'])) {
            $configuration['definitions'] = array();
        }
        if (!array_key_exists('definitionmappings', $configuration) || !is_array($configuration['definitionmappings'])) {
            $configuration['definitionmappings'] = array();
        }
        if (!array_key_exists('locks', $configuration) || !is_array($configuration['locks'])) {
            $configuration['locks'] = array();
        }

        return $configuration;
    }