Code coverage report for lib/abstract.js

# all files / lib/ abstract.js

76% Statements 38/50
59.38% Branches 19/32
55.56% Functions 5/9
75% Lines 36/48

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93

    1×

    1×
    1×

    1×
    8×
    8×
    8×
    8×
    8×
    8×
    8×
    8×

    1×

    1×
    41×

    41×

    41×

    1×

    1×

    1×

    1×

    1×
    2×
    2×

    1×
    2×
    2×
    2×
    2×
    2×
    2×

    2×

    2×
    2×

    28×

    2×

     // the parent class for all fstreams.

    module.exports = Abstract

    var Stream = require('stream').Stream
    var inherits = require('inherits')

    function Abstract () {
      Stream.call(this)
      this.ready = false
      this.path = null
      this.linkpath = null
      this.type = null
      this._aborted = false
      this._path = null
      this._paused = false
    }

    inherits(Abstract, Stream)

    Abstract.prototype.on = function (ev, fn) {
      Iif (ev === 'ready' && this.ready) {
        process.nextTick(fn.bind(this))
      } else {
        Stream.prototype.on.call(this, ev, fn)
      }
      return this
    }

    Abstract.prototype.abort = function () {
      this._aborted = true
      this.emit('abort')
    }

    Abstract.prototype.destroy = function () {}

    Abstract.prototype.warn = function (msg, code) {
      var self = this
      var er = decorate(msg, code, self)
      if (!self.listeners('warn').length) {
        console.error('%s %s\n' +
        'path = %s\n' +
        'syscall = %s\n' +
        'fstream_type = %s\n' +
        'fstream_path = %s\n' +
        'fstream_unc_path = %s\n' +
        'fstream_class = %s\n' +
        'fstream_stack =\n%s\n',
          code || 'UNKNOWN',
          er.stack,
          er.path,
          er.syscall,
          er.fstream_type,
          er.fstream_path,
          er.fstream_unc_path,
          er.fstream_class,
          er.fstream_stack.join('\n'))
      } else {
        self.emit('warn', er)
      }
    }

    Abstract.prototype.info = function (msg, code) {
      this.emit('info', msg, code)
    }

    Abstract.prototype.error = function (msg, code, th) {
      var er = decorate(msg, code, this)
      Eif (th) throw er
      else this.emit('error', er)
    }

    function decorate (er, code, self) {
      Eif (!(er instanceof Error)) er = new Error(er)
      er.code = er.code || code
      er.path = er.path || self.path
      er.fstream_type = er.fstream_type || self.type
      er.fstream_path = er.fstream_path || self.path
      Iif (self._path !== self.path) {
        er.fstream_unc_path = er.fstream_unc_path || self._path
      }
      Iif (self.linkpath) {
        er.fstream_linkpath = er.fstream_linkpath || self.linkpath
      }
      er.fstream_class = er.fstream_class || self.constructor.name
      er.fstream_stack = er.fstream_stack ||
        new Error().stack.split(/\n/).slice(3).map(function (s) {
          return s.replace(/^ {4}at /, '')
        })

      return er
    }