Allow for config overrides, via an elixirConfig.js file.
15229
function overrideConfig() {
    _.merge(Elixir.config, require(path.join(process.cwd(), 'elixirConfig.js')));
}
987326
def apply_config_defaults(parser, args, root):
    """"""
    if root is None:
        try:
            from pep8radius.vcs import VersionControl
            root = VersionControl.which().root_dir()
        except NotImplementedError:
            pass  # don't update local, could be using as module

    config = SafeConfigParser()
    config.read(args.global_config)
    if root and not args.ignore_local_config:
        config.read(local_config_files(root))

    try:
        defaults = dict((k.lstrip('-').replace('-', '_'), v)
                        for k, v in config.items("pep8"))
        parser.set_defaults(**defaults)
    except NoSectionError:
        pass  # just do nothing, potentially this could raise ?
    return parser
31856
def custom_conf(self, conf):
        ''''''
        if conf:
            for (key, val) in conf.items():
                self.__conf[key] = val
        return self
967948
def _override_cfg(container, yamlkeys, value):
    

    key = yamlkeys[0]
    rest = yamlkeys[1:]

    if len(rest) == 0:
        # no rest means we found the key to update.
        container[key] = value

    elif key in container:
        # still need to find the leaf in the tree, so recurse.
        _override_cfg(container[key], rest, value)

    else:
        # need to create a sub-tree down to the leaf to insert into.
        subtree = {}
        _override_cfg(subtree, rest, value)
        container[key] = subtree
271879
def override_secure(env, config = {})
      if scheme(env) != "https" && config != OPT_OUT
        config[:secure] = OPT_OUT
      end

      config
    end
295526
function applyConfig(config) {
    var previous = {};

    config.rules.forEach(function (rule) {
        var isprev = (rule.value === '$previous');
        var setOption = function (name, value) {
            previous[name] = this.current[name];
            this.current[name] = this.setOption(name, value, isprev);
        }.bind(this);
        if (rule.type === 'rule') {
            setOption(rule.name, isprev ? this.previous[rule.name]
                                        : rule.value);
        /* istanbul ignore else */
        } else if (rule.type === 'preset') {
            var preset = isprev ? this.previousPreset
                                : presets.presets[rule.value];
            Object.keys(preset).forEach(function (name) {
                setOption(name, preset[name]);
            });
        }
    }.bind(this));

    lodash.merge(this.previous, this.previousPreset = previous);
}
730415
def validate_config(raise_=True):
    
    ELIBConfig.check()
    known_paths = set()
    duplicate_values = set()
    missing_values = set()
    for config_value in ConfigValue.config_values:
        if config_value.path not in known_paths:
            known_paths.add(config_value.path)
        else:
            duplicate_values.add(config_value.name)
        try:
            config_value()
        except MissingValueError:
            missing_values.add(config_value.name)

    if raise_ and duplicate_values:
        raise DuplicateConfigValueError(str(duplicate_values))
    if raise_ and missing_values:
        raise MissingValueError(str(missing_values), 'missing config value(s)')
    return duplicate_values, missing_values
265110
def override_stage_config_setting(self, key, val):
        
        self._stage_config_overrides = getattr(self, '_stage_config_overrides', {})
        self._stage_config_overrides.setdefault(self.api_stage, {})[key] = val
1064142
function overrideJest({ plugin, options }, cracoConfig, jestConfig, context) {
    if (isFunction(plugin.overrideJestConfig)) {
        const resultingConfig = plugin.overrideJestConfig({
            cracoConfig: cracoConfig,
            jestConfig: jestConfig,
            pluginOptions: options,
            context: context
        });

        if (!resultingConfig) {
            throw new Error("craco: Plugin returned an undefined Jest config.");
        }
    }

    log("Overrided Jest config with plugin.");

    return jestConfig;
}
243200
def override(self, key, value):
        
        keys = key.split('.')
        if len(keys) > 1:
            if keys[0] != "plugins":
                raise AttributeError("no such setting: %r" % key)
            self.plugins.override(keys[1:], value)
        else:
            self.overrides[key] = value
            self._uncache(key)
1045727
def config(host, seq, option, value):
    """"""
    at(host, 'CONFIG', seq, [str(option), str(value)])
1032229
def configure(self):
        """"""
        if self.debug is not None and not self.debug:
            self._remove_debug_handlers()
        self._remove_debug_only()
        logging.config.dictConfig(self.config)
        try:
            logging.captureWarnings(True)
        except AttributeError:
            pass
885891
def override_spec(cls, **kwargs):
        """"""
        cls._default_spec.set(**kwargs)
        cls.spec.set(**kwargs)
1039955
def apply_defaults(self, other_config):
        
        if isinstance(other_config, self.__class__):
            self.config.load_from_dict(other_config.config, overwrite=False)
        else:
            self.config.load_from_dict(other_config, overwrite=False)
661770
function(suppliedConfig) {
    // Handle config and defaults
    try {
      config.parseAndUpdate(suppliedConfig);
    } catch (e) {
      render.triggerError(e);
      return this
    }

    utils.logDebug(['Final config:', getConfig()]);

    try {
      return startRender();
    } catch (e) {
      render.triggerError(e);
      return this
    }
  }
1047912
def _handle_config(self, data):
        """"""

        self.room.config.update(data)
        self.conn.enqueue_data("config", data)
253394
def config_files(override)
      # Adjust verbosity quickly
      Bunto.logger.adjust_verbosity(
        :quiet   => quiet?(override),
        :verbose => verbose?(override)
      )

      # Get configuration from <source>/_config.yml or <source>/<config_file>
      config_files = override.delete("config")
      if config_files.to_s.empty?
        default = %w(yml yaml).find(-> { "yml" }) do |ext|
          File.exist?(Bunto.sanitized_path(source(override), "_config.#{ext}"))
        end
        config_files = Bunto.sanitized_path(source(override), "_config.#{default}")
        @default_config_file = true
      end
      config_files = [config_files] unless config_files.is_a? Array
      config_files
    end