returns an option_collection_hash given a list of options
430528
def calculate_hash(options):
        """"""
        options = sorted(list(options))
        sha_hash = sha1()
        # equivalent to loop over the options and call sha_hash.update()
        sha_hash.update(''.join(options).encode('utf-8'))
        return sha_hash.hexdigest()
278336
def to_hash
      OPTIONS.inject({}) do |hash, option|
        hash.merge(option.to_sym => send(option))
      end
    end
104428
def options
      opts    = fetch('options', {})
      headers = fetch('headers', {})
      if value = accept
        headers[:accept] = value
      end
      opts[:raw]     = key?('raw') ? self['raw'] : false
      opts[:headers] = headers unless headers.empty?
      opts
    end
1162413
function generateHashForOptions (options) {
  var hash = crypto.createHash('md5');
  hash.update(JSON.stringify(options));
  return hash.digest('hex');
}
1352123
def options
      VALID_OPTIONS_KEYS.reduce({}) do |option, key|
        option.merge!(key => send(key))
      end
    end
1154219
def options
      map = Config.class_variables.map do |key|
        [key.to_s.tr('@', '').to_sym, class_variable_get(:"#{key}")]
      end
      Hash[map]
    end
1119600
def _get_option_list(options):
    '''
    
    '''
    return ', '.join(['{0}={1}'.format(x, y) for x, y in six.iteritems(options)])
382678
function getOption(opts, key, def) {
  var value = opts[key];
  return value === undefined ? def : value;
}
138006
def _optlist(self):
    """"""
    res = ""
    for o in self.options:
        res += o.short
        if o.argName is not None:
          res += ":"
    return res
731126
def options
      options_storage.each_with_object({}) do |(k, v), memo|
        memo[k.to_sym] = get(k)
      end
    end
1037111
function() {
      var options = [];
      Object.keys(_definition).forEach((key, i, list) => {
        if(options.indexOf(_definition[key]) == -1) {
          options.push(_definition[key]);
        }
      });
      return options;
    }
277581
def family(options = {})
      hash = family_hash(options)
      hash.keys.inject([]){|tot,k| tot << hash[k] }.compact.flatten
    end
614792
function (optionCollection, key, model, collection) {
        if (optionCollection) {
            return strTo(optionCollection, model, Collection) || collection;
        }
        return strTo(key, model, Collection) || null;
    }
3301
def options
      Hash[
        DeskApi::Configuration.keys.map do |key|
          [key, instance_variable_get(:"@#{key}")]
        end
      ]
    end
440655
def options
      map = Artifactory::Configurable.keys.map do |key|
        [key, instance_variable_get(:"@#{key}")]
      end
      Hash[map]
    end
12156
def cli_hash(list_of_kv):
    """"""
    ev_obj = {}
    for extra_var in list_of_kv:
        ev_list = extra_var.split('=')
        key = ev_list[0]
        val = '='.join(ev_list[1:])  # b64 and other side effects
        ev_obj[key] = val

    return ev_obj
459322
def parse_options(self, options):
        
        for name in self.get_option_names():
            parse = getattr(self, "parse_option_{name:s}".format(
                name=name), None)
            if parse is not None and isinstance(parse, collections.Callable):
                options[name] = parse()
        return options