hdachev/fakeredis

"use strict";


// Error replies.

var ERROR = function (message) {
  this.getError = function () { return message; };
  this.toString = function () { return "<ERROR<" + message + ">>"; };
};

var BAD_TYPE = new ERROR('Operation against a key holding the wrong kind of value');
var BAD_KEY = new ERROR('no such key');
var BAD_INT = new ERROR('value is not an integer or out of range');
var BAD_FLOAT = new ERROR('value is not a valid float');
var BAD_ARGS = new ERROR('wrong number of arguments');
var BAD_SYNTAX = new ERROR('syntax error');
var BAD_INDEX = new ERROR('index out of range');
var BAD_SORT = new ERROR('One or more scores can\'t be converted into double');

var BAD_BIT1 = new ERROR('bit offset is not an integer or out of range');
var BAD_BIT2 = new ERROR('bit is not an integer or out of range');
var BAD_SETEX = new ERROR('invalid expire time in SETEX');
var BAD_ZUIS = new ERROR('at least 1 input key is needed for ZUNIONSTORE/ZINTERSTORE');


// Status replies.

var STATUS = function (message) {
  this.getStatus = function () { return message; };
  this.toString = function () { return "<STATUS<" + message + ">>"; };
};

var OK = new STATUS('OK');
var PONG = new STATUS('PONG');
var NONE = new STATUS('none');


// Redis types.

var VALID_TYPE = function () {};
var TYPE = function (type, makePrimitive) {
  var Constr = function (value) {
    if (!(this instanceof VALID_TYPE))
      return new Constr(value);
    if (!value)
      value = makePrimitive();

    this.value = value;
  };

  Constr.getStatus = function () { return type; };
  Constr.prototype = new VALID_TYPE;
  Constr.prototype.toString = function () { return "<TYPE<" + type + ">>"; };
  Constr.prototype.TYPE = Constr;
  return Constr;
};

var EMPTY_STR = { toString: function () { return ""; }, length: 0, copy: function () {} };
var STRING = TYPE("string", function () { return EMPTY_STR; });
var LIST = TYPE("list", function () { return []; });
var HASH = TYPE("hash", function () { return {}; });
var SET = TYPE("set",  function () { return {}; });
var ZSET = TYPE("zset", function () { return {}; });


// Utils.

var arr = function (obj) {
  var i, n = obj.length, out = [];
  for (i = 0; i < n; i++)
    out[i] = obj[i];

  return out;
};

var range = function (min, max) {
  var xlo, xhi;

  if ((xlo = min.substr(0, 1) === '('))
    min = str2float(min.substr(1));
  else
    min = str2float(min);

  if (min instanceof ERROR)
    return min;

  if ((xhi = max.substr(0, 1) === '('))
    max = str2float(max.substr(1));
  else
    max = str2float(max);

  if (max instanceof ERROR)
    return max;

  return function (num) {
    return !((xlo && num <= min) || (num < min) || (xhi && num >= max) || (num > max));
  };
};

var slice = function (arr, start, stop, asCount) {
  start = str2int(start);
  stop = str2int(stop);
  if (start instanceof ERROR) return start;
  if (stop instanceof ERROR) return stop;

  if (arr.slice) {
    var n = arr.length;
    if (asCount) {
      if (start < 0) {
        start = 0; // Redis is inconsistent about this, ZRANGEBYSCORE will return an empty multibulk on negative offset
        stop = 0; // whilst SORT will return as if the offset was 0. Best to lint these away with client-side errors.
      }
      else if (stop < 0) stop = n;
      else stop += start;
    }
    else {
      if (start < 0) start = n + start;
      if (stop < 0) stop = n + stop;
      stop++;
    }

    if (start >= stop)
      return [];
    else
      return arr.slice(start < 0 ? 0 : start, stop > n ? n : stop);
  }

  else
    return arr;
};

var str2float = function (string) {
  var value = Number(string);
  if (typeof string !== 'string') throw new Error("WOOT! str2float: '" + string + "' not a string.");
  if (string === '+inf') value = Number.POSITIVE_INFINITY;
  else if (string === '-inf') value = Number.NEGATIVE_INFINITY;
  else if (!string || (!value && value !== 0)) return BAD_FLOAT;
  return value;
};

var str2int = function (string) {
  var value = str2float(string);
  if (value instanceof ERROR || value % 1 !== 0) return BAD_INT;
  return value;
};

var pattern = function (string) {
  string = string.replace(/([+{($^|.\\])/g, '\\' + '$1');
  string = string.replace(/(^|[^\\])([*?])/g, '$1.$2');
  string = '^' + string + '$';

  var pattern = new RegExp(string);
  return pattern.test.bind(pattern);
};

var populationCount = function (data) {
  var count;
  for (count = 0; data > 0; count++) {
    data &= data - 1;
  }
  return count;
};

// Keyspace and pubsub.

exports.Backend = function () {
  var state
    , dbs = {}
    , delrev = {}
    , rev = 0

    , subs = []
    , call = []
    , tick = false
    , nextTick = function () {
      var c, func;
      tick = false;
      c = call.splice(0, call.length);
      while ((func = c.shift())) func();
    };


  // Select.
  // Selected keyspace is NOT relevant to pubsub.
  this.selectDB = function (id) {
    if (typeof id !== "number" || id % 1 !== 0)
      throw new Error("Invalid database id: " + id);

    // Select or instantiate.
    var db = dbs[id] || (dbs[id] = {});
    state = db;
  };

  // Connections start in database 0.
  this.selectDB(0);


  // Typed getKey.

  this.getKey = function (Type, key, make) {
    var entry = state[key];

    if (Type && !Type.getStatus)
      throw new Error("WOOT! Type param for getKey is not a valid Type.");
    if (key === undefined)
      throw new Error("WOOT! key param for getKey is undefined.");

    if (entry) {
      if (entry.expire < Date.now()) {
        delete state[key];
        delrev[key] = ++rev;
        entry = null;
      }
      else if (!(entry.value instanceof VALID_TYPE))
        throw new Error("WOOT! keyspace entry value is not a valid Type.");
    }

    if (Type) {
      if (entry && !(entry.value instanceof Type))
        return BAD_TYPE;
      if (!entry && make)
        return new Type;
    }

    return (entry && entry.value) || null;
  };

  this.setKey = function (key, value) {
    if (value) {
      if (!(value instanceof VALID_TYPE))
        throw new Error("WOOT! Value doesn't have a valid type.");

      rev++;
      state[key] = { value: value };
      state[key].rev = rev;
      delete delrev[key];

      this.pub(this.UPDATE, key);

      return 1;
    }

    else if (state[key]) {
      rev++;
      delrev[key] = rev;
      delete state[key];

      return 1;
    }

    return 0;
  };

  this.upsetKey = function (key, value) {
    if (!value)
      throw new Error("WOOT! Update key with a falsy value.");
    if (!(value instanceof VALID_TYPE))
      throw new Error("WOOT! Value doesn't have a valid type.");

    if (state[key] && state[key].expire >= Date.now()) {
      if (state[key].value !== value)
        throw new Error("WOOT! Chaning value containers during upsetKey.");

      rev++;
      state[key].value = value;
      state[key].rev = rev;

      this.pub(this.UPDATE, key);
    }

    else
      this.setKey(key, value);
  };

  this.getExpire = function (key) {
    var entry = state[key];

    if (!entry || entry.expire < Date.now()) {
      delete state[key];
      return null;
    }

    return entry.expire;
  };

  this.setExpire = function (key, expire) {
    var entry = state[key];

    if (!entry || entry.expire < Date.now()) {
      delete state[key];
      return 0;
    }

    else if (expire) {
      entry.expire = expire;
      return 1;
    }

    else if (entry.expire) {
      delete entry.expire;
      return 1;
    }

    return 0;
  };

  this.getKeys = function () {
    var keys = []
      , key;

    for (key in state)
      if (this.getKey(null, key))
        keys.push(key);

    return keys;
  };

  this.renameKey = function (keyA, keyB) {
    if (!this.getKey(null, keyA))
      return false;

    rev++;
    state[keyB] = state[keyA];
    state[keyB].rev = rev++;
    delete state[keyA];

    this.pub(this.UPDATE, keyB);

    return true;
  };


  // Keyspace change event.

  this.UPDATE = new STATUS("Key value updated.");


  // For implementing watch and stuff.

  this.getRevision = function (key) {
    this.getKey(null, key);
    return (state[key] && state[key].rev) || delrev[key] || 0;
  };


  // Publish / subscribe backend.

  this.pub = function (channel, message) {
    if (!channel && channel !== '') throw new Error("WOOT! Publishing to a falsy, non-string channel : [" + channel + '] ' + message);
    if (!message && message !== '') throw new Error("WOOT! Publishing a falsy, non-string message : [" + channel + '] ' + message);

    var i, n = subs.length, sub, x = 0;
    for (i = 0; i < n; i++) {
      sub = subs[i];

      if (sub.channel === channel || (sub.pattern !== null && sub.channel(channel))) {
        if (sub.pattern !== null)
          call.push(sub.client.pushMessage.bind(sub.client, 'pmessage', sub.pattern, channel, message));
        else
          call.push(sub.client.pushMessage.bind(sub.client, 'message', channel, message));

        x++;
        if (!tick) {
          tick = true;
          process.nextTick(nextTick);
        }
      }
    }

    return x;
  };

  // p - true/false
  // channel - string
  // client { push ( pattern, channel, message ) }

  this.sub = function (p, channel, client) {
    if (!channel && channel !== '') throw new Error("WOOT! Subscribing to a falsy, non-string channel : [" + channel + ']');
    if (!client || !client.pushMessage) throw new Error("WOOT! Subscribing an invalid client : " + client);
    if (typeof channel === 'function') throw new Error("WOOT! Subscribing to a function : " + channel);

    var i, n = subs.length, sub, found = false;
    for (i = 0; i < n; i++) {
      sub = subs[i];
      if (sub.client === client && ((p && sub.pattern === channel) || (!p && sub.channel === channel))) {
        found = true;
        break;
      }
    }

    var x = this.numSubs(client);

    if (!found) {
      x++;

      subs.push({ pattern: p ? channel : null, channel: p ? pattern(channel) : channel, client: client });
      process.nextTick(client.pushMessage.bind(client, p ? 'psubscribe' : 'subscribe', channel, x));
    }

    return x;
  };

  this.unsub = function (p, channel, client) {
    if (!channel && channel !== '' && channel !== null) throw new Error("WOOT! Unsubscribing from a falsy, non-string, non-null channel : [" + channel + ']');
    if (!client || !client.pushMessage) throw new Error("WOOT! Unsubscribing an invalid client : " + client);

    var x = this.numSubs(client);

    var i, n = subs.length, sub;
    for (i = 0; i < n; i++) {
      sub = subs[i];
      if (sub.client !== client)
        continue;

      if ((p && sub.pattern !== null && (channel === null || sub.pattern === channel)) || (!p && sub.pattern === null && (channel === null || sub.channel === channel))) {
        x--;
        subs.splice(i, 1);
        process.nextTick(client.pushMessage.bind(client, p ? 'punsubscribe' : 'unsubscribe', p ? sub.pattern : sub.channel, x));
        i--; n--;
      }
    }

    return x;
  };

  this.numSubs = function (client) {
    var i, n = subs.length, x = 0;
    for (i = 0; i < n; i++)
      if (subs[i].client === client)
        x++;

    return x;
  };

};


// Redis commands.

exports.Backend.prototype = {


  // Keys.

  DEL: function () {
    var i, n = arguments.length, x = 0;
    if (!n) return BAD_ARGS;
    for (i = 0; i < n; i++)
      if (this.setKey(arguments[i], null)) x++;

    return x;
  }

, EXISTS: function (key) {
    return this.getKey(null, key)? 1 : 0;
  }

, PEXPIREAT: function (key, time) {
    time = str2int(time);
    if (time instanceof ERROR) return time;
    return this.setExpire(key, time);
  }

, EXPIREAT: function (key, time) {
    time = str2int(time);
    if (time instanceof ERROR) return time;
    return this.setExpire(key, time * 1000);
  }

, PEXPIRE: function (key, time) {
    time = str2int(time);
    if (time instanceof ERROR) return time;
    return this.setExpire(key, time + Date.now());
  }

, EXPIRE: function (key, time) {
    time = str2int(time);
    if (time instanceof ERROR) return time;
    return this.setExpire(key, time * 1000 + Date.now());
  }

, PERSIST: function (key) {
    return this.PEXPIREAT(key, "0");
  }

, PTTL: function (key) {
    var ttl = this.getExpire(key);
    if (ttl) return ttl - Date.now();
    else return - 1;
  }

, RANDOMKEY: function () {
    var keys = this.getKeys(), n = keys && keys.length;
    if (n) return keys[Math.floor(Math.random()* n)];
    else return null;
  }

, RENAME: function (key, newkey) {
    return this.renameKey(key, newkey)? OK : BAD_KEY;
  }

, RENAMENX: function (key, newkey) {
    if (!this.EXISTS(key)) return BAD_KEY;
    if (this.EXISTS(newkey)) return 0;
    if (!this.renameKey(key, newkey)) throw new Error("WOOT! Couldn't rename.");
    return 1;
  }

, TTL: function (key) {
    var ttl = this.getExpire(key);
    if (ttl) return Math.ceil((ttl - Date.now())/ 1000);
    else return - 1;
  }

, TYPE: function (key) {
    var K = this.getKey(null, key);
    return K ? K.TYPE : NONE;
  }

, KEYS: function (pat) {
    var keys = this.getKeys().filter(pattern(pat));
    keys.sort();
    return keys;
  }

, SCAN: function () {
    return this._scan(this.getKeys(), 1, arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]);
  }

, SSCAN: function () {
    return this._scan(this.SMEMBERS(arguments[0]), 1, arguments[1], arguments[2], arguments[3], arguments[4], arguments[5]);
  }

, HSCAN: function () {
    return this._scan(this.HGETALL(arguments[0]), 2, arguments[1], arguments[2], arguments[3], arguments[4], arguments[5]);
  }

, ZSCAN: function () {
    return this._scan(this.ZRANGE(arguments[0], '0', '-1', 'WITHSCORES'), 2, arguments[1], arguments[2], arguments[3], arguments[4], arguments[5]);
  }

, _scan: function (allKeys, size, cursor, opt1, opt1val, opt2, opt2val) {
    cursor = str2int(cursor);
    if (cursor instanceof ERROR)
      return cursor;

    var count = 10;
    var matchPattern = null;

    opt1 = (opt1 || '').toUpperCase();
    opt2 = (opt2 || '').toUpperCase();
    if (opt1 === 'MATCH') {
      matchPattern = pattern(opt1val);
      if (opt2 === 'COUNT')
        count = str2int(opt2val);
      else if (opt2)
        return BAD_SYNTAX;
    }
    else if (opt1 === 'COUNT') {
      if (opt2)
        return BAD_SYNTAX;
      else
        count = str2int(opt1val);
    }
    else if (opt1)
      return BAD_SYNTAX;

    if (count instanceof ERROR)
      return count;

    var nextCursor = cursor + count;
    var keys = allKeys.slice(cursor, nextCursor);

    // Apply MATCH filtering _after_ getting number of keys
    if (matchPattern) {
      var i = 0;
      while (i < keys.length)
        if (!matchPattern(keys[i]))
          keys.splice(i, size);
        else
          i += size;
    }

    // Return 0 when iteration is complete.
    if (nextCursor >= allKeys.length)
      nextCursor = 0;

    return [nextCursor, keys];
  }


  // String setters.

, SET: function () {
    if (arguments.length < 2) return BAD_ARGS;
    var argc = 0;
    var key = arguments[argc++];
    var value = arguments[argc++];
    var buf = new Buffer(Buffer.byteLength(value));
      buf.write(value);

    var optNX = false;
    var optXX = false;
    var optEX = 0;
    var optPX = 0;

    // process.stdout.write('arguments is ' + JSON.stringify(arguments));
    while (argc < arguments.length) {
      switch (arguments[argc++].toUpperCase()) {
        case 'NX': {
          optNX = true;
          break;
        }
        case 'XX': {
          optXX = true;
          break;
        }
        case 'EX': {
          if (arguments.length === argc)
            return BAD_ARGS;
          optEX = arguments[argc++];
          /*jshint -W018*/
          if (!(str2int(optEX) > 0))
            return BAD_INT;
          break;
        }
        case 'PX': {
          if (arguments.length === argc)
            return BAD_ARGS;
          optPX = arguments[argc++];
          /*jshint -W018*/
          if (!(str2int(optPX) > 0))
            return BAD_INT;
          break;
        }
      }
    }

    if (optNX) {
      if (this.EXISTS(key)) return null;
    }

    if (optXX) {
      if (!this.EXISTS(key)) return null;
    }

    this.setKey(key, new STRING(buf));

    if (optEX) {
      this.EXPIRE(key, optEX);
    }

    if (optPX) {
      this.PEXPIRE(key, optPX);
    }

    return OK;
  }

, sIncrBy: function (parse, key, incr) {
    var K = this.getKey(STRING, key, true);
    if (K instanceof ERROR) return K;

    incr = parse(incr);
    if (incr instanceof ERROR) return incr;
    var value = parse(K.value.toString() || "0");
    if (value instanceof ERROR) return value;

    value = (value + incr).toString();
    var buf = new Buffer(Buffer.byteLength(value));
      buf.write(value);

    K.value = value;
    this.upsetKey(key, K);
    return value;
  }

, sFit: function (key, length) {
    var K = this.getKey(STRING, key, true);
    if (K instanceof ERROR) return ERROR;

    if (K.value.length < length) {
      var buf = new Buffer(length);
        buf.fill(0);

      K.value.copy(buf);
      K.value = buf;
    }

    return K;
  }

, SETBIT: function (key, offset, state) {
    /*jshint -W018*/
    offset = str2int(offset);
    if (!(offset >  - 1)) return BAD_BIT1;
    state = str2int(state);
    if (!(state === 0 || state === 1)) return BAD_BIT2;

    var x = Math.floor(offset / 8);
    var K = this.sFit(key, x + 1);
    if (K instanceof ERROR) return K;

    var mask = 1 << (7 - (offset % 8));
    var current = K.value[x];
    var old = current & mask ? 1 : 0;

    if (state && !old)
      K.value[x] = current | mask;
    else if (!state && old)
      K.value[x] = current & ~mask;

    this.upsetKey(key, K);
    return old;
  }

, SETRANGE: function (key, offset, value) {
    /*jshint -W018*/
    offset = str2int(offset);
    if (!(offset >  - 1)) return BAD_BIT1;

    var K = this.sFit(key, offset + Buffer.byteLength(value));
    K.value.write(value, offset);

    this.upsetKey(key, K);
    return this.STRLEN(key);
  }


  // String getters.

, GET: function (key) {
    var K = this.getKey(STRING, key);
    if (K instanceof ERROR) return K;
    return K ? K.value.toString() : null;
  }

, STRLEN: function (key) {
    var K = this.getKey(STRING, key);
    if (K instanceof ERROR) return ERROR;
    return K ? K.value.length : 0;
  }

, GETBIT: function (key, offset) {
    /*jshint -W018*/
    var K = this.getKey(STRING, key);
    if (K instanceof ERROR) return ERROR;

    offset = str2int(offset);
    if (!(offset >  - 1)) return BAD_BIT1;
    var x = Math.floor(offset / 8);
    if (!K || K.length < x + 1) return 0;

    var mask = 1 << (7 - (offset % 8));
    return (K.value[x]& mask)? 1 : 0;
  }

, GETRANGE: function (key, start, stop) {
    var K = this.getKey(STRING, key);
    if (K instanceof ERROR) return ERROR;
    if (!K) return "";

    var out = slice(K.value, start, stop);
    if (out instanceof ERROR) return out;
    return out.toString();
  }

, BITCOUNT: function () {
    var key = arguments[0];
    var start = arguments[1] || 0;
    var stop = arguments[2] || -1;

    if (!key) return BAD_ARGS;

    var K = this.GETRANGE(key, start.toString(), stop.toString());
    if (K instanceof ERROR) return ERROR;
    if (!K) return 0;

    var bitCount = 0;
    var buff = new Buffer(K);
    for (var i = 0; i < buff.length; i++) {
      bitCount += populationCount(buff[i].toString());
    }

    return bitCount;
  }


  // String ops.

, APPEND: function (key, value) {
    var strlen = this.STRLEN(key);
    if (strlen instanceof ERROR) return strlen;
    return this.SETRANGE(key, strlen.toString(), value);
  }

, DECR: function (key) {
    return this.DECRBY(key, "1");
  }

, DECRBY: function (key, decr) {
    var value = str2int(decr);
    if (value instanceof ERROR) return value;
    return this.INCRBY(key, ( - value).toString());
  }

, GETSET: function (key, value) {
    var old = this.GET(key);
    if (old instanceof ERROR) return old;
    this.SET(key, value);
    return old;
  }

, INCR: function (key) {
    return this.INCRBY(key, "1");
  }

, INCRBY: function (key, incr) {
    return this.sIncrBy(str2int, key, incr);
  }

, INCRBYFLOAT: function (key, incr) {
    return this.sIncrBy(str2float, key, incr);
  }

, MGET: function () {
    var out = [], i, n = arguments.length;
    if (!n) return BAD_ARGS;

    for (i = 0; i < n; i++) {
      var value = this.GET(arguments[i]);
      out[i] = value instanceof ERROR ? null : value;
    }

    return out;
  }

, MSET: function () {
    var key, value, i, n = arguments.length;
    if (!n || n % 2) return BAD_ARGS;

    for (i = 0; i < n; i += 2) {
      key = arguments[i];
      value = arguments[i + 1];
      this.SET(key, value);
    }

    return OK;
  }

, MSETNX: function () {
    var i, n = arguments.length;
    for (i = 0; i < n; i += 2)
      if (this.EXISTS(arguments[i])) return 0;

    this.MSET.apply(this, arguments);
    return 1;
  }

, PSETEX: function (key, timediff, value) {
    /*jshint -W018*/
    if (!(str2int(timediff) > 0))
      return BAD_SETEX;

    this.SET(key, value);
    this.PEXPIRE(key, timediff);
    return OK;
  }

, SETEX: function (key, timediff, value) {
    /*jshint -W018*/
    if (!(str2int(timediff) > 0))
      return BAD_SETEX;

    this.SET(key, value);
    this.EXPIRE(key, timediff);
    return OK;
  }

, SETNX: function (key, value) {
    if (this.EXISTS(key)) return 0;
    this.SET(key, value);
    return 1;
  }


  // Lists, non-blocking.

, lStore: function (key, values) {
    // Only used in SORT.

    if (values.length)
      return this.setKey(key, new LIST(values));
    else
      return this.setKey(key, null);
  }

, LINDEX: function (key, index) {
    var K = this.getKey(LIST, key);
    if (K instanceof ERROR) return K;

    index = str2int(index);
    if (index instanceof ERROR)
      return index;

    return (K && K.value[index < 0 ? K.value.length + index : index]) || null;
  }

, upsetList: function (key, K) {
    if (K.value.length) this.upsetKey(key, K);
    else this.setKey(key, null);
  }

, LINSERT: function (key, relpos, pivot, value) {
    var K = this.getKey(LIST, key), x;
    if (K instanceof ERROR) return K;

    relpos = relpos.toUpperCase();
    if (relpos !== 'BEFORE' && relpos !== 'AFTER') return BAD_SYNTAX;
    if (!K) return 0;
    if ((x = K.value.indexOf(pivot)) < 0) return 0;

    K.value.splice(relpos === 'AFTER'? x + 1 : x, 0, value);
    this.upsetList(key, K);
    return 1;
  }

, LLEN: function (key) {
    var K = this.getKey(LIST, key);
    if (K instanceof ERROR) return K;

    return (K && K.value && K.value.length) || 0;
  }

, lPopMany: function (left, keys) {
    var K = [], value, i, n = keys.length;
    if (!n) return BAD_ARGS;
    for (i = 0; i < n; i++) {
      K[i] = this.getKey(LIST, keys[i]);
      if (K[i]instanceof ERROR) return K[i];
    }
    for (i = 0; i < n; i++)
      if (K[i] && K[i].value && K[i].value.length) {
        value = left ? K[i].value.shift() : K[i].value.pop();
        this.upsetList(keys[i], K[i]);
        return [keys[i], value];
      }

    return null;
  }

, lPop: function (left, key) {
    var out = this.lPopMany(left, [key]);
    return out && out.length ? out[1] : out;
  }

, LPOP: function (key) {
    return this.lPop(true, key);
  }

, RPOP: function (key) {
    return this.lPop(false, key);
  }

, lPush: function (left, make, args) {
    var i, n = args.length, key = args[0];
    var K = this.getKey(LIST, key, make);
    if (K instanceof ERROR) return K;
    if (n < 2) return BAD_ARGS;
    if (!K) return 0;

    if (left) for (i = 1; i < n; i++)
      K.value.unshift(args[i]);
    else
      K.value.push.apply(K.value, args.slice(1));

    this.upsetList(key, K);
    return K.value.length;
  }

, LPUSH: function () {
    return this.lPush(true, true, arr(arguments));
  }

, LPUSHX: function () {
    return this.lPush(true, false, arr(arguments));
  }

, RPUSH: function () {
    return this.lPush(false, true, arr(arguments));
  }

, RPUSHX: function () {
    return this.lPush(false, false, arr(arguments));
  }

, RPOPLPUSH: function (source, destination) {
    var dest = this.getKey(LIST, destination);
    if (dest && dest instanceof ERROR) return dest;
    var value = this.RPOP(source);
    if (value === null || value instanceof ERROR) return value;

    var len = this.LPUSH(destination, value);
    if (!len || len instanceof ERROR) throw new Error("WOOT! LPUSH failed in RPOPLPUSH.");

    return value;
  }

, LRANGE: function (key, start, stop) {
    var K = this.getKey(LIST, key);
    if (K instanceof ERROR) return K;
    if (!K) return [];

    return slice(K.value, start, stop);
  }

, LREM: function (key, count, value) {
    var K = this.getKey(LIST, key);
    if (K instanceof ERROR) return K;
    count = str2int(count);
    if (count instanceof ERROR) return count;
    if (!K) return 0;

    var i, n = K.value.length, x = 0;
    if (count < 0) {
      count *=  - 1;
      for (i = n - 1; i >= 0; i--)
        if (K.value[i] === value && (!count || x < count)) {
          K.value.splice(i, 1);
          x++;
        }
    }
    else for (i = 0; i < n; i++)
      if (K.value[i] === value && (!count || x < count)) {
        K.value.splice(i, 1);
        i--; n--; x++;
      }

    if (x > 0) this.upsetList(key, K);
    return x;
  }

, LSET: function (key, index, value) {
    var K = this.getKey(LIST, key);
    if (!K) return BAD_KEY;
    if (K instanceof ERROR) return K;
    index = str2int(index);
    if (index instanceof ERROR) return index;
    if (index < 0 || index > K.value.length) return BAD_INDEX;

    K.value[index] = value;
    this.upsetList(key, K);
    return OK;
  }

, LTRIM: function (key, start, stop) {
    var range = this.LRANGE(key, start, stop);
    if (!range.join)
      return range;

    var K = this.getKey(LIST, key);
    if (K) {
      K.value = range;
      this.upsetList(key, K);
    }

    return OK;
  }


  // Blocking list commands.
  // The blocking part happens at the connection level,
  // where in case the response is null the connection subscribes to the keyspace change event for the key and waits to retry.

  // So this only validates the parameter.

, bArgs: function (args) {
    args = arr(args);
    var timeout = str2int(args.pop() || "FAIL");
    if (timeout instanceof ERROR) return timeout;
    if (timeout < 0) return BAD_INT;
    return args;
  }

, BLPOP: function () {
    var a = this.bArgs(arguments);
    if (a instanceof ERROR) return a;
    return this.lPopMany(true, a);
  }

, BRPOP: function () {
    var a = this.bArgs(arguments);
    if (a instanceof ERROR) return a;
    return this.lPopMany(false, a);
  }

, BRPOPLPUSH: function () {
    var a = this.bArgs(arguments);
    if (a instanceof ERROR) return a;
    return this.RPOPLPUSH.apply(this, a);
  }


  // Hashes.

, structPut: function (type, validate, revArgs, args) {
    var key = args[0], i, n = args.length, x = 0;

    if (n < 3 || ((n - 1) % 2)) return BAD_ARGS;
    var K = this.getKey(type, key, true);
    if (K instanceof ERROR) return K;

    for (i = 1; i < n; i += 2) {
      var member = args[revArgs ? i + 1 : i]
        , value = validate(args[revArgs ? i : i + 1]);
      if (value instanceof ERROR) return value;
      if (!(member in K.value)) x++;
      K.value[member] = value;
    }

    if (x) this.upsetKey(key, K);
    return x;
  }

, structDel: function (type, args) {
    var key = args[0]
      , i, n = args.length
      , x;

    if (n < 2) return BAD_ARGS;
    var K = this.getKey(type, key);
    if (K instanceof ERROR) return K;
    if (!K) return 0;

    x = 0;
    for (i = 1; i < n; i++) {
      if (args[i]in K.value) x++;
      delete K.value[args[i]];
    }

    // Remove the set if empty, upset otherwise.

    var member;
    for (member in K.value) {
      if (x) this.upsetKey(key, K);
      return x;
    }

    this.setKey(key, null);
    return x;
  }

, structGet: function (type, key, member) {
    var K = this.getKey(type, key);
    if (K instanceof ERROR) return K;
    if (!K || !(member in K.value)) return null;
    return K.value[member];
  }

, HDEL: function () {
    return this.structDel(HASH, arguments);
  }

, HEXISTS: function (key, field) {
    var fields = this.HKEYS(key);
    if (fields.indexOf) return fields.indexOf(field) >= 0 ? 1 : 0;
    return fields;
  }

, HGET: function (key, field) {
    return this.structGet(HASH, key, field);
  }

, HGETALL: function (key) {
    var fields = this.HKEYS(key);
    var i, n = fields.length, out = [];
    for (i = 0; i < n; i++)
      out.push(fields[i], this.HGET(key, fields[i]));

    return out;
  }

, hIncrBy: function (parse, key, field, incr) {
    var K = this.getKey(HASH, key, true);
    if (K instanceof ERROR) return K;

    incr = parse(incr);
    if (incr instanceof ERROR) return incr;
    var value = parse(K.value[field] || "0");
    if (value instanceof ERROR) return value;

    K.value[field] = (value + incr).toString();
    this.upsetKey(key, K);
    return K.value[field];
  }

, HINCRBY: function (key, field, incr) {
    return this.hIncrBy(str2int, key, field, incr);
  }

, HINCRBYFLOAT: function (key, field, incr) {
    return this.hIncrBy(str2float, key, field, incr);
  }

, HKEYS: function (key) {
    var K = this.getKey(HASH, key);
    if (K instanceof ERROR) return K;

    var fields = [], field;
    if (K) for (field in K.value)
      fields.push(field);

    fields.sort();
    return fields;
  }

, HLEN: function (key) {
    var fields = this.HKEYS(key);
    if (fields.indexOf) return fields.length;
    return fields;
  }

, HMGET: function () {
    var K = this.getKey(HASH, arguments[0]);
    if (K instanceof ERROR) return K;

    var i, n = arguments.length, values = [];
    if (n < 2) return BAD_ARGS;
    for (i = 1; i < n; i++)
      values.push(K && arguments[i]in K.value ? K.value[arguments[i]] : null);

    return values;
  }

, HMSET: function () {
    var x = this.structPut(HASH, String, false, arguments);
    return x instanceof ERROR ? x : OK;
  }

, HSET: function () {
    return this.structPut(HASH, String, false, arguments);
  }

, HSETNX: function (key, field, value) {
    var exists = this.HEXISTS(key, field);
    if (exists instanceof ERROR) return exists;
    if (exists) return 0;
    return this.HSET(key, field, value);
  }

, HVALS: function (key) {
    var out = this.HKEYS(key), self = this;
    if (out instanceof ERROR) return out;

    if (out.map)
      out = out.map(function (field) {
        return self.HGET(key, field);
      });

    out.sort();
    return out;
  }


  // Sets.

, SADD: function () {
    var key = arguments[0]
      , i, n = arguments.length
      , x = 0;

    if (n < 2) return BAD_ARGS;
    var K = this.getKey(SET, key, true);
    if (K instanceof ERROR) return K;

    for (i = 1; i < n; i++)
      if (!K.value[arguments[i]]) {
        K.value[arguments[i]] = true;
        x++;
      }

    if (x) this.upsetKey(key, K);
    return x;
  }

, SCARD: function (key) {
    var members = this.SMEMBERS(key);
    return members.join ? members.length : members;
  }

, SISMEMBER: function (key, member) {
    var members = this.SMEMBERS(key);
    return members.indexOf ? members.indexOf(member) >= 0 ? 1 : 0: members;
  }

, SMEMBERS: function (key) {
    return this.SUNION(key);
  }

, SPOP: function (key) {
    var member = this.SRANDMEMBER(key);
    if (typeof member === 'string')
      this.SREM(key, member);

    return member;
  }

, SRANDMEMBER: function (key) {
    var members = this.SMEMBERS(key)
      , n = members.length, member;
    if (!n)
      return n === 0 ? null : members;

    member = members[Math.floor(Math.random()* n)];
    return member;
  }

, SREM: function () {
    return this.structDel(SET, arguments);
  }


  // Set multikey ops.
  // Set members come out sorted lexicographically to facilitate testing.

, SMOVE: function (source, destination, member) {
    var removed = this.SREM(source, member);
    if (removed === 1)
      return this.SADD(destination, member);
    else
      return removed;
  }

, SUNION: function () {
    var i, n = arguments.length, out = [];
    if (!n) return BAD_ARGS;

    for (i = 0; i < n; i++) {
      var K = this.getKey(SET, arguments[i]);
      if (K instanceof ERROR) return K;

      var member;
      if (K) for (member in K.value)
        if (out.indexOf(member) < 0)
          out.push(member);
    }

    out.sort();
    return out;
  }

, sCombine: function (diff, args) {
    var i, n = args.length;
    if (!n)
      return BAD_ARGS;

    var out = this.SUNION(args[0]);
    if (out instanceof ERROR) return out;
    for (i = 1; i < n; i++) {
      var K = this.getKey(SET, args[i]);
      if (K instanceof ERROR) return K;

      var j, m = out.length;
      for (j = 0; j < m; j++)
        if ((diff && (K && K.value[out[j]])) || (!diff && !(K && K.value[out[j]]))) {
          out.splice(j, 1);
          j--;
          m--;
        }
    }

    out.sort();
    return out;
  }

, SDIFF: function () {
    return this.sCombine(true, arr(arguments));
  }

, SINTER: function () {
    return this.sCombine(false, arr(arguments));
  }

, sStore: function (key, members) {
    var K, i, n = members.length;
    if (n) K = new SET({});
    for (i = 0; i < n; i++)
      K.value[members[i]] = true;

    return this.setKey(key, K || null);
  }

, sStoreOp: function (op, args) {
    if (!args.length)
      return BAD_ARGS;

    var key = args.shift()
      , members = op.apply(this, args);

    if (members.join) {
      this.sStore(key, members);
      return members.length;
    }

    return members;
  }

, SDIFFSTORE: function () {
    return this.sStoreOp(this.SDIFF, arr(arguments));
  }

, SINTERSTORE: function () {
    return this.sStoreOp(this.SINTER, arr(arguments));
  }

, SUNIONSTORE: function () {
    return this.sStoreOp(this.SUNION, arr(arguments));
  }


  // Sorted sets.

, ZADD: function () {
    return this.structPut(ZSET, str2float, true, arguments);
  }

, ZCARD: function (key) {
    return this.ZCOUNT(key, '-inf', '+inf');
  }

, ZCOUNT: function (key, min, max) {
    var members = this.ZRANGEBYSCORE(key, min, max);
    return members.join ? members.length : members;
  }

, ZINCRBY: function (key, incr, member) {
    var K = this.getKey(ZSET, key, true);
    if (K instanceof ERROR) return K;

    var value = str2float(incr);
    if (value instanceof ERROR) return value;
    value += Number(K.value[member] || 0);

    K.value[member] = value;
    this.upsetKey(key, K);
    return value;
  }


  // Sort set queries.

, zSort: function (rev, key, min, max) {
    var K = this.getKey(ZSET, key);
    if (K instanceof ERROR) return K;
    if (!K) return [];

    var rng = range(min, max), member, out = [];
    if (rng instanceof ERROR) return rng;

    for (member in K.value)
      if (rng(K.value[member]))
        out.push({ member: member, score: K.value[member] });

    // First by score,
    // then in lexicographic order.

    if (rev)
      out.sort(function (b, a) {
        return (a.score - b.score) || (a.member < b.member ? - 1 : 1);
      });

    else
      out.sort(function (a, b) {
        return (a.score - b.score) || (a.member < b.member ? - 1 : 1);
      });

    return out;
  }

, zUnwrap: function (range, scores) {
    var i, n = range.length, out = n ?[] : range;
    if (n)
      for (i = 0; i < n; i++) {
        out.push(range[i].member);
        if (scores)
          out.push(range[i].score);
      }

    return out;
  }

, zGetRange: function (rev, args) {
    var key = args[0], start = args[1], stop = args[2], scores = args[3];

    if (args.length < 3 || args.length > 4)
      return BAD_ARGS;
    if (scores && scores.toUpperCase() !== 'WITHSCORES')
      return BAD_SYNTAX;

    var range = this.zSort(rev, key, '-inf', '+inf');

    return this.zUnwrap(slice(range, start, stop), scores);
  }

, zGetRangeByScore: function (rev, args) {
    var key = args[0], min = args[rev ? 2 : 1], max = args[rev ? 1 : 2]
      , scores, limit, offset, count;

    if (args.length < 3)
      return BAD_ARGS;

    else if (args.length === 4)
      scores = args[3];

    else if (args.length === 6) {
      limit = args[3];
      offset = args[4];
      count = args[5];
    }

    else if (args.length === 7) {
      scores = args[3];
      limit = args[4];
      offset = args[5];
      count = args[6];
    }

    if (scores && scores.toUpperCase() !== 'WITHSCORES')
      return BAD_SYNTAX;
    if (limit && limit.toUpperCase() !== 'LIMIT')
      return BAD_SYNTAX;

    var range = this.zSort(rev, key, min, max);
    if (limit)
      range = slice(range, offset, count, true);

    return this.zUnwrap(range, scores);
  }

, ZRANGE: function () {
    return this.zGetRange(false, arr(arguments));
  }

, ZREVRANGE: function () {
    return this.zGetRange(true, arr(arguments));
  }

, ZRANGEBYSCORE: function () {
    return this.zGetRangeByScore(false, arr(arguments));
  }

, ZREVRANGEBYSCORE: function () {
    return this.zGetRangeByScore(true, arr(arguments));
  }

, ZRANK: function (key, member) {
    var out = this.zSort(false, key, '-inf', '+inf')
      , i, n = out.length;

    for (i = 0; i < n; i++)
      if (out[i].member === member)
        return i;

    return n || n === 0 ? null : out;
  }

, ZREVRANK: function (key, member) {
    var out = this.zSort(false, key, '-inf', '+inf')
      , i, n = out.length;

    for (i = n - 1; i >= 0; i--)
      if (out[i].member === member)
        return n - i - 1;

    return n || n === 0 ? null : out;
  }

, ZSCORE: function (key, member) {
    return this.structGet(ZSET, key, member);
  }

, ZREM: function () {
    return this.structDel(ZSET, arguments);
  }

, ZREMRANGEBYRANK: function (key, start, stop) {
    var members = this.ZRANGE(key, start, stop), n = members.length;
    if (n)
      n = this.ZREM.apply(this, [key].concat(members));

    return n || n === 0 ? n : members;
  }

, ZREMRANGEBYSCORE: function (key, min, max) {
    var members = this.ZRANGEBYSCORE(key, min, max), n = members.length;
    if (n)
      n = this.ZREM.apply(this, [key].concat(members));

    return n || n === 0 ? n : members;
  }


  // Sorted set multikey ops.

, getSetOrZsetKey: function (key) {
    var K;
    var type = this.TYPE(key);
    if (type === ZSET || type === SET) {
      K = this.getKey(type, key);
    }

    return K;
}


, zOpStore: function (union, key, keys, weights, aggregate) {
    var K = this.getSetOrZsetKey(keys[0]);
    if (K instanceof ERROR) return K;

    var out = {}, member, x = 0, weight = (weights === null ? 1 : weights[0]);
    if (K) for (member in K.value) {
      out[member] = K.value[member]* weight;
      x++;
    }

    var i, n = keys.length;
    for (i = 1; i < n; i++) {
      K = this.getSetOrZsetKey(keys[i]);
      if (K instanceof ERROR) return K;

      weight = (weights !== null ? weights[i] : 1);
      if (!union) {
        if (!K) {
          out = {};
          x = 0;
        }

        else for (member in out) if (!(member in K.value)) {
          delete out[member];
          x--;
        }
      }

      if (K) for (member in K.value)
        if (union || member in out) {
          if (!(member in out)) {
            x++;
            out[member] = K.value[member]* weight;
          }

          else
            out[member] = aggregate(K.value[member]* weight, out[member]);
        }
    }

    if (x) this.setKey(key, new ZSET(out));
    return x;
  }

, zsum: function (a, b) { return a + b; }
, zmin: function (a, b) { return a < b ? a : b; }
, zmax: function (a, b) { return a > b ? a : b; }

, zParseOpStore: function (union, args) {
    var key = args[0], N = str2int(args[1]);
    if (N instanceof ERROR) return N;
    if (N < 1) return BAD_ZUIS;
    if (args.length < N + 2) return BAD_ARGS;

    var keys = args.splice(2, N), weigh = (args[2] || '').toUpperCase() === 'WEIGHTS', weights;
    if (weigh) {
      if (args.length < N + 3) return BAD_ARGS;
      weights = args.splice(3, N);
      if (weights.map(str2float).some(function (w) { return w instanceof ERROR; })) return BAD_FLOAT;
      args.splice(2, 1);
    }

    var aggregate = (args[2] || '').toUpperCase() === 'AGGREGATE' ? (args[3] || '').toLowerCase() : null;
    if (aggregate) {
      if (aggregate !== 'sum' && aggregate !== 'min' && aggregate !== 'max') return BAD_SYNTAX;
      aggregate = this['z' + aggregate];
      if (typeof aggregate !== 'function')
        throw new Error("WOOT! Can't find the aggregate function for " + args[3]);
      args.splice(2, 2);
    }

    if (args.length !== 2)
      return BAD_ARGS;

    return this.zOpStore(union, key, keys, weights || null, aggregate || this.zsum);
  }

, ZINTERSTORE: function () {
    return this.zParseOpStore(false, arr(arguments));
  }

, ZUNIONSTORE: function () {
    return this.zParseOpStore(true, arr(arguments));
  }


  // Sort.

, sortSelect: function (pat, kkey) {
    var select = /^((?:.)*?)(?:->(.*))?$/.exec(pat)
      , key = select[1].replace(/\*/, kkey),  // no g flag, so only first occurence is replaced
      field = select[2];

    if (typeof field === 'string')
      return this.HGET(key, field);
    else
      return this.GET(key);
  }

, SORT: function () {
    var self = this, args = arr(arguments), n = args.length;
    if (!n) return new BAD_ARGS;

    // Parse.
    // SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC|DESC] [ALPHA] [STORE destination]

    var key = args.shift()
      , by, limit, offset, count, get, pat, desc, alpha, store
      , seenAscDesc = false;

    if (/^by$/i.test(args[0])) {
      by = args[1];
      if (typeof by !== 'string') return BAD_SYNTAX;
      args.splice(0, 2);
    }

    if (/^limit$/i.test(args[0])) {
      limit = true;
      if (args.length < 3) return BAD_ARGS;
      offset = args[1]; // integer validation happens in slice()
      count = args[2];
      args.splice(0, 3);
    }

    if (/^asc|desc$/i.test(args[0])) {
      desc = /^desc$/i.test(args[0]);
      args.splice(0, 1);
      seenAscDesc = true;
    }

    while (/^get$/i.test(args[0])) {
      pat = args[1];
      if (typeof pat !== 'string') return BAD_SYNTAX;
      if (!get) get = [];
      get.push(pat);
      args.splice(0, 2);
    }

    if (!seenAscDesc)
      if (/^asc|desc$/i.test(args[0])) {
        desc = /^desc$/i.test(args[0]);
        args.splice(0, 1);
        seenAscDesc = true;
      }

    if (/^alpha$/i.test(args[0])) {
      alpha = true;
      args.splice(0, 1);
    }

    if (/^store$/i.test(args[0])) {
      store = args[1];
      if (typeof store !== 'string') return BAD_SYNTAX;
      args.splice(0, 2);
    }

    // Redis appears to accept params in any order,
    // needs some tests before allowing this here.

    if (args.length) return BAD_SYNTAX;

    // Collect data.

    var type = this.TYPE(key), data, scoreFail = false;

    if (type === NONE)
      data = [];
    else if (type === LIST)
      data = this.LRANGE(key, '0', '-1');
    else if (type === SET)
      data = this.SMEMBERS(key);
    else if (type === ZSET)
      data = this.ZRANGE(key, '0', '-1');
    else
      return BAD_TYPE;

    data = data.map(function (id) {
      var entry = { id: id };
      if (by) {
        entry.by = self.sortSelect(by, id);
        if (!alpha)
          entry.num = str2float(entry.by || '0');
      }
      else if (!alpha)
        entry.num = str2float(id);
      else
        entry.num = 0;

      if (entry.num instanceof ERROR)
        scoreFail = true;

      if (get)
        entry.get = get.map(function (get) {
          if (get === '#') return id;
          return self.sortSelect(get, id);
        });

      return entry;
    });

    if (scoreFail) return BAD_SORT;

    // Sort.

    data.sort(function (a, b) {
      var d = a.num - b.num;
      if (!d && by) d = a.by < b.by ? - 1 : a.by > b.by ? 1 : 0;
      if (!d) d = a.id < b.id ? - 1 : a.id > b.id ? 1 : 0;
      return desc ? - d : d;
    });

    // Limit.

    if (parseInt(offset, 10) < 0)
      offset = '0'; // SORT treats negative offset limit differently from other redis commands.

    if (limit) data = slice(data, offset, count, true);

    // Format.

    var out = [], i;
    n = data.length;
    for (i = 0; i < n; i++) {
      if (get) out.push.apply(out, data[i].get);
      else out[i] = data[i].id;
    }

    // Store or return.

    if (store) {
      this.lStore(store, out);
      return this.LLEN(store);
    }
    else
      return out;
  }


  // Pubsub.

, PUBLISH: function (channel, message) {
    return this.pub(channel, message);
  }


  // Connection.
  // Quit and select could be implemented on the connection object.

, PING: function () {
    if (arguments.length)
      return BAD_ARGS;

    return PONG;
  }

, ECHO: function (message) {
    return message;
  }


  // Server.
  // FLUSHALL can be implemented on the connection object.

, DBSIZE: function () {
    return this.getKeys().length;
  }

, FLUSHDB: function () {
    var keys = this.getKeys(), i, n = keys.length;
    for (i = 0; i < n; i++)
      this.setKey(keys[i], null);

    return OK;
  }

, TIME: function () {
    var time = Date.now()
      , sec = Math.round(time / 1000)
      , msec = (time % 1000)* 1000 + Math.floor(Math.random()* 1000);

    return [sec, msec];
  }


  // Helper commands.

, FAKE_DUMP: function (pattern) {
    var keys = this.KEYS(pattern), i, n = keys.length, out = [], key, type;

    for (i = 0; i < n; i++) {
      key = keys[i];
      type = this.TYPE(key);
      out.push(key, this.TTL(key), type.getStatus());

      if (type === STRING)
        out.push(this.GET(key));
      else if (type === LIST)
        out.push(this.LRANGE(key, '0', '-1'));
      else if (type === HASH)
        out.push(this.HGETALL(key));
      else if (type === SET)
        out.push(this.SMEMBERS(key));
      else if (type === ZSET)
        out.push(this.ZRANGE(key, '0', '-1', 'withscores'));
      else
        throw new Error("WOOT! Key type is " + type);
    }

    return out;
  }
};


// These don't have an effect on the dataset, so dummies are safe for tests.

exports.Backend.prototype.AUTH =
exports.Backend.prototype.BGREWRITEAOF =
exports.Backend.prototype.SAVE =
exports.Backend.prototype.BGSAVE = function () { return OK; };


// All of these are implemented at the connection level.

exports.Backend.prototype.QUIT =

exports.Backend.prototype.SUBSCRIBE =
exports.Backend.prototype.PSUBSCRIBE =
exports.Backend.prototype.UNSUBSCRIBE =
exports.Backend.prototype.PUNSUBSCRIBE =

exports.Backend.prototype.MULTI =
exports.Backend.prototype.EXEC =
exports.Backend.prototype.WATCH =
exports.Backend.prototype.UNWATCH =
exports.Backend.prototype.SELECT =
exports.Backend.prototype.DISCARD = function () { throw new Error("WOOT! This command shouldn't have reached the backend."); };