key: 'x' -> '{x}'
498957
def _brace_key(self, key):
        
        if isinstance(key, six.integer_types):
            t = str
            key = t(key)
        else:
            t = type(key)
        return t(u'{') + key + t(u'}')
138376
def literal_key(key)
      case key
      when TrueClass  then "'t'"
      when FalseClass then "'f'"
      when Numeric    then key
      else
        key = key.to_s
        key.start_with?("'") && key.end_with?("'") ? key : "'#{key}'"
      end
    end
1234989
function getkey(key) {
        var parsedKey = Number(key);

        return (isNaN(parsedKey) || key.indexOf('.') !== -1)? key : parsedKey;
    }
236594
function(subset, key) {
            return [
              key.nRow(),
              key.nCol(),
              key.at(0, 'D'),
              key.at(0, 'C'),
            ];
          }
1044478
function keyOptions (key, options) {
  const _key = options._key == null
    ? key
    : options._key + '.' + key
  return Object.assign({}, options, { _key: _key })
}
1201843
function (key) {
    var string = key.split('.');
    string.shift(0);
    var value = string.join('.');
    return value;
  }
894149
function prefixKey(key) {
    if (self.nameSpace.length > 0 && !key.startsWith(self.nameSpace)) {
      return `${self.nameSpace}:${key}`
    }
    return key;
  }
951117
function setKey(key, val, ex, px, flag, req) {
  var saved = HashMap.prototype.setKey.apply(this, arguments);
  if(req && req.def) {
    this.modified(req);
  }
  return saved;
}
194932
function( signature, input, key ) {

    var check = this.sign( input, key )

    return signature.toString( 'hex' ) ===
      check.toString( 'hex' )

  }
1119287
function (key) {
            var modelVal = this.getModelVal();
            modelVal = this.multiple ? modelVal : [modelVal];
            return (_.indexOf(_.map(modelVal, toStr), toStr(key)) > -1);
        }
1207768
function stringify(key, value) {
  if (value instanceof RegExp) {
    return value.toString();
  }
  if (value instanceof Function) {
    return '[function]';
  }
  return value;
}
273883
function _edgeKey(u, v) {
    var uStr = u.toString();
    var vStr = v.toString();
    return uStr.length + ":" + uStr + vStr;
  }
822204
function setKey(key, val, flag, expiry, xflag, req) {
  var exists = this._data[key] !== undefined;
  var o = {v: val, t: Date.now()};
  if((xflag === Constants.NX && exists)
    || (xflag === Constants.XX && !exists)) {
    return undefined;
  }
  this._data[key] = o;
  if(!exists) {
    this._keys.push(key);
  }
  if((flag === Constants.EX || flag === Constants.PX)
    && expiry !== undefined) {
    expiry = flag === Constants.EX
      ? Date.now() + (expiry * 1000)
      : Date.now() + expiry;
    this.setExpiry(key, expiry, req);
  }
  return Constants.OK;
}
1244543
function (key) {
        'use strict';
        var parts = key.split('.'),
            body = new Array(parts.length),
            last = parts.pop(),
            len = parts.length,
            fn;
        for (var i = 0; i < len; i += 1) {
            body[i] = "if (typeof (o = o." + parts[i] + ") === 'undefined') return o;";
        }
        body[i] = "return o." + last + ";";
        fn = Function("o", body.join('\n'));
        return fn;
    }
1111626
function (key, obj) {
        'use strict';
        var keysArr = key.split('.'),
            lastKeyPart = keysArr.pop(),
            len = keysArr.length,
            i, k, objNext;
        for (i = 0; i < len; i += 1) {
            k = keysArr[i];
            objNext = obj[k];
            if (!isObj(objNext)) {
                objNext = obj[k] = {};
            }
            obj = objNext;
        }
        return {
            node: obj,
            key: lastKeyPart
        };
    }
65679
def field(key, value)
      field = "<<"
      field << "/T" + "(#{key})"
      field << "/V" + (Array === value ? "[#{value.map{ |v|"(#{quote(v)})" }.join}]" : "(#{quote(value)})")
      field << ">>\n"
      field
    end
255299
function tileToQuadkey(tile) {
    var index = '';
    for (var z = tile[2]; z > 0; z--) {
        var b = 0;
        var mask = 1 << (z - 1);
        if ((tile[0] & mask) !== 0) b++;
        if ((tile[1] & mask) !== 0) b += 2;
        index += b.toString();
    }
    return index;
}