Overwrite if you need to replace or enhance the configuration.

@return array
559033
protected static function conf() {
		return [
			'given_names' => array
				(
					//// male

					// UK
					'Oliver', 'Jack', 'Harry', 'Alfie', 'Charlie', 'Thomas', 'William', 'Joshua', 'George', 'James',
					// France
					'Nathan', 'Lucas', 'Jules', 'Enzo', 'Gabriel', 'Louis', 'Arthur', 'Raphaël', 'Mathis', 'Ethan',
					// Germany
					'Ben', 'Leon', 'Lukas', 'Fynn', 'Jonas', 'Maximilian', 'Paul', 'Felix', 'Luka',
					// Italy
					'Francesco', 'Alessandro', 'Andrea', 'Lorenzo', 'Matteo', 'Mattia', 'Gabriele', 'Riccardo', 'Davide', 'Leonardo',

					//// female

					// UK
					'Olivia', 'Sophie', 'Emily', 'Lily', 'Amelia', 'Jessica', 'Ruby', 'Chloe', 'Grace', 'Evie',
					// France
					'Olivia', 'Sophie', 'Emily', 'Amelia', 'Jessica', 'Ruby', 'Chloe',
					// Germany
					'Mia', 'Emma', 'Hannah', 'Anna', 'Leah', 'Lina', 'Marie', 'Sophia', 'Lena',
					// Italy
					'Giulia', 'Sara', 'Martina', 'Giorgia', 'Chiara', 'Aurora', 'Alice', 'Emma', 'Alessia',
				),

			'family_names' => array
				(
					// Irish
					'Murphy', 'Kelly', 'O\'Sullivan', 'Breathnach', 'Mac Gabhann', 'Ó Briain', 'Ó Néill', 'Mac Cárthaigh', 'Lynch',
					// UK
					'Brown', 'Smith', 'Patel', 'Roberts', 'Khan', 'Cox', 'Davis', 'Clarke', 'Hall', 'Thompson', 'Jenkins', 'Griffiths', 'Morgan', 'Evans', 'Hughes',
					// France
					'Dubois', 'Durand', 'Bernard', 'Martin', 'Lefebvre', 'Leroy', 'Laurent', 'Lefèvre', 'André', 'Roux', 'Vincent', 'Fournier', 'Moreau',
					// Germany
					'Müller', 'Schmidt', 'Schneider', 'Fischer', 'Weber', 'Meyer', 'Schulz', 'Wagner', 'Becker', 'Hoffmann',
					// Italy
					'Rossi', 'Russo', 'Ferrari', 'Bianchi', 'Ricci', 'Bruno', 'Bruno', 'Rizzo', 'Moretti', 'Santoro',
				),

			'punctuation' => array
				(
					'.', '?', '.', '!', '.', ';'
				),

			'words' => array
				(
					'lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consectetur', 'adipiscing', 'elit', 'quisque', 'vitae', 'metus',
					'non', 'leo', 'rutrum', 'interdum', 'eget', 'tincidunt', 'erat', 'morbi', 'id', 'lorem', 'id', 'turpis',
					'blandit', 'gravida', 'et', 'vitae', 'neque', 'nam', 'pretium', 'tempus', 'mauris', 'in', 'porta', 'orci',
					'dictum', 'vitae', 'mauris', 'orci', 'tortor', 'aliquam', 'sit', 'amet', 'iaculis', 'ut', 'mattis', 'in',
					'augue', 'quisque', 'purus', 'nunc', 'egestas', 'quis', 'fringilla', 'ac', 'ornare', 'eget', 'est', 'vestibulum',
					'ante', 'ipsum', 'primis', 'in', 'faucibus', 'orci', 'luctus', 'et', 'ultrices', 'posuere', 'cubilia', 'curae',
					'mauris', 'leo', 'orci', 'pulvinar', 'sit', 'amet', 'imperdiet', 'vitae', 'laoreet', 'vel', 'augue', 'phasellus',
					'id', 'varius', 'nulla', 'nulla', 'vitae', 'magna', 'elit', 'vestibulum', 'vitae', 'ullamcorper', 'elit', 'sed',
					'eu', 'enim', 'sem', 'at', 'mattis'
				),

			'cities' => array
				(
					'New York', 'Los Angeles', 'Chicago', 'Houston', 'Philadelphia',
					'Phoenix', 'San Antonio', 'San Diego', 'Dallas', 'San Jose',
					'Jacksoville', 'Indianapolis', 'Austin', 'San Francisco',
					'Columbus', 'Fort Worth', 'Charlotte', 'Detroit', 'El Paso',
					'Memphis', 'Boston', 'Seattle', 'Denver', 'Baltimore',
					'Washington', 'Nashville', 'Louisville', 'Milwaukee',
					'Portland', 'Oklahoma City', 'Las Vegas', 'Albuquerque',
					'Tucson', 'Fresno', 'Sacramento', 'Long Beach', 'Kansas City',
					'Mesa', 'Virginia Beach', 'Atlanta', 'Colorado Springs',
					'Raleigh', 'Omaha', 'Miami', 'Tulsa', 'Oakland', 'Cleveland',
					'Minneapolis', 'Wichita', 'Arlington', 'New Orleans',
					'Bakersfield', 'Tampa', 'Anaheim', 'Honolulu', 'Aurora',
					'Santa Ana', 'St. Louis', 'Riverside',
				),
		];
	}
945362
private function setDummyReplacements()
    {
        $this->dummyReplacements = [
          'DefaultTitle' => $this->getAttribute('title'),
          'DefaultTheme' => $this->getAttribute('namespace'),
          'DefaultOrganisation' => $this->getAttribute('organisation'),
          'DefaultAuthor' => $this->getAttribute('authorName'),
          'DefaultEmail' => $this->getAttribute('authorEmail'),
        ];
        return $this;
    }
481827
public function applyConfigOverrides()
    {
        // init
        $config_items = [];

        foreach ($this->settings_default as $key => $value) {
            if (ee()->config->item($key)) {
                $config_items[$key] = ee()->config->item($key);
            }
        }

        if (is_array($this->settings)) {
            $this->settings = array_merge($this->settings, $config_items);
        }
    }
656789
private static function loadConfig()
    {
        $config = Config::get('placeholders');
        self::$longs = $config['longs'];
        self::$longModifiers = $config['longModifiers'];
        self::$placeholders = array();
        foreach ($config['placeholders'] as $placeholder) {
            self::$placeholders[$placeholder] = true;
        }
        self::$lModifiers = array();
        foreach ($config['modifiers'] as $modifier) {
            self::$lModifiers[$modifier] = false;
        }
        return true;
    }
353065
protected function setOverrides()
    {
        $config = $this->app['config']->get('cartalyst.sentinel');

        $users = $config['users']['model'];

        $roles = $config['roles']['model'];

        $persistences = $config['persistences']['model'];

        if (class_exists($users)) {
            if (method_exists($users, 'setRolesModel')) {
                forward_static_call_array([ $users, 'setRolesModel' ], [ $roles ]);
            }

            if (method_exists($users, 'setPersistencesModel')) {
                forward_static_call_array([ $users, 'setPersistencesModel' ], [ $persistences ]);
            }

            if (method_exists($users, 'setPermissionsClass')) {
                forward_static_call_array([ $users, 'setPermissionsClass' ], [ $config['permissions']['class'] ]);
            }
        }

        if (class_exists($roles) && method_exists($roles, 'setUsersModel')) {
            forward_static_call_array([ $roles, 'setUsersModel' ], [ $users ]);
        }

        if (class_exists($persistences) && method_exists($persistences, 'setUsersModel')) {
            forward_static_call_array([ $persistences, 'setUsersModel' ], [ $users ]);
        }
    }
834134
public function changes()
    {
        $changes = [];
        foreach ($this->changedAttributes as $attrName => $originalValue) {
            $changes[$attrName] = [$originalValue, $this->attributes->get($attrName)];
        }
        return $changes;
    }
966053
public function canWriteConfiguration()
    {
        $fileLocation = SettingsFiles::getOverrideSettingsFile();

        return @is_writable(file_exists($fileLocation) ? $fileLocation : Environment::getConfigPath() . '/');
    }
985803
public function getReplacements()
    {
        $replaces = [
            'extends' => $this->extends,
            'section' => $this->section,
            'content' => $this->content,
        ];

        return $this->customReplacements + $replaces;
    }
756697
private function patchRules()
    {
        $bundleDir = $this->bundle->getPath();
        $bundlePrefix = $this->getBundlePrefix();
        $fileName = $bundlePrefix . '.yml';
        $configurationFile = $bundleDir . '/Resources/config/app/' . $fileName;
        $resource = strtolower($this->model);

        $ref = <<<EOF
sylius_rbac:
    permissions:\n
EOF;

        if (!$this->refExist($configurationFile, $ref)) {
            $this->addError(sprintf('Cannot patch configuration file injection "%s"', $fileName));

            return false;
        }

        $rules = '        ' . $bundlePrefix . '.manage.' . $resource . ': Manage ' . $resource . "\n";
        foreach ($this->configuration['actions'] as $action) {
            $rules .= sprintf('        %s.%s.%s: %s %s', $bundlePrefix, $resource, $action, $action, $resource) . "\n";
        }

        $nodeDeclaration = <<<EOF
$rules
EOF;

        $this->dumpFile($configurationFile, $nodeDeclaration . "\n", $ref);

        $ref = <<<EOF
    permissions_hierarchy:\n
EOF;

        $rules = array();
        foreach ($this->configuration['actions'] as $action) {
            $rules[] = sprintf('%s.%s.%s', $bundlePrefix, $resource, $action);
        }

        $rules = implode(', ', $rules);
        $nodeDeclaration = <<<EOF
        $bundlePrefix.manage.$resource: [$rules]
EOF;

        $this->dumpFile($configurationFile, $nodeDeclaration . "\n", $ref);

        $ref = <<<EOF
    roles:\n
EOF;

        $nodeDeclaration = <<<EOF
        $resource:
            name: $this->model
            description: $this->model management
            permissions: [$bundlePrefix.manage.$resource]
            security_roles: [ROLE_ADMINISTRATION_ACCESS]
EOF;

        $this->dumpFile($configurationFile, $nodeDeclaration . "\n", $ref);

        $ref = <<<EOF
    roles_hierarchy:
        administrator: [
EOF;

        $nodeDeclaration = <<<EOF
$resource,
EOF;

        $this->dumpFile($configurationFile, $nodeDeclaration, $ref);
    }
1284767
protected function formatConfig()
    {
        return array_merge([
            'identifier' => $this->config['client_id'],
            'secret' => $this->config['client_secret'],
            'callback_uri' => $this->config['redirect'],
        ], $this->config);
    }
448977
protected function prepareModelOverrides()
    {
        $this->overrides = $this->getOverrideConfigForModel($this->moduleId);

        // determine name to use, handle pluralization and check database table override
        if (array_key_exists('name', $this->overrides)) {

            $name = $this->overrides['name'];

        } else {

            $name = array_get($this->module, 'prefixed_name') ?: $this->model['name'];

            if (config('pxlcms.generator.models.model_name.singularize_model_names')) {

                if ($this->context->dutchMode) {
                    $name = $this->dutchSingularize($name);
                } else {
                    $name = str_singular($name);
                }
            }
        }

        // make sure we force set a table name if it does not follow convention
        $tableOverride = null;

        if (str_plural($this->normalizeDb($name)) != $this->normalizeDb($this->module['name'])) {

            $tableOverride = $this->getModuleTablePrefix($this->moduleId)
                           . $this->normalizeDb($this->module['name']);
        }

        // force listified?
        $listified = array_key_exists('listify', $this->overrides)
                   ?    (bool) $this->overrides['listify']
                   :    $this->model['is_listified'];


        // override hidden attributes?
        $this->overrideHidden = [];

        if (    ! is_null(array_get($this->overrides, 'attributes.hidden'))
            &&  ! array_get($this->overrides, 'attributes.hidden-empty')
        ) {
            $this->overrideHidden = array_get($this->overrides, 'attributes.hidden');

            if ( ! is_array($this->overrideHidden)) $this->overrideHidden = [ (string) $this->overrideHidden ];
        }


        // apply overrides to model data
        $this->model['name']         = $name;
        $this->model['table']        = $tableOverride;
        $this->model['is_listified'] = $listified;
        $this->model['hidden']       = $this->overrideHidden;
        $this->model['casts']        = array_get($this->overrides, 'attributes.casts', []);
    }
1336445
public function getReplacements()
    {

        return array_merge(parent::getReplacements(), [
            'controller' => $this->getControllerName(),
            'plural'     => $this->getPluralName(),
            'singular'   => $this->getSingularName(),
            'validator'  => $this->getValidator(),
            'repository' => $this->getRepository(),
            'appname'    => $this->getAppNamespace(),
        ]);
    }
981824
public function getAvailableOverrides()
    {
        $path   = $this->getPath();
        $suffix = $this->getSuffix();

        $glob   = "{$path}/*{$suffix}";
        $result = [];
        foreach (glob($glob) as $file) {
            $identifier          = basename($file, $suffix);
            $result[$identifier] = $file;
        }

        return $result;
    }
1041741
public function getOverrides()
    {
        $result = [];
        if (isset($this->payload->body)) {
            foreach ($this->payload->body as $field) {
                if (isset($field->overridable) && true === $field->overridable) {
                    // Remove irrelevant data, since this result will need to be light-weight.
                    unset($field->default_value);
                    unset($field->test_value);
                    unset($field->test_only);
                    unset($field->overridable);
                    unset($field->required);
                    $result[(string) $field->key] = $field;
                }
            }
        }
        ksort($result);

        return array_values($result);
    }
1003733
public static function configMerge() {
        $result = array();
        $args = func_get_args();
        foreach ($args as $arg) {
            if (!is_array($arg)) {
                continue;
            }
            foreach ($arg as $key => $value) {
                if (is_numeric($key)) {
                    // Renumber numeric keys as array_merge() does.
                    $result[] = $value;
                } elseif (array_key_exists($key, $result) && is_array($result[$key]) && is_array($value)) {
                    // Recurse only when both values are arrays.
                    $result[$key] = ConfigServiceProvider::configMerge($result[$key], $value);
                } else {
                    // Otherwise, use the latter value.
                    $result[$key] = $value;
                }
            }
        }
        return $result;
    }
747305
protected function getKeysToWrite()
    {
        $keys = array_get($this->config, 'keys', ['*']);

        if (in_array('*', $keys)) {
            return $this->getWritableDefaultKeys();
        }

        return $keys;
    }
829564
public function merge_config()
    {
        $current      = $this->config;
        $this->config = array();

        foreach ($this->replaced_config as $prop => $replacement) {
            if (isset($current[$prop])) {
                if ($prop == 'skin_path') {
                    $this->config[$replacement] = preg_replace('#skins/(\w+)/?$#', '\\1', $current[$prop]);
                }
                else if ($prop == 'multiple_identities') {
                    $this->config[$replacement] = $current[$prop] ? 2 : 0;
                }
                else {
                    $this->config[$replacement] = $current[$prop];
                }
            }

            unset($current[$prop]);
        }

        foreach ($this->obsolete_config as $prop) {
            unset($current[$prop]);
        }

        // add all ldap_public sources having global_search enabled to autocomplete_addressbooks
        if (is_array($current['ldap_public'])) {
            foreach ($current['ldap_public'] as $key => $ldap_public) {
                if ($ldap_public['global_search']) {
                    $this->config['autocomplete_addressbooks'][] = $key;
                    unset($current['ldap_public'][$key]['global_search']);
                }
            }
        }

        $this->config = array_merge($this->config, $current);

        foreach (array_keys((array) $current['ldap_public']) as $key) {
            $this->config['ldap_public'][$key] = $current['ldap_public'][$key];
        }
    }