more likely, strategy should be part of configuration options directly when Config object is created!
503079
def configure_relation
      case strategy
      when :ref_many      
        has_many_for subject_class, :role, :through => join_key 
        
        belongs_to_for join_model, subject_class
        belongs_to_for join_model, object_model

        has_many_for role, subject_class, :through => join_key 
        
      when :embed_many
        embeds_many subject_class, object_model
      end
    end
1348700
def configure(**kwargs):
        """"""
        for key in kwargs:
            if key == 'is_logging_enabled':
                Event.is_logging_enabled = kwargs[key]
            elif key == 'collector_queue':
                Event.collector_queue = kwargs[key]
            else:
                Logger.get_logger(__name__).error("Unknown key %s in configure or bad type %s",
                                                  key, type(kwargs[key]))
375664
function checkConfig (config) {
    if (config) {
        if (!util.isObject(config)) {
            throw new CartoValidationError('\'config\' property must be an object.', CartoValidationErrorTypes.INCORRECT_TYPE);
        }
        _checkServerURL(config.serverURL);
    }
}
89882
def configure(ctx, helper, edit):
    '''
    
    '''

    ctx.obj.config = ConfigFile(ctx.obj.config_file)

    if edit:
        ctx.obj.config.edit_config_file()
        return

    if os.path.isfile(ctx.obj.config.config_file):
        ctx.obj.config.read_config()

    if ctx.obj.profile is None:
        ctx.obj.profile = ctx.obj.config.default_profile

    args, kwargs = _parse_args_and_kwargs(ctx.args)
    assert len(args) == 0, 'Unrecognized arguments: "{}"'.format(args)

    if ctx.obj.profile not in ctx.obj.config.config['profiles']:
        ctx.obj.config.config['profiles'][ctx.obj.profile] = {
            'api': {'user_config': {}}, 'manager': {}, 'authorities': {}}

    profile_config = ctx.obj.config.config['profiles'][ctx.obj.profile]
    profile_config['api']['user_config'].update(kwargs)

    ctx.obj.config.write_config(ctx.obj.config_file)

    _generate_api(ctx)

    if ctx.obj.api.manager is not None:
        check_requirements(
            to_populate=profile_config['api']['user_config'],
            prompts=ctx.obj.api.manager.required_user_config,
            helper=helper)

    ctx.obj.config.write_config(ctx.obj.config_file)
16788
function (config) {
    config = config || {};
    Appender.call(this, config);

    /**
     * True to log strings instead of objects
     */
    this.appendStrings = (typeof config.appendStrings !== 'undefined') ?
      config.appendStrings :
      true;
  }
1045727
def config(host, seq, option, value):
    """"""
    at(host, 'CONFIG', seq, [str(option), str(value)])
8660
private void includeConfigurationInternal(final Configuration conf) {

		if (conf == null) {
			LOG.error("Given configuration object is null, ignoring it...");
			return;
		}

		synchronized (this.confData) {

			final Iterator<String> it = conf.keySet().iterator();

			while (it.hasNext()) {

				final String key = it.next();
				this.confData.put(key, conf.getString(key, ""));
			}
		}
	}
747758
function createPersistConfig(persist, name) {
    switch (typeof persist === 'undefined' ? 'undefined' : _typeof(persist)) {
        case 'boolean':
            if (persist) {
                persist = {
                    key: name,
                    storage: _storage2.default
                };
            }

            break;
        case 'object':
            persist = _extends({
                storage: _storage2.default
            }, persist, {
                key: name
            });

            break;
    }

    return persist;
}
1351522
function strategy (options, verify) {

  // some sensible defaults
  options.protocol = options.protocol || 'https://';
  options.signatureAlgorithm = options.signatureAlgorithm || 'sha256';
  options.identifierFormat = options.identifierFormat || 'urn:oasis:names:tc:SAML:2.0:nameid-format:transient';
  options.acceptedClockSkewMs = options.acceptedClockSkewMs || 60000;
  options.attributeConsumingServiceIndex = options.attributeConsumingServiceIndex || false;
  options.forceAuthn = options.forceAuthn || false;
  options.skipRequestCompression = options.skipRequestCompression || false;

  if (options.disableRequestedAuthnContext === undefined) {
    options.disableRequestedAuthnContext = true;
  }

  if (options.validatedInResponseTo === undefined) {
    options.validateInResponseTo = true;
  }

  if (options.decryptionCertPath) {
    options.decryptionCert = fs.readFileSync(options.decryptionCertPath, 'utf8');
  }

  if (options.decryptionPvkPath) {
    options.decryptionPvk = fs.readFileSync(options.decryptionPvkPath, 'utf8');
  }

  if (options.entityID) {
    options.issuer = options.entityID;
  }

  if (options.entityId) {
    options.issuer = options.entityId;
  }

  if (options.idp) {
    if (idps[options.idp]) {
      options.entryPoint = idps[options.idp].entryPoint;
      options.cert = idps[options.idp].cert;
    } else {
      throw new Error('Unknown IdP: ' + options.idp);
    }
  }

  if (!options.entryPoint || !options.cert) {
    console.warn('No IdP defined - defaulting to ' + idps.dev.entityID);
    options.entryPoint = idps.dev.entryPoint;
    options.cert = idps.dev.cert;
  }

  if (!options.issuer) {
    throw new Error('No entityId defined!');
  }

  // having either both an encryption cert and private key is valid
  // having neither an encryption cert nor a private key is also valid
  // having only one or the other is NOT valid
  if (!options.decryptionCert && options.decryptionPvk) {
    throw new Error('Only a private key was defined; a public cert is also required');
  }

  if (options.decryptionCert && !options.decryptionPvk) {
    throw new Error('Only a public cert was defined; a private key is also required')
  }

  if (!options.loginPath) {
    throw new Error('No loginPath defined!');
  }

  this.loginPath = options.loginPath;

  // set up an attribute mapper
  this.attributeMapper = attrmap(options.attributeMap);

  // call the parent method before setting the strategy name,
  // otherwise the name will always be 'saml'
  saml.Strategy.call(this, options, function (req, profile, done) {
    req.session.strategy = this.name;
    this.attributeMapper(profile, done);
  }.bind(this));

  // set the name of this strategy to either the name passed in
  // via the options, or the short name of the idp.
  //
  // if neither is set, the name will be 'suSAML'

  this.name = options.name || options.idp || 'suSAML';

}
235296
public function onConfigUpdated()
    {
        if ($this->client) {
            $this->client->config = $this->config;
            $this->client->onConfigUpdated();
        }
    }
1251298
function initConfig(conf) {
  const result = Object.assign({}, conf);
  if (conf.filename) {
    result.filepath = path.dirname(conf.filename);
  }
  return result;
}
39982
def setup(self, **kwargs):
        

        for key in kwargs:
            if key not in self.config.keys():
                raise error.GrabMisuseError('Unknown option: %s' % key)

        if 'url' in kwargs:
            if self.config.get('url'):
                kwargs['url'] = self.make_url_absolute(kwargs['url'])
        self.config.update(kwargs)
758081
def init_config(options={})
      options = options.to_symbol_keys

      if !options[:method]
        abort "Please provide a deployment method. e.g. #{METHODS.keys}"
      end

      @options = DEFAULT_OPTIONS.deep_merge(options)
      write_config
      check_gitignore
    end
1180941
function config(options) {
    var current = config.current
    Object.assign(current, options)
    api._init(current)
}
472481
function Strategy(options, verify) {
  ['domain',
    'clientID',
    'clientSecret',
    'callbackURL'].forEach(function (k) {
    if(!options[k]){
      throw new Error('You must provide the ' + k + ' configuration value to use passport-auth0.');
    }
  });


  this.options = xtend({}, options, {
    authorizationURL: 'https://' + options.domain + '/authorize',
    tokenURL:         'https://' + options.domain + '/oauth/token',
    userInfoURL:      'https://' + options.domain + '/userinfo',
    apiUrl:           'https://' + options.domain + '/api'
  });

  if (this.options.state === undefined) {
    this.options.state = true;
  }

  this._base = Object.getPrototypeOf(Strategy.prototype);
  this._base.constructor.call(this, this.options, verify);

  this.name = 'auth0';
}
443285
function checkConfiguration(conf) {
    let failedChecks = 0;

    for (const path of Object.keys(CHECKS)) {
        // @todo avoid try..catch
        try {
            checkProperty(path, get(conf, path), CHECKS[path]);
        } catch (error) {
            LusterConfigurationError.ensureError(error).log();
            ++failedChecks;
        }
    }

    return failedChecks;
}
798356
function Strategy(transports, options) {
  var strategy = this;

  if (!(strategy instanceof Strategy)) return new Strategy(transports, options);
  if (Object.prototype.toString.call(transports) !== '[object Array]') {
    options = transports;
    transports = [];
  }

  strategy.transports = [];     // List of active transports.
  strategy.transport = 0;       // Current selected transport id.
  strategy.length = 0;          // Amount of transports available.
  strategy.id = 0;              // ID generation pool.

  for (var i = 0; i < transports.length; i++) {
    strategy.push(transports[i]);
  }
}