LukasMeine / vigilance

node_modules/from2/index.js

var Readable = require('readable-stream').Readable
var inherits = require('inherits')

module.exports = from2

from2.ctor = ctor
from2.obj = obj

var Proto = ctor()

function toFunction(list) {
  list = list.slice()
  return function (_, cb) {
    var err = null
    var item = list.length ? list.shift() : null
    if (item instanceof Error) {
      err = item
      item = null
    }

    cb(err, item)
  }
}

function from2(opts, read) {
  if (typeof opts !== 'object' || Array.isArray(opts)) {
    read = opts
    opts = {}
  }

  var rs = new Proto(opts)
  rs._from = Array.isArray(read) ? toFunction(read) : (read || noop)
  return rs
}

function ctor(opts, read) {
  if (typeof opts === 'function') {
    read = opts
    opts = {}
  }

  opts = defaults(opts)

  inherits(Class, Readable)
  function Class(override) {
    if (!(this instanceof Class)) return new Class(override)

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

    this._reading = false
    this._callback = check
    this.destroyed = false
    Readable.call(this, override || opts)

    var self = this
    var hwm = this._readableState.highWaterMark

    function check(err, data) {
      if (self.destroyed) return

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

Are you sure this return statement is not missing an argument? If this is intended, consider adding an explicit undefined like return undefined;.

      if (err) return self.destroy(err)

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

      if (data === null) return self.push(null)

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

      self._reading = false
      if (self.push(data)) self._read(hwm)

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

There is no return statement if self.push(data) is false. Are you sure this is correct? If so, consider adding return; explicitly.

    }

There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.

  }

  Class.prototype._from = read || noop
  Class.prototype._read = function(size) {
    if (this._reading || this.destroyed) return

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

    this._reading = true
    this._from(size, this._callback)
  }

  Class.prototype.destroy = function(err) {
    if (this.destroyed) return

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

    this.destroyed = true

    var self = this
    process.nextTick(function() {
      if (err) self.emit('error', err)

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

      self.emit('close')
    })
  }

  return Class
}

function obj(opts, read) {
  if (typeof opts === 'function' || Array.isArray(opts)) {
    read = opts
    opts = {}
  }

  opts = defaults(opts)
  opts.objectMode = true
  opts.highWaterMark = 16

  return from2(opts, read)
}

function noop () {}

function defaults(opts) {
  opts = opts || {}
  return opts
}