more lint

1 files changed, 154 insertions, 129 deletions

diff --git a/lib/fs.js b/lib/fs.js
index 938ffdc81e..b9e6b2d716 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -10,54 +10,57 @@ var kPoolSize = 40 * 1024;
 
 fs.Stats = binding.Stats;
 
-fs.Stats.prototype._checkModeProperty = function (property) {
+fs.Stats.prototype._checkModeProperty = function(property) {
   return ((this.mode & constants.S_IFMT) === property);
 };
 
-fs.Stats.prototype.isDirectory = function () {
+fs.Stats.prototype.isDirectory = function() {
   return this._checkModeProperty(constants.S_IFDIR);
 };
 
-fs.Stats.prototype.isFile = function () {
+fs.Stats.prototype.isFile = function() {
   return this._checkModeProperty(constants.S_IFREG);
 };
 
-fs.Stats.prototype.isBlockDevice = function () {
+fs.Stats.prototype.isBlockDevice = function() {
   return this._checkModeProperty(constants.S_IFBLK);
 };
 
-fs.Stats.prototype.isCharacterDevice = function () {
+fs.Stats.prototype.isCharacterDevice = function() {
   return this._checkModeProperty(constants.S_IFCHR);
 };
 
-fs.Stats.prototype.isSymbolicLink = function () {
+fs.Stats.prototype.isSymbolicLink = function() {
   return this._checkModeProperty(constants.S_IFLNK);
 };
 
-fs.Stats.prototype.isFIFO = function () {
+fs.Stats.prototype.isFIFO = function() {
   return this._checkModeProperty(constants.S_IFIFO);
 };
 
-fs.Stats.prototype.isSocket = function () {
+fs.Stats.prototype.isSocket = function() {
   return this._checkModeProperty(constants.S_IFSOCK);
 };
 
-fs.readFile = function (path, encoding_) {
+fs.readFile = function(path, encoding_) {
   var encoding = typeof(encoding_) === 'string' ? encoding_ : null;
-  var callback = arguments[arguments.length-1];
+  var callback = arguments[arguments.length - 1];
   if (typeof(callback) !== 'function') callback = noop;
   var readStream = fs.createReadStream(path);
   var buffers = [];
   var nread = 0;
-  readStream.on("data", function (chunk) {
+
+  readStream.on('data', function(chunk) {
     buffers.push(chunk);
     nread += chunk.length;
   });
-  readStream.on("error", function (er) {
+
+  readStream.on('error', function(er) {
     callback(er);
     readStream.destroy();
   });
-  readStream.on("end", function () {
+
+  readStream.on('end', function() {
     // copy all the buffers into one
     var buffer;
     switch (buffers.length) {
@@ -66,7 +69,7 @@ fs.readFile = function (path, encoding_) {
       default: // concat together
         buffer = new Buffer(nread);
         var n = 0;
-        buffers.forEach(function (b) {
+        buffers.forEach(function(b) {
           var l = b.length;
           b.copy(buffer, n, 0, l);
           n += l;
@@ -84,7 +87,7 @@ fs.readFile = function (path, encoding_) {
   });
 };
 
-fs.readFileSync = function (path, encoding) {
+fs.readFileSync = function(path, encoding) {
   var fd = fs.openSync(path, constants.O_RDONLY, 0666);
   var buffer = new Buffer(4048);
   var buffers = [];
@@ -107,13 +110,14 @@ fs.readFileSync = function (path, encoding) {
     var offset = 0;
     var i;
     buffer = new Buffer(nread);
-    buffers.forEach(function (i) {
+    buffers.forEach(function(i) {
       if (!i._bytesRead) return;
-      i.copy(buffer,offset,0,i._bytesRead);
+      i.copy(buffer, offset, 0, i._bytesRead);
       offset += i._bytesRead;
     });
   } else if (buffers.length) {
-    //buffers has exactly 1 (possibly zero length) buffer, so this should be a shortcut
+    // buffers has exactly 1 (possibly zero length) buffer, so this should
+    // be a shortcut
     buffer = buffers[0].slice(0, buffers[0]._bytesRead);
   } else {
     buffer = new Buffer(0);
@@ -131,30 +135,43 @@ function stringToFlags(flag) {
     return flag;
   }
   switch (flag) {
-    case "r": return constants.O_RDONLY;
-    case "r+": return constants.O_RDWR;
-    case "w": return constants.O_CREAT | constants.O_TRUNC | constants.O_WRONLY;
-    case "w+": return constants.O_CREAT | constants.O_TRUNC | constants.O_RDWR;
-    case "a": return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY;
-    case "a+": return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR;
-    default: throw new Error("Unknown file open flag: " + flag);
+    case 'r':
+      return constants.O_RDONLY;
+
+    case 'r+':
+      return constants.O_RDWR;
+
+    case 'w':
+      return constants.O_CREAT | constants.O_TRUNC | constants.O_WRONLY;
+
+    case 'w+':
+      return constants.O_CREAT | constants.O_TRUNC | constants.O_RDWR;
+
+    case 'a':
+      return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY;
+
+    case 'a+':
+      return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR;
+
+    default:
+      throw new Error('Unknown file open flag: ' + flag);
   }
 }
 
-function noop () {}
+function noop() {}
 
 // Yes, the follow could be easily DRYed up but I provide the explicit
 // list to make the arguments clear.
 
-fs.close = function (fd, callback) {
+fs.close = function(fd, callback) {
   binding.close(fd, callback || noop);
 };
 
-fs.closeSync = function (fd) {
+fs.closeSync = function(fd) {
   return binding.close(fd);
 };
 
-fs.open = function (path, flags, mode_, callback) {
+fs.open = function(path, flags, mode_, callback) {
   var mode = (typeof(mode_) == 'number' ? mode_ : 0666);
   var callback_ = arguments[arguments.length - 1];
   var callback = (typeof(callback_) == 'function' ? callback_ : null);
@@ -162,12 +179,12 @@ fs.open = function (path, flags, mode_, callback) {
   binding.open(path, stringToFlags(flags), mode, callback || noop);
 };
 
-fs.openSync = function (path, flags, mode) {
+fs.openSync = function(path, flags, mode) {
   if (mode === undefined) { mode = 0666; }
   return binding.open(path, stringToFlags(flags), mode);
 };
 
-fs.read = function (fd, buffer, offset, length, position, callback) {
+fs.read = function(fd, buffer, offset, length, position, callback) {
   if (!Buffer.isBuffer(buffer)) {
     // legacy string interface (fd, length, position, encoding, callback)
     var cb = arguments[4],
@@ -180,9 +197,7 @@ fs.read = function (fd, buffer, offset, length, position, callback) {
     callback = function(err, bytesRead) {
       if (!cb) return;
 
-      var str = (bytesRead > 0)
-        ? buffer.toString(encoding, 0, bytesRead)
-        : '';
+      var str = (bytesRead > 0) ? buffer.toString(encoding, 0, bytesRead) : '';
 
       (cb)(err, str, bytesRead);
     };
@@ -191,7 +206,7 @@ fs.read = function (fd, buffer, offset, length, position, callback) {
   binding.read(fd, buffer, offset, length, position, callback || noop);
 };
 
-fs.readSync = function (fd, buffer, offset, length, position) {
+fs.readSync = function(fd, buffer, offset, length, position) {
   var legacy = false;
   if (!Buffer.isBuffer(buffer)) {
     // legacy string interface (fd, length, position, encoding, callback)
@@ -209,19 +224,17 @@ fs.readSync = function (fd, buffer, offset, length, position) {
     return r;
   }
 
-  var str = (r > 0)
-      ? buffer.toString(encoding, 0, r)
-      : '';
+  var str = (r > 0) ? buffer.toString(encoding, 0, r) : '';
   return [str, r];
 };
 
-fs.write = function (fd, buffer, offset, length, position, callback) {
+fs.write = function(fd, buffer, offset, length, position, callback) {
   if (!Buffer.isBuffer(buffer)) {
     // legacy string interface (fd, data, position, encoding, callback)
     callback = arguments[4];
     position = arguments[2];
 
-    buffer = new Buffer(''+arguments[1], arguments[3]);
+    buffer = new Buffer('' + arguments[1], arguments[3]);
     offset = 0;
     length = buffer.length;
   }
@@ -238,145 +251,145 @@ fs.write = function (fd, buffer, offset, length, position, callback) {
   binding.write(fd, buffer, offset, length, position, callback || noop);
 };
 
-fs.writeSync = function (fd, buffer, offset, length, position) {
+fs.writeSync = function(fd, buffer, offset, length, position) {
   if (!Buffer.isBuffer(buffer)) {
     // legacy string interface (fd, data, position, encoding)
     position = arguments[2];
 
-    buffer = new Buffer(''+arguments[1], arguments[3]);
+    buffer = new Buffer('' + arguments[1], arguments[3]);
     offset = 0;
     length = buffer.length;
   }
-  if(!length) return 0;
+  if (!length) return 0;
 
   return binding.write(fd, buffer, offset, length, position);
 };
 
-fs.rename = function (oldPath, newPath, callback) {
+fs.rename = function(oldPath, newPath, callback) {
   binding.rename(oldPath, newPath, callback || noop);
 };
 
-fs.renameSync = function (oldPath, newPath) {
+fs.renameSync = function(oldPath, newPath) {
   return binding.rename(oldPath, newPath);
 };
 
-fs.truncate = function (fd, len, callback) {
+fs.truncate = function(fd, len, callback) {
   binding.truncate(fd, len, callback || noop);
 };
 
-fs.truncateSync = function (fd, len) {
+fs.truncateSync = function(fd, len) {
   return binding.truncate(fd, len);
 };
 
-fs.rmdir = function (path, callback) {
+fs.rmdir = function(path, callback) {
   binding.rmdir(path, callback || noop);
 };
 
-fs.rmdirSync = function (path) {
+fs.rmdirSync = function(path) {
   return binding.rmdir(path);
 };
 
-fs.fdatasync = function (fd, callback) {
+fs.fdatasync = function(fd, callback) {
   binding.fdatasync(fd, callback || noop);
 };
 
-fs.fdatasyncSync = function (fd) {
+fs.fdatasyncSync = function(fd) {
   return binding.fdatasync(fd);
 };
 
-fs.fsync = function (fd, callback) {
+fs.fsync = function(fd, callback) {
   binding.fsync(fd, callback || noop);
 };
 
-fs.fsyncSync = function (fd) {
+fs.fsyncSync = function(fd) {
   return binding.fsync(fd);
 };
 
-fs.mkdir = function (path, mode, callback) {
+fs.mkdir = function(path, mode, callback) {
   binding.mkdir(path, mode, callback || noop);
 };
 
-fs.mkdirSync = function (path, mode) {
+fs.mkdirSync = function(path, mode) {
   return binding.mkdir(path, mode);
 };
 
-fs.sendfile = function (outFd, inFd, inOffset, length, callback) {
+fs.sendfile = function(outFd, inFd, inOffset, length, callback) {
   binding.sendfile(outFd, inFd, inOffset, length, callback || noop);
 };
 
-fs.sendfileSync = function (outFd, inFd, inOffset, length) {
+fs.sendfileSync = function(outFd, inFd, inOffset, length) {
   return binding.sendfile(outFd, inFd, inOffset, length);
 };
 
-fs.readdir = function (path, callback) {
+fs.readdir = function(path, callback) {
   binding.readdir(path, callback || noop);
 };
 
-fs.readdirSync = function (path) {
+fs.readdirSync = function(path) {
   return binding.readdir(path);
 };
 
-fs.fstat = function (fd, callback) {
+fs.fstat = function(fd, callback) {
   binding.fstat(fd, callback || noop);
 };
 
-fs.lstat = function (path, callback) {
+fs.lstat = function(path, callback) {
   binding.lstat(path, callback || noop);
 };
 
-fs.stat = function (path, callback) {
+fs.stat = function(path, callback) {
   binding.stat(path, callback || noop);
 };
 
-fs.fstatSync = function (fd) {
+fs.fstatSync = function(fd) {
   return binding.fstat(fd);
 };
 
-fs.lstatSync = function (path) {
+fs.lstatSync = function(path) {
   return binding.lstat(path);
 };
 
-fs.statSync = function (path) {
+fs.statSync = function(path) {
   return binding.stat(path);
 };
 
-fs.readlink = function (path, callback) {
+fs.readlink = function(path, callback) {
   binding.readlink(path, callback || noop);
 };
 
-fs.readlinkSync = function (path) {
+fs.readlinkSync = function(path) {
   return binding.readlink(path);
 };
 
-fs.symlink = function (destination, path, callback) {
+fs.symlink = function(destination, path, callback) {
   binding.symlink(destination, path, callback || noop);
 };
 
-fs.symlinkSync = function (destination, path) {
+fs.symlinkSync = function(destination, path) {
   return binding.symlink(destination, path);
 };
 
-fs.link = function (srcpath, dstpath, callback) {
+fs.link = function(srcpath, dstpath, callback) {
   binding.link(srcpath, dstpath, callback || noop);
 };
 
-fs.linkSync = function (srcpath, dstpath) {
+fs.linkSync = function(srcpath, dstpath) {
   return binding.link(srcpath, dstpath);
 };
 
-fs.unlink = function (path, callback) {
+fs.unlink = function(path, callback) {
   binding.unlink(path, callback || noop);
 };
 
-fs.unlinkSync = function (path) {
+fs.unlinkSync = function(path) {
   return binding.unlink(path);
 };
 
-fs.chmod = function (path, mode, callback) {
+fs.chmod = function(path, mode, callback) {
   binding.chmod(path, mode, callback || noop);
 };
 
-fs.chmodSync = function (path, mode) {
+fs.chmodSync = function(path, mode) {
   return binding.chmod(path, mode);
 };
 
@@ -388,28 +401,28 @@ fs.chownSync = function(path, uid, gid) {
   return binding.chown(path, uid, gid);
 };
 
-function writeAll (fd, buffer, offset, length, callback) {
+function writeAll(fd, buffer, offset, length, callback) {
   // write(fd, buffer, offset, length, position, callback)
-  fs.write(fd, buffer, offset, length, offset, function (writeErr, written) {
+  fs.write(fd, buffer, offset, length, offset, function(writeErr, written) {
     if (writeErr) {
-      fs.close(fd, function () {
+      fs.close(fd, function() {
         if (callback) callback(writeErr);
       });
     } else {
       if (written === length) {
         fs.close(fd, callback);
       } else {
-        writeAll(fd, buffer, offset+written, length-written, callback);
+        writeAll(fd, buffer, offset + written, length - written, callback);
       }
     }
   });
 }
 
-fs.writeFile = function (path, data, encoding_, callback) {
+fs.writeFile = function(path, data, encoding_, callback) {
   var encoding = (typeof(encoding_) == 'string' ? encoding_ : 'utf8');
   var callback_ = arguments[arguments.length - 1];
   var callback = (typeof(callback_) == 'function' ? callback_ : null);
-  fs.open(path, 'w', 0666, function (openErr, fd) {
+  fs.open(path, 'w', 0666, function(openErr, fd) {
     if (openErr) {
       if (callback) callback(openErr);
     } else {
@@ -419,16 +432,16 @@ fs.writeFile = function (path, data, encoding_, callback) {
   });
 };
 
-fs.writeFileSync = function (path, data, encoding) {
-  var fd = fs.openSync(path, "w");
+fs.writeFileSync = function(path, data, encoding) {
+  var fd = fs.openSync(path, 'w');
   if (!Buffer.isBuffer(data)) {
-    data = new Buffer(data, encoding || "utf8")
+    data = new Buffer(data, encoding || 'utf8');
   }
   var written = 0;
   var length = data.length;
   //writeSync(fd, buffer, offset, length, position)
   while (written < length) {
-    written += fs.writeSync(fd, data, written, length-written, written);
+    written += fs.writeSync(fd, data, written, length - written, written);
   }
   fs.closeSync(fd);
 };
@@ -437,12 +450,12 @@ fs.writeFileSync = function (path, data, encoding) {
 
 var statWatchers = {};
 
-fs.watchFile = function (filename) {
+fs.watchFile = function(filename) {
   var stat;
   var options;
   var listener;
 
-  if ("object" == typeof arguments[1]) {
+  if ('object' == typeof arguments[1]) {
     options = arguments[1];
     listener = arguments[2];
   } else {
@@ -460,11 +473,11 @@ fs.watchFile = function (filename) {
     stat = statWatchers[filename];
     stat.start(filename, options.persistent, options.interval);
   }
-  stat.addListener("change", listener);
+  stat.addListener('change', listener);
   return stat;
 };
 
-fs.unwatchFile = function (filename) {
+fs.unwatchFile = function(filename) {
   var stat;
   if (statWatchers[filename]) {
     stat = statWatchers[filename];
@@ -484,7 +497,7 @@ var normalizeArray = path.normalizeArray;
 // See: http://insanecoding.blogspot.com/2007/11/pathmax-simply-isnt.html
 fs.realpathSync = realpathSync;
 fs.realpath = realpath;
-function realpathSync (p) {
+function realpathSync(p) {
   if (p.charAt(0) !== '/') {
     p = path.join(process.cwd(), p);
   }
@@ -496,26 +509,31 @@ function realpathSync (p) {
   // values, and pushing non-link path bits onto the buffer.
   // then return the buffer.
   // NB: path.length changes.
-  for (var i = 0; i < p.length; i ++) {
+  for (var i = 0; i < p.length; i++) {
     // skip over empty path parts.
     if (p[i] === '') continue;
+
     var part = path.join.apply(path, buf.concat(p[i]));
+
     if (knownHard[part]) {
-      buf.push( p[i] );
+      buf.push(p[i]);
       continue;
     }
+
     var stat = fs.lstatSync(part);
     if (!stat.isSymbolicLink()) {
       // not a symlink. easy.
-      knownHard[ part ] = true;
+      knownHard[part] = true;
       buf.push(p[i]);
       continue;
     }
-    var id = stat.dev.toString(32)+':'+stat.ino.toString(32);
+
+    var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
     if (!seenLinks[id]) {
       fs.statSync(part);
       seenLinks[id] = fs.readlinkSync(part);
     }
+
     var target = seenLinks[id];
     if (target.charAt(0) === '/') {
       // absolute. Start over.
@@ -524,9 +542,10 @@ function realpathSync (p) {
       i = -1;
       continue;
     }
+
     // not absolute.  join and splice.
-    if (i === 0 && p[i].charAt(0) === "/") {
-      target = "/"+target;
+    if (i === 0 && p[i].charAt(0) === '/') {
+      target = '/' + target;
     }
     target = path.split(target);
     Array.prototype.splice.apply(p, [i, 1].concat(target));
@@ -538,7 +557,7 @@ function realpathSync (p) {
 }
 
 
-function realpath (p, cb) {
+function realpath(p, cb) {
   if (p.charAt(0) !== '/') {
     p = path.join(process.cwd(), p);
   }
@@ -552,37 +571,41 @@ function realpath (p, cb) {
   // NB: path.length changes.
   var i = -1;
   var part;
+
   LOOP();
-  function LOOP () {
-    i ++;
+  function LOOP() {
+    i++;
     if (!(i < p.length)) return exit();
     // skip over empty path parts.
     if (p[i] === '') return process.nextTick(LOOP);
-    part = path.join(buf.join('/')+'/'+p[i]);
+    part = path.join(buf.join('/') + '/' + p[i]);
     if (knownHard[part]) {
-      buf.push( p[i] );
+      buf.push(p[i]);
       return process.nextTick(LOOP);
     }
     return fs.lstat(part, gotStat);
   }
-  function gotStat (er, stat) {
+
+  function gotStat(er, stat) {
     if (er) return cb(er);
     if (!stat.isSymbolicLink()) {
       // not a symlink. easy.
-      knownHard[ part ] = true;
+      knownHard[part] = true;
       buf.push(p[i]);
       return process.nextTick(LOOP);
     }
-    var id = stat.dev.toString(32)+':'+stat.ino.toString(32);
+
+    var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
     if (seenLinks[id]) return gotTarget(null, seenLinks[id]);
-    fs.stat(part, function (er) {
-      if (er) return cb(er)
-      fs.readlink(part, function (er, target) {
+    fs.stat(part, function(er) {
+      if (er) return cb(er);
+      fs.readlink(part, function(er, target) {
         gotTarget(er, seenLinks[id] = target);
       });
-    })
+    });
   }
-  function gotTarget (er, target) {
+
+  function gotTarget(er, target) {
     if (er) return cb(er);
     if (target.charAt(0) === '/') {
       // absolute. Start over.
@@ -592,8 +615,8 @@ function realpath (p, cb) {
       return process.nextTick(LOOP);
     }
     // not absolute.  join and splice.
-    if (i === 0 && p[i].charAt(0) === "/") {
-      target = "/"+target;
+    if (i === 0 && p[i].charAt(0) === '/') {
+      target = '/' + target;
     }
     target = path.split(target);
     Array.prototype.splice.apply(p, [i, 1].concat(target));
@@ -602,13 +625,15 @@ function realpath (p, cb) {
     buf = [];
     return process.nextTick(LOOP);
   }
-  function exit () {
+
+  function exit() {
     cb(null, path.join(buf.join('/') || '/'));
   }
 }
 
 var pool;
-function allocNewPool () {
+
+function allocNewPool() {
   pool = new Buffer(kPoolSize);
   pool.used = 0;
 }
@@ -644,12 +669,12 @@ var ReadStream = fs.ReadStream = function(path, options) {
     this[key] = options[key];
   }
 
-  if(this.encoding) this.setEncoding(this.encoding);
+  if (this.encoding) this.setEncoding(this.encoding);
 
   if (this.start !== undefined || this.end !== undefined) {
     if (this.start === undefined || this.end === undefined) {
-      this.emit('error',
-        new Error('Both start and end are needed for range streaming.'));
+      this.emit('error', new Error('Both start and end are needed ' +
+                                   'for range streaming.'));
     } else if (this.start > this.end) {
       this.emit('error', new Error('start must be <= end'));
     } else {
@@ -677,13 +702,13 @@ util.inherits(ReadStream, Stream);
 
 fs.FileReadStream = fs.ReadStream; // support the legacy name
 
-ReadStream.prototype.setEncoding = function (encoding) {
-  var StringDecoder = require("string_decoder").StringDecoder; // lazy load
+ReadStream.prototype.setEncoding = function(encoding) {
+  var StringDecoder = require('string_decoder').StringDecoder; // lazy load
   this._decoder = new StringDecoder(encoding);
 };
 
 
-ReadStream.prototype._read = function () {
+ReadStream.prototype._read = function() {
   var self = this;
   if (!self.readable || self.paused) return;
 
@@ -710,7 +735,7 @@ ReadStream.prototype._read = function () {
     toRead = Math.min(this.end - this.pos + 1, toRead);
   }
 
-  function afterRead (err, bytesRead) {
+  function afterRead(err, bytesRead) {
     if (err) {
       self.emit('error', err);
       self.readable = false;
@@ -723,7 +748,7 @@ ReadStream.prototype._read = function () {
       return;
     }
 
-    var b = thisPool.slice(start, start+bytesRead);
+    var b = thisPool.slice(start, start + bytesRead);
 
     // Possible optimizition here?
     // Reclaim some bytes if bytesRead < toRead?
@@ -751,7 +776,7 @@ ReadStream.prototype._read = function () {
 };
 
 
-ReadStream.prototype._emitData = function (d) {
+ReadStream.prototype._emitData = function(d) {
   if (this._decoder) {
     var string = this._decoder.write(d);
     if (string.length) this.emit('data', string);
@@ -761,7 +786,7 @@ ReadStream.prototype._emitData = function (d) {
 };
 
 
-ReadStream.prototype.destroy = function (cb) {
+ReadStream.prototype.destroy = function(cb) {
   var self = this;
   this.readable = false;
 
@@ -842,7 +867,7 @@ util.inherits(WriteStream, Stream);
 
 fs.FileWriteStream = fs.WriteStream; // support the legacy name
 
-WriteStream.prototype.flush = function () {
+WriteStream.prototype.flush = function() {
   if (this.busy) return;
   var self = this;
 
@@ -900,7 +925,7 @@ WriteStream.prototype.flush = function () {
   method.apply(this, args);
 };
 
-WriteStream.prototype.write = function (data) {
+WriteStream.prototype.write = function(data) {
   if (!this.writable) {
     throw new Error('stream not writable');
   }
@@ -908,8 +933,8 @@ WriteStream.prototype.write = function (data) {
   this.drainable = true;
 
   var cb;
-  if (typeof(arguments[arguments.length-1]) == 'function') {
-    cb = arguments[arguments.length-1];
+  if (typeof(arguments[arguments.length - 1]) == 'function') {
+    cb = arguments[arguments.length - 1];
   }
 
   if (Buffer.isBuffer(data)) {
@@ -926,13 +951,13 @@ WriteStream.prototype.write = function (data) {
   return false;
 };
 
-WriteStream.prototype.end = function (cb) {
+WriteStream.prototype.end = function(cb) {
   this.writable = false;
   this._queue.push([fs.close, cb]);
   this.flush();
 };
 
-WriteStream.prototype.destroy = function (cb) {
+WriteStream.prototype.destroy = function(cb) {
   var self = this;
   this.writable = false;