Improve the js parser further

Handle big data in constant time again
Small performance improvements here and there
Add ReplyError subclass

Author: Ruben Bridgewater

index.js

@@ -1,3 +1,4 @@
 'use strict';
 
 module.exports = require('./lib/parser');
+module.exports.ReplyError = require('./lib/replyError');

lib/javascript.js

@@ -1,5 +1,6 @@
 'use strict';
-/*jshint latedef: nofunc */
+
+var ReplyError = require('./replyError');
 
 /**
  * Used for lengths only, faster perf on arrays / bulks
@@ -24,7 +25,6 @@ function parseSimpleString(parser) {
 		}
 		string += String.fromCharCode(c1);
 	}
-	return undefined;
 }
 
 /**
@@ -33,12 +33,11 @@ function parseSimpleString(parser) {
  * @param parser
  * @param start
  * @param end
- * @param noBuffer
  * @returns {*}
  */
-function convertBufferRange(parser, start, end, noBuffer) {
+function convertBufferRange(parser, start, end) {
 	// If returnBuffers is active, all return values are returned as buffers besides numbers and errors
-	if (!noBuffer && parser.optionReturnBuffers === true) {
+	if (parser.optionReturnBuffers === true) {
 		return parser.buffer.slice(start, end);
 	}
 
@@ -49,25 +48,20 @@ function convertBufferRange(parser, start, end, noBuffer) {
  * Parse a '+' redis simple string response but forward the offsets
  * onto convertBufferRange to generate a string.
  * @param parser
- * @param noBuffer
  * @returns {*}
  */
-function parseSimpleStringViaOffset(parser, noBuffer) {
+function parseSimpleStringViaOffset(parser) {
 	var start = parser.offset;
 	var offset = parser.offset;
 	var length = parser.buffer.length;
 
 	while (offset < length) {
 		var c1 = parser.buffer[offset++];
-		if (c1 === 13) { // \r
-			var c2 = parser.buffer[offset++];
-			if (c2 === 10) { // \n
-				parser.offset = offset;
-				return convertBufferRange(parser, start, offset - 2, noBuffer);
-			}
+		if (c1 === 13) { // \r // Finding a \r is sufficient here, since in a simple string \r is always followed by \n
+			parser.offset = offset + 1;
+			return convertBufferRange(parser, start, offset - 1);
 		}
 	}
-	return undefined;
 }
 
 /**
@@ -76,14 +70,7 @@ function parseSimpleStringViaOffset(parser, noBuffer) {
  * @returns {*}
  */
 function parseLength(parser) {
-	var string;
-	/* istanbul ignore if  */
-	if (parser.buffer.length > 4096) {
-		 string = parseSimpleStringViaOffset(parser, true);
-	} else {
-		string = parseSimpleString(parser);
-	}
-	
+	var string = parseSimpleString(parser);
 	if (string !== undefined) {
 		var length = +string;
 		if (length === -1) {
@@ -99,7 +86,7 @@ function parseLength(parser) {
  * @returns {*}
  */
 function parseInteger(parser) {
-	var string = parseSimpleStringViaOffset(parser);
+	var string = parseSimpleString(parser);
 	if (string !== undefined) {
 		// If stringNumbers is activated the parser always returns numbers as string
 		// This is important for big numbers (number > Math.pow(2, 53)) as js numbers
@@ -114,16 +101,18 @@ function parseInteger(parser) {
 /**
  * Parse a '$' redis bulk string response
  * @param parser
- * @returns {null}
+ * @returns {*}
  */
 function parseBulkString(parser) {
 	var length = parseLength(parser);
-	/* jshint eqnull: true */
-	if (length == null) {
+	if (length === null || length === undefined) {
 		return length;
 	}
 	var offsetEnd = parser.offset + length;
-	if ((offsetEnd + 2) > parser.buffer.length) {
+	if (offsetEnd + 2 > parser.buffer.length) {
+		parser.bufferCache.push(parser.buffer);
+		parser.totalChunkSize = parser.buffer.length;
+		parser.bigStrSize = length + 2;
 		return;
 	}
 
@@ -139,9 +128,9 @@ function parseBulkString(parser) {
  * @returns {Error}
  */
 function parseError(parser) {
-	var string = parseSimpleStringViaOffset(parser);
-	if (string !== undefined) {
-		return new Error(string);
+	var str = parseSimpleString(parser);
+	if (str !== undefined) {
+		return new ReplyError(str);
 	}
 }
 
@@ -162,8 +151,7 @@ function handleError(parser, error) {
  */
 function parseArray(parser) {
 	var length = parseLength(parser);
-	/* jshint eqnull: true */
-	if (length == null) { // will break if using ===
+	if (length === null || length === undefined) {
 		return length;
 	}
 
@@ -189,6 +177,7 @@ function parseArray(parser) {
  * @param type
  * @returns {*}
  */
+
 function parseType(parser, type) {
 	switch (type) {
 		case 36: // $
@@ -202,37 +191,24 @@ function parseType(parser, type) {
 		case 45: // -
 			return parseError(parser);
 		default:
-			return handleError(parser, new Error('Protocol error, got ' + JSON.stringify(String.fromCharCode(type)) + ' as reply type byte'));
+			return handleError(parser, new ReplyError('Protocol error, got ' + JSON.stringify(String.fromCharCode(type)) + ' as reply type byte'));
 	}
 }
 
-/**
- * Quick buffer appending via buffer copy.
- * @param parser
- * @param buffer
- */
-function appendToBuffer(parser, buffer) {
-	var oldLength = parser.buffer.length;
-	var remainingLength = oldLength - parser.offset;
-	var newLength = remainingLength + buffer.length;
-	var newBuffer = new Buffer(newLength);
-	parser.buffer.copy(newBuffer, 0, parser.offset, oldLength);
-	buffer.copy(newBuffer, remainingLength, 0, buffer.length);
-	parser.buffer = newBuffer;
-	parser.offset = 0;
-}
-
 /**
  * Javascript Redis Parser
  * @param options
  * @constructor
  */
 function JavascriptRedisParser(options) {
-	this.optionReturnBuffers = !!options.return_buffers;
-	this.optionStringNumbers = !!options.string_numbers;
+	this.optionReturnBuffers = !!options.returnBuffers;
+	this.optionStringNumbers = !!options.stringNumbers;
 	this.name = 'javascript';
 	this.offset = 0;
 	this.buffer = null;
+	this.bigStrSize = 0;
+	this.totalChunkSize = 0;
+	this.bufferCache = [];
 }
 
 /**
@@ -243,8 +219,29 @@ JavascriptRedisParser.prototype.execute = function (buffer) {
 	if (this.buffer === null) {
 		this.buffer = buffer;
 		this.offset = 0;
+	} else if (this.bigStrSize === 0) {
+		var oldLength = this.buffer.length;
+		var remainingLength = oldLength - this.offset;
+		var newLength = remainingLength + buffer.length;
+		var newBuffer = new Buffer(newLength);
+		this.buffer.copy(newBuffer, 0, this.offset, oldLength);
+		buffer.copy(newBuffer, remainingLength, 0, buffer.length);
+		this.buffer = newBuffer;
+		this.offset = 0;
+	} else if (this.totalChunkSize + buffer.length >= this.bigStrSize) {
+		this.bufferCache.push(buffer);
+		if (this.offset !== 0) {
+			this.bufferCache[0] = this.bufferCache[0].slice(this.offset);
+		}
+		this.buffer = Buffer.concat(this.bufferCache, this.totalChunkSize + buffer.length - this.offset);
+		this.bigStrSize = 0;
+		this.totalChunkSize = 0;
+		this.bufferCache = [];
+		this.offset = 0;
 	} else {
-		appendToBuffer(this, buffer);
+		this.bufferCache.push(buffer);
+		this.totalChunkSize += buffer.length;
+		return;
 	}
 
 	var length = this.buffer.length;

lib/replyError.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var util = require('util');
+
+function ReplyError (message) {
+	var limit = Error.stackTraceLimit;
+	Error.stackTraceLimit = 2;
+	Error.captureStackTrace(this, this.constructor);
+	Error.stackTraceLimit = limit;
+	Object.defineProperty(this, 'name', {
+		value: 'ReplyError',
+		configurable: false,
+		enumerable: false,
+		writable: true
+	});
+	Object.defineProperty(this, 'message', {
+		value: message || '',
+		configurable: false,
+		enumerable: false,
+		writable: true
+	});
+}
+
+util.inherits(ReplyError, Error);
+
+module.exports = ReplyError;