lint: reduce complexity of parser write method

Author: dougwilson

lib/protocol/Parser.js

@@ -1,9 +1,11 @@
-var MAX_PACKET_LENGTH = Math.pow(2, 24) - 1;
-var MUL_32BIT         = Math.pow(2, 32);
-var PacketHeader      = require('./PacketHeader');
-var BigNumber         = require('bignumber.js');
-var Buffer            = require('safe-buffer').Buffer;
-var BufferList        = require('./BufferList');
+var PacketHeader = require('./PacketHeader');
+var BigNumber    = require('bignumber.js');
+var Buffer       = require('safe-buffer').Buffer;
+var BufferList   = require('./BufferList');
+
+var MAX_PACKET_LENGTH    = Math.pow(2, 24) - 1;
+var MUL_32BIT            = Math.pow(2, 32);
+var PACKET_HEADER_LENGTH = 4;
 
 module.exports = Parser;
 function Parser(options) {
@@ -28,71 +30,17 @@ Parser.prototype.write = function write(chunk) {
   this._nextBuffers.push(chunk);
 
   while (!this._paused) {
-    if (!this._packetHeader) {
-      if (!this._combineNextBuffers(4)) {
-        break;
-      }
-
-      this._packetHeader = new PacketHeader(
-        this.parseUnsignedNumber(3),
-        this.parseUnsignedNumber(1)
-      );
-
-      if (this._packetHeader.number !== this._nextPacketNumber) {
-        var err = new Error(
-          'Packets out of order. Got: ' + this._packetHeader.number + ' ' +
-          'Expected: ' + this._nextPacketNumber
-        );
-
-        err.code  = 'PROTOCOL_PACKETS_OUT_OF_ORDER';
-        err.fatal = true;
+    var packetHeader = this._tryReadPacketHeader();
 
-        this._onError(err);
-      }
-
-      this.incrementPacketNumber();
-    }
-
-    if (!this._combineNextBuffers(this._packetHeader.length)) {
+    if (!packetHeader) {
       break;
     }
 
-    this._packetEnd    = this._offset + this._packetHeader.length;
-    this._packetOffset = this._offset;
-
-    if (this._packetHeader.length === MAX_PACKET_LENGTH) {
-      this._longPacketBuffers.push(this._buffer.slice(this._packetOffset, this._packetEnd));
-
-      this._advanceToNextPacket();
-      continue;
+    if (!this._combineNextBuffers(packetHeader.length)) {
+      break;
     }
 
-    this._combineLongPacketBuffers();
-
-    // Try...finally to ensure exception safety. Unfortunately this is costing
-    // us up to ~10% performance in some benchmarks.
-    var hadException = true;
-    try {
-      this._onPacket(this._packetHeader);
-      hadException = false;
-    } catch (err) {
-      if (!err || typeof err.code !== 'string' || err.code.substr(0, 7) !== 'PARSER_') {
-        throw err; // Rethrow non-MySQL errors
-      }
-
-      // Pass down parser errors
-      this._onError(err);
-      hadException = false;
-    } finally {
-      this._advanceToNextPacket();
-
-      // If we had an exception, the parser while loop will be broken out
-      // of after the finally block. So we need to make sure to re-enter it
-      // to continue parsing any bytes that may already have been received.
-      if (hadException) {
-        process.nextTick(this.write.bind(this));
-      }
-    }
+    this._parsePacket(packetHeader);
   }
 };
 
@@ -468,6 +416,73 @@ Parser.prototype._combineLongPacketBuffers = function _combineLongPacketBuffers(
   this._packetOffset = 0;
 };
 
+Parser.prototype._parsePacket = function _parsePacket(packetHeader) {
+  this._packetEnd    = this._offset + packetHeader.length;
+  this._packetOffset = this._offset;
+
+  if (packetHeader.length === MAX_PACKET_LENGTH) {
+    this._longPacketBuffers.push(this._buffer.slice(this._packetOffset, this._packetEnd));
+    this._advanceToNextPacket();
+    return;
+  }
+
+  this._combineLongPacketBuffers();
+
+  var hadException = true;
+  try {
+    this._onPacket(packetHeader);
+    hadException = false;
+  } catch (err) {
+    if (!err || typeof err.code !== 'string' || err.code.substr(0, 7) !== 'PARSER_') {
+      throw err; // Rethrow non-MySQL errors
+    }
+
+    // Pass down parser errors
+    this._onError(err);
+    hadException = false;
+  } finally {
+    this._advanceToNextPacket();
+
+    // If there was an exception, the parser while loop will be broken out
+    // of after the finally block. So schedule a blank write to re-enter it
+    // to continue parsing any bytes that may already have been received.
+    if (hadException) {
+      process.nextTick(this.write.bind(this));
+    }
+  }
+};
+
+Parser.prototype._tryReadPacketHeader = function _tryReadPacketHeader() {
+  if (this._packetHeader) {
+    return this._packetHeader;
+  }
+
+  if (!this._combineNextBuffers(PACKET_HEADER_LENGTH)) {
+    return null;
+  }
+
+  this._packetHeader = new PacketHeader(
+    this.parseUnsignedNumber(3),
+    this.parseUnsignedNumber(1)
+  );
+
+  if (this._packetHeader.number !== this._nextPacketNumber) {
+    var err = new Error(
+      'Packets out of order. Got: ' + this._packetHeader.number + ' ' +
+      'Expected: ' + this._nextPacketNumber
+    );
+
+    err.code  = 'PROTOCOL_PACKETS_OUT_OF_ORDER';
+    err.fatal = true;
+
+    this._onError(err);
+  }
+
+  this.incrementPacketNumber();
+
+  return this._packetHeader;
+};
+
 Parser.prototype._advanceToNextPacket = function() {
   this._offset       = this._packetEnd;
   this._packetHeader = null;