Lint byline: Use strict equal; const instead of var; arrow function for this; Buffer.from instead of new Buffer

lib/byline.js

@@ -20,138 +20,134 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 // IN THE SOFTWARE.
 
-var stream = require('stream'),
+const stream = require('stream')
-    util = require('util'),
+const util = require('util')
-    timers = require('timers');
+const timers = require('timers')
 
 // convinience API
-module.exports = function(readStream, options) {
+module.exports = function (readStream, options) {
-  return module.exports.createStream(readStream, options);
+  return module.exports.createStream(readStream, options)
-};
+}
 
 // basic API
-module.exports.createStream = function(readStream, options) {
+module.exports.createStream = function (readStream, options) {
   if (readStream) {
-    return createLineStream(readStream, options);
+    return createLineStream(readStream, options)
   } else {
-    return new LineStream(options);
+    return new LineStream(options)
   }
-};
+}
 
 // deprecated API
-module.exports.createLineStream = function(readStream) {
+module.exports.createLineStream = function (readStream) {
-  console.log('WARNING: byline#createLineStream is deprecated and will be removed soon');
+  console.log('WARNING: byline#createLineStream is deprecated and will be removed soon')
-  return createLineStream(readStream);
+  return createLineStream(readStream)
-};
+}
 
-function createLineStream(readStream, options) {
+function createLineStream (readStream, options) {
   if (!readStream) {
-    throw new Error('expected readStream');
+    throw new Error('expected readStream')
   }
   if (!readStream.readable) {
-    throw new Error('readStream must be readable');
+    throw new Error('readStream must be readable')
   }
-  var ls = new LineStream(options);
+  const ls = new LineStream(options)
-  readStream.pipe(ls);
+  readStream.pipe(ls)
-  return ls;
+  return ls
 }
 
 //
 // using the new node v0.10 "streams2" API
 //
 
-module.exports.LineStream = LineStream;
+module.exports.LineStream = LineStream
 
-function LineStream(options) {
+function LineStream (options) {
-  stream.Transform.call(this, options);
+  stream.Transform.call(this, options)
-  options = options || {};
+  options = options || {}
 
   // use objectMode to stop the output from being buffered
   // which re-concatanates the lines, just without newlines.
-  this._readableState.objectMode = true;
+  this._readableState.objectMode = true
-  this._lineBuffer = [];
+  this._lineBuffer = []
-  this._keepEmptyLines = options.keepEmptyLines || false;
+  this._keepEmptyLines = options.keepEmptyLines || false
-  this._lastChunkEndedWithCR = false;
+  this._lastChunkEndedWithCR = false
 
   // take the source's encoding if we don't have one
-  var self = this;
+  const self = this
-  this.on('pipe', function(src) {
+  this.on('pipe', function (src) {
     if (!self.encoding) {
       // but we can't do this for old-style streams
       if (src instanceof stream.Readable) {
-        self.encoding = src._readableState.encoding;
+        self.encoding = src._readableState.encoding
       }
     }
-  });
+  })
 }
-util.inherits(LineStream, stream.Transform);
+util.inherits(LineStream, stream.Transform)
 
-LineStream.prototype._transform = function(chunk, encoding, done) {
+LineStream.prototype._transform = function (chunk, encoding, done) {
   // decode binary chunks as UTF-8
-  encoding = encoding || 'utf8';
+  encoding = encoding || 'utf8'
 
   if (Buffer.isBuffer(chunk)) {
-    if (encoding == 'buffer') {
+    if (encoding === 'buffer') {
-      chunk = chunk.toString(); // utf8
+      chunk = chunk.toString() // utf8
-      encoding = 'utf8';
+      encoding = 'utf8'
-    }
+    } else {
-    else {
+      chunk = chunk.toString(encoding)
-     chunk = chunk.toString(encoding);
     }
   }
-  this._chunkEncoding = encoding;
+  this._chunkEncoding = encoding
 
   // see: http://www.unicode.org/reports/tr18/#Line_Boundaries
-  var lines = chunk.split(/\r\n|[\n\v\f\r\x85\u2028\u2029]/g);
+  const lines = chunk.split(/\r\n|[\n\v\f\r\x85\u2028\u2029]/g)
 
   // don't split CRLF which spans chunks
-  if (this._lastChunkEndedWithCR && chunk[0] == '\n') {
+  if (this._lastChunkEndedWithCR && chunk[0] === '\n') {
-    lines.shift();
+    lines.shift()
   }
 
   if (this._lineBuffer.length > 0) {
-    this._lineBuffer[this._lineBuffer.length - 1] += lines[0];
+    this._lineBuffer[this._lineBuffer.length - 1] += lines[0]
-    lines.shift();
+    lines.shift()
   }
 
-  this._lastChunkEndedWithCR = chunk[chunk.length - 1] == '\r';
+  this._lastChunkEndedWithCR = chunk[chunk.length - 1] === '\r'
-  this._lineBuffer = this._lineBuffer.concat(lines);
+  this._lineBuffer = this._lineBuffer.concat(lines)
-  this._pushBuffer(encoding, 1, done);
+  this._pushBuffer(encoding, 1, done)
-};
+}
 
-LineStream.prototype._pushBuffer = function(encoding, keep, done) {
+LineStream.prototype._pushBuffer = function (encoding, keep, done) {
   // always buffer the last (possibly partial) line
   while (this._lineBuffer.length > keep) {
-    var line = this._lineBuffer.shift();
+    const line = this._lineBuffer.shift()
     // skip empty lines
-    if (this._keepEmptyLines || line.length > 0 ) {
+    if (this._keepEmptyLines || line.length > 0) {
       if (!this.push(this._reencode(line, encoding))) {
         // when the high-water mark is reached, defer pushes until the next tick
-        var self = this;
+        timers.setImmediate(() => {
-        timers.setImmediate(function() {
+          this._pushBuffer(encoding, keep, done)
-          self._pushBuffer(encoding, keep, done);
+        })
-        });
+        return
-        return;
       }
     }
   }
-  done();
+  done()
-};
+}
 
-LineStream.prototype._flush = function(done) {
+LineStream.prototype._flush = function (done) {
-  this._pushBuffer(this._chunkEncoding, 0, done);
+  this._pushBuffer(this._chunkEncoding, 0, done)
-};
+}
 
 // see Readable::push
-LineStream.prototype._reencode = function(line, chunkEncoding) {
+LineStream.prototype._reencode = function (line, chunkEncoding) {
-  if (this.encoding && this.encoding != chunkEncoding) {
+  if (this.encoding && this.encoding !== chunkEncoding) {
-    return new Buffer(line, chunkEncoding).toString(this.encoding);
+    return Buffer.from(line, chunkEncoding).toString(this.encoding)
-  }
+  } else if (this.encoding) {
-  else if (this.encoding) {
     // this should be the most common case, i.e. we're using an encoded source stream
-    return line;
+    return line
-  }
+  } else {
-  else {
+    return Buffer.from(line, chunkEncoding)
-    return new Buffer(line, chunkEncoding);
   }
-};
+}