redis 3.1.0 → 3.1.1

package/heroku/node_modules/redis/lib/command.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var betterStackTraces = /development/i.test(process.env.NODE_ENV) || /\bredis\b/i.test(process.env.NODE_DEBUG);
+
+function Command (command, args, callback, call_on_write) {
+    this.command = command;
+    this.args = args;
+    this.buffer_args = false;
+    this.callback = callback;
+    this.call_on_write = call_on_write;
+    if (betterStackTraces) {
+        this.error = new Error();
+    }
+}
+
+module.exports = Command;

package/heroku/node_modules/redis/lib/commands.js

@@ -0,0 +1,105 @@
+'use strict';
+
+var commands = require('redis-commands');
+var Multi = require('./multi');
+var RedisClient = require('../').RedisClient;
+var Command = require('./command');
+
+var addCommand = function (command) {
+    // Some rare Redis commands use special characters in their command name
+    // Convert those to a underscore to prevent using invalid function names
+    var commandName = command.replace(/(?:^([0-9])|[^a-zA-Z0-9_$])/g, '_$1');
+
+    // Do not override existing functions
+    if (!RedisClient.prototype[command]) {
+        RedisClient.prototype[command.toUpperCase()] = RedisClient.prototype[command] = function () {
+            var arr;
+            var len = arguments.length;
+            var callback;
+            var i = 0;
+            if (Array.isArray(arguments[0])) {
+                arr = arguments[0];
+                if (len === 2) {
+                    callback = arguments[1];
+                }
+            } else if (len > 1 && Array.isArray(arguments[1])) {
+                if (len === 3) {
+                    callback = arguments[2];
+                }
+                len = arguments[1].length;
+                arr = new Array(len + 1);
+                arr[0] = arguments[0];
+                for (; i < len; i += 1) {
+                    arr[i + 1] = arguments[1][i];
+                }
+            } else {
+                // The later should not be the average use case
+                if (len !== 0 && (typeof arguments[len - 1] === 'function' || typeof arguments[len - 1] === 'undefined')) {
+                    len--;
+                    callback = arguments[len];
+                }
+                arr = new Array(len);
+                for (; i < len; i += 1) {
+                    arr[i] = arguments[i];
+                }
+            }
+            return this.internal_send_command(new Command(command, arr, callback));
+        };
+        // Alias special function names (e.g. NR.RUN becomes NR_RUN and nr_run)
+        if (commandName !== command) {
+            RedisClient.prototype[commandName.toUpperCase()] = RedisClient.prototype[commandName] = RedisClient.prototype[command];
+        }
+        Object.defineProperty(RedisClient.prototype[command], 'name', {
+            value: commandName
+        });
+    }
+
+    // Do not override existing functions
+    if (!Multi.prototype[command]) {
+        Multi.prototype[command.toUpperCase()] = Multi.prototype[command] = function () {
+            var arr;
+            var len = arguments.length;
+            var callback;
+            var i = 0;
+            if (Array.isArray(arguments[0])) {
+                arr = arguments[0];
+                if (len === 2) {
+                    callback = arguments[1];
+                }
+            } else if (len > 1 && Array.isArray(arguments[1])) {
+                if (len === 3) {
+                    callback = arguments[2];
+                }
+                len = arguments[1].length;
+                arr = new Array(len + 1);
+                arr[0] = arguments[0];
+                for (; i < len; i += 1) {
+                    arr[i + 1] = arguments[1][i];
+                }
+            } else {
+                // The later should not be the average use case
+                if (len !== 0 && (typeof arguments[len - 1] === 'function' || typeof arguments[len - 1] === 'undefined')) {
+                    len--;
+                    callback = arguments[len];
+                }
+                arr = new Array(len);
+                for (; i < len; i += 1) {
+                    arr[i] = arguments[i];
+                }
+            }
+            this.queue.push(new Command(command, arr, callback));
+            return this;
+        };
+        // Alias special function names (e.g. NR.RUN becomes NR_RUN and nr_run)
+        if (commandName !== command) {
+            Multi.prototype[commandName.toUpperCase()] = Multi.prototype[commandName] = Multi.prototype[command];
+        }
+        Object.defineProperty(Multi.prototype[command], 'name', {
+            value: commandName
+        });
+    }
+};
+
+commands.list.forEach(addCommand);
+
+module.exports = addCommand;

package/heroku/node_modules/redis/lib/createClient.js

@@ -0,0 +1,88 @@
+'use strict';
+
+var utils = require('./utils');
+var URL = require('url');
+
+module.exports = function createClient (port_arg, host_arg, options) {
+
+    if (typeof port_arg === 'number' || typeof port_arg === 'string' && /^\d+$/.test(port_arg)) {
+
+        var host;
+        if (typeof host_arg === 'string') {
+            host = host_arg;
+        } else {
+            if (options && host_arg) {
+                throw new TypeError('Unknown type of connection in createClient()');
+            }
+            options = options || host_arg;
+        }
+        options = utils.clone(options);
+        options.host = host || options.host;
+        options.port = port_arg;
+
+    } else if (typeof port_arg === 'string' || port_arg && port_arg.url) {
+
+        options = utils.clone(port_arg.url ? port_arg : host_arg || options);
+        var url = port_arg.url || port_arg;
+        var parsed = URL.parse(url, true, true);
+
+        // [redis:]//[[user][:password]@][host][:port][/db-number][?db=db-number[&password=bar[&option=value]]]
+        if (parsed.slashes) { // We require slashes
+            if (parsed.auth) {
+                var columnIndex = parsed.auth.indexOf(':');
+                options.password = parsed.auth.slice(columnIndex + 1);
+                if (columnIndex > 0) {
+                    options.user = parsed.auth.slice(0, columnIndex);
+                }
+            }
+            if (parsed.protocol) {
+                if (parsed.protocol === 'rediss:') {
+                    options.tls = options.tls || {};
+                } else if (parsed.protocol !== 'redis:') {
+                    console.warn('node_redis: WARNING: You passed "' + parsed.protocol.substring(0, parsed.protocol.length - 1) + '" as protocol instead of the "redis" protocol!');
+                }
+            }
+            if (parsed.pathname && parsed.pathname !== '/') {
+                options.db = parsed.pathname.substr(1);
+            }
+            if (parsed.hostname) {
+                options.host = parsed.hostname;
+            }
+            if (parsed.port) {
+                options.port = parsed.port;
+            }
+            if (parsed.search !== '') {
+                var elem;
+                for (elem in parsed.query) {
+                    // If options are passed twice, only the parsed options will be used
+                    if (elem in options) {
+                        if (options[elem] === parsed.query[elem]) {
+                            console.warn('node_redis: WARNING: You passed the ' + elem + ' option twice!');
+                        } else {
+                            throw new RangeError('The ' + elem + ' option is added twice and does not match');
+                        }
+                    }
+                    options[elem] = parsed.query[elem];
+                }
+            }
+        } else if (parsed.hostname) {
+            throw new RangeError('The redis url must begin with slashes "//" or contain slashes after the redis protocol');
+        } else {
+            options.path = url;
+        }
+
+    } else if (typeof port_arg === 'object' || port_arg === undefined) {
+        options = utils.clone(port_arg || options);
+        options.host = options.host || host_arg;
+
+        if (port_arg && arguments.length !== 1) {
+            throw new TypeError('Too many arguments passed to createClient. Please only pass the options object');
+        }
+    }
+
+    if (!options) {
+        throw new TypeError('Unknown type of connection in createClient()');
+    }
+
+    return options;
+};

package/heroku/node_modules/redis/lib/customErrors.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var util = require('util');
+var assert = require('assert');
+var RedisError = require('redis-errors').RedisError;
+var ADD_STACKTRACE = false;
+
+function AbortError (obj, stack) {
+    assert(obj, 'The options argument is required');
+    assert.strictEqual(typeof obj, 'object', 'The options argument has to be of type object');
+
+    Object.defineProperty(this, 'message', {
+        value: obj.message || '',
+        configurable: true,
+        writable: true
+    });
+    if (stack || stack === undefined) {
+        Error.captureStackTrace(this, AbortError);
+    }
+    for (var keys = Object.keys(obj), key = keys.pop(); key; key = keys.pop()) {
+        this[key] = obj[key];
+    }
+}
+
+function AggregateError (obj) {
+    assert(obj, 'The options argument is required');
+    assert.strictEqual(typeof obj, 'object', 'The options argument has to be of type object');
+
+    AbortError.call(this, obj, ADD_STACKTRACE);
+    Object.defineProperty(this, 'message', {
+        value: obj.message || '',
+        configurable: true,
+        writable: true
+    });
+    Error.captureStackTrace(this, AggregateError);
+    for (var keys = Object.keys(obj), key = keys.pop(); key; key = keys.pop()) {
+        this[key] = obj[key];
+    }
+}
+
+util.inherits(AbortError, RedisError);
+util.inherits(AggregateError, AbortError);
+
+Object.defineProperty(AbortError.prototype, 'name', {
+    value: 'AbortError',
+    configurable: true,
+    writable: true
+});
+Object.defineProperty(AggregateError.prototype, 'name', {
+    value: 'AggregateError',
+    configurable: true,
+    writable: true
+});
+
+module.exports = {
+    AbortError: AbortError,
+    AggregateError: AggregateError
+};

package/heroku/node_modules/redis/lib/debug.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var index = require('../');
+
+function debug () {
+    if (index.debug_mode) {
+        var data = Array.prototype.slice.call(arguments);
+        data.unshift(new Date().toISOString());
+        console.error.apply(null, data);
+    }
+}
+
+module.exports = debug;

package/heroku/node_modules/redis/lib/extendedApi.js

@@ -0,0 +1,113 @@
+'use strict';
+
+var utils = require('./utils');
+var debug = require('./debug');
+var RedisClient = require('../').RedisClient;
+var Command = require('./command');
+var noop = function () {};
+
+/**********************************************
+All documented and exposed API belongs in here
+**********************************************/
+
+// Redirect calls to the appropriate function and use to send arbitrary / not supported commands
+RedisClient.prototype.send_command = RedisClient.prototype.sendCommand = function (command, args, callback) {
+    // Throw to fail early instead of relying in order in this case
+    if (typeof command !== 'string') {
+        throw new TypeError('Wrong input type "' + (command !== null && command !== undefined ? command.constructor.name : command) + '" for command name');
+    }
+    command = command.toLowerCase();
+    if (!Array.isArray(args)) {
+        if (args === undefined || args === null) {
+            args = [];
+        } else if (typeof args === 'function' && callback === undefined) {
+            callback = args;
+            args = [];
+        } else {
+            throw new TypeError('Wrong input type "' + args.constructor.name + '" for args');
+        }
+    }
+    if (typeof callback !== 'function' && callback !== undefined) {
+        throw new TypeError('Wrong input type "' + (callback !== null ? callback.constructor.name : 'null') + '" for callback function');
+    }
+
+    // Using the raw multi command is only possible with this function
+    // If the command is not yet added to the client, the internal function should be called right away
+    // Otherwise we need to redirect the calls to make sure the internal functions don't get skipped
+    // The internal functions could actually be used for any non hooked function
+    // but this might change from time to time and at the moment there's no good way to distinguish them
+    // from each other, so let's just do it do it this way for the time being
+    if (command === 'multi' || typeof this[command] !== 'function') {
+        return this.internal_send_command(new Command(command, args, callback));
+    }
+    if (typeof callback === 'function') {
+        args = args.concat([callback]); // Prevent manipulating the input array
+    }
+    return this[command].apply(this, args);
+};
+
+RedisClient.prototype.end = function (flush) {
+    // Flush queue if wanted
+    if (flush) {
+        this.flush_and_error({
+            message: 'Connection forcefully ended and command aborted.',
+            code: 'NR_CLOSED'
+        });
+    } else if (arguments.length === 0) {
+        this.warn(
+            'Using .end() without the flush parameter is deprecated and throws from v.3.0.0 on.\n' +
+            'Please check the doku (https://github.com/NodeRedis/node_redis) and explictly use flush.'
+        );
+    }
+    // Clear retry_timer
+    if (this.retry_timer) {
+        clearTimeout(this.retry_timer);
+        this.retry_timer = null;
+    }
+    this.stream.removeAllListeners();
+    this.stream.on('error', noop);
+    this.connected = false;
+    this.ready = false;
+    this.closing = true;
+    return this.stream.destroySoon();
+};
+
+RedisClient.prototype.unref = function () {
+    if (this.connected) {
+        debug("Unref'ing the socket connection");
+        this.stream.unref();
+    } else {
+        debug('Not connected yet, will unref later');
+        this.once('connect', function () {
+            this.unref();
+        });
+    }
+};
+
+RedisClient.prototype.duplicate = function (options, callback) {
+    if (typeof options === 'function') {
+        callback = options;
+        options = null;
+    }
+    var existing_options = utils.clone(this.options);
+    options = utils.clone(options);
+    for (var elem in options) {
+        existing_options[elem] = options[elem];
+    }
+    var client = new RedisClient(existing_options);
+    client.selected_db = options.db || this.selected_db;
+    if (typeof callback === 'function') {
+        var ready_listener = function () {
+            callback(null, client);
+            client.removeAllListeners(error_listener);
+        };
+        var error_listener = function (err) {
+            callback(err);
+            client.end(true);
+        };
+        client.once('ready', ready_listener);
+        client.once('error', error_listener);
+        return;
+    }
+    return client;
+};