Creates the config parts of the specified section

@param Config $config
@param $section
@return string
353454
protected function getSectionConfig(Config $config, $section)
    {
        $string = '';
        if (isset($config[$section])) {
            /** @var Config $config */
            $config = $config[$section];
            // If there is at least one section
            if ($config->count() > 0) {
                /** @var Config $values */
                foreach ($config as $name => $values) {
                    if ($values->count() > 0) {
                        $string .= $this->sections[$section] . ' ' . $name . PHP_EOL . '{' . PHP_EOL . "\t";
                        $string .= $this->getValuesString($values->toArray());
                        $string .= PHP_EOL . '}' . PHP_EOL;
                    }
                }
            }
        }
        return $string;
    }
804204
protected function getSectionStructureFromIncomingStructure($section)
    {
        $pos = strpos($section, '.');
        if ($pos === false) {
            $section = (int) $section;
            if ($section === 0) {
                return $this->structure;
            }

            return $this->structure->parts[($section - 1)];
        }
        $sections = explode('.', $section);
        $count = count($sections);
        $outObject = null;
        foreach ($sections as $section) {
            $section = (int) $section;
            if (!isset($outObject)) {
                $outObject = $this->getObjectStructureFromParts($this->structure, ($section - 1));
            } else {
                $outObject = $this->getObjectStructureFromParts($outObject, ($section - 1));
            }
        }

        return $outObject;
    }
913987
public function getConfig($section)
    {
        if (!isset($this->_sections[$section])) {
            $this->_sections[$section] = $this->di->getConfig($section, $this->di->environment(), []);
        }

        return $this->_sections[$section];
    }
1041946
public function config($config)
    {
        if (is_array($config)) {
            $this->config = array_merge($this->config, $config);
        } elseif (isset($this->config[$config])) {
            return $this->config[$config];
        } else {
            return;
        }
    }
148706
def get_config(self, section=None):
        
        config = self.session.config
        section = self.config_section() if section is None else section
        try:
            return config[section]
        except KeyError:
            config.add_section(section)
            return config[section]
1062281
protected function concat(string $section, string $key)
    {
        if ($section === '') {
            return $key;
        }
        if ($key === '') {
            return $section;
        }
        return $section . $this->sectionKeyDelimiter . $key;
    }
1276425
private function getPrefix(Config $config)
    {
        $parts = explode(':', $config->getPrefix());
        array_shift($parts);

        return strtolower(str_replace(array('/', '\\'), '_', implode('_', $parts)));
    }
156273
public function setSection($section, array $config, $overwrite = false)
    {
        if (false === $overwrite && array_key_exists($section, $this->raw_parameters)) {
            $this->raw_parameters[$section] = Collection::array_merge_assoc_recursive($this->raw_parameters[$section], $config);
        } else {
            $this->raw_parameters[$section] = $config;
        }

        if (array_key_exists($section, $this->parameters)) {
            unset($this->parameters[$section]);
        }

        return $this;
    }
612855
public function parseSections(array $sections, Configuration $configuration = null)
    {
        if (is_null($configuration)) {
            $configuration = new Configuration();
        }

        foreach ($sections as $sectionName => $section) {
            $name = explode(':', $sectionName, 2);

            $class = $configuration->findSection($name[0]);

            if (false === $class) {
                $class = 'Supervisor\Configuration\Section\GenericSection';
                $name[1] = $sectionName;
            }

            if (isset($name[1])) {
                $section = new $class($name[1], $section);
            } else {
                $section = new $class($section);
            }

            $configuration->addSection($section);
        }

        return $configuration;
    }
41191
def add_section(self, section):
        
        # check if section already exists
        if not self.config.has_section(section):
            self.config.add_section(section)
            # return updated sections
            return (True, self.config.sections())
        return (False, 'Section: ' + section + ' already exists')
1247233
private function parseConfig(\DOMDocument $config) {

		try {

			// determine server context, missing SERVER_ADDR assumes localhost/CLI

			$this->isLocalhost = !isset($_SERVER['SERVER_ADDR']) || !!preg_match('/^(?:127|192|1|0)(?:\.\d{1,3}){3}$/', $_SERVER['SERVER_ADDR']);

			$rootNode = $config->firstChild;

			// allow parsing of specific sections

			foreach($rootNode->childNodes as $section) {

				if($section->nodeType !== XML_ELEMENT_NODE) {

					continue;

				}

				$sectionName = $section->nodeName;

				if(empty($this->sections) || in_array($sectionName, $this->sections)) {

					$methodName =
						'parse' .
						ucfirst(preg_replace_callback('/_([a-z])/', function($match) { return strtoupper($match[1]); }, $sectionName)) .
						'Settings'
					;

					if(method_exists($this, $methodName)) {

						call_user_func([$this, $methodName], $section);

					}
				}

			}
		}

		catch(ConfigException $e) {

			throw $e;

		}

	}
443252
public function getMultiple(string $section, $keys, $default = null)
    {
        $sctnd = [];
        foreach ($keys as $key) {
            $sctnd[] = $this->concat($section, $key);
        }
        return $this->config->getMultiple($sctnd, $default);
    }
821797
public function append($section, array $config)
    {
        $config = array_merge([
            'config' => null,
            'view' => null,
            'script' => null,
            'menu' => null,
            'style' => null,
            'form' => null,
            'meta' => null,
            'position' => 0
        ], $config);

        if($html = $this->renderByType($config)){

            $this->inject($section, $html);

        }
    }
569513
public function createCRUD($config, $section, $table, $splitTable)
    {
        $bar = $this->output->createProgressBar(7);

        try {
            $this->crudService->generateCore($config, $bar);
            $this->crudService->generateAppBased($config, $bar);

            $this->crudGenerator->createTests(
                $config,
                $this->option('serviceOnly'),
                $this->option('apiOnly'),
                $this->option('api')
            );
            $bar->advance();

            $this->crudGenerator->createFactory($config);
            $bar->advance();

            $this->crudService->generateAPI($config, $bar);
            $bar->advance();

            $this->crudService->generateDB($config, $bar, $section, $table, $splitTable, $this);
            $bar->finish();

            $this->crudReport($table);
        } catch (Exception $e) {
            throw new Exception('Unable to generate your CRUD: ('.$e->getFile().':'.$e->getLine().') '.$e->getMessage(), 1);
        }
    }
969050
public function get($section, $key, $default = null)
    {
        $items = $this->getSettingsConfig();

        if (isset($items[$section][$key])) {
            $this->setting = ArrayHelper::getValue($items[$section][$key], 'value');
            $type = ArrayHelper::getValue($items[$section][$key], 'type');
            $this->convertSettingType($type);
        } else {
            $this->setting = $default;
        }

        return $this->setting;
    }
474585
public function getConfiguration($name, $section = null)
    {
        $configValue = null;

        if ($section === null) {
            if (array_key_exists($name, $this->config)) {
                $configValue = $this->config[$name];
            }
        } else {
            if (array_key_exists($section, $this->config)) {
                $sectionSettings = $this->config[$section];
                if (array_key_exists($name, $sectionSettings)) {
                    $configValue = $sectionSettings[$name];
                }
            }
        }

        return $configValue;
    }
563414
public static function configure($config)
    {
        if (is_null(static::$instance)) {
            static::$instance = new self();

            static::$name = $config['default'];

            static::$config = $config;
        }

        return static::$instance;
    }