Code coverage report for lib/proxy-writer.js

# all files / lib/ proxy-writer.js

22.03% Statements 13/59
0% Branches 0/18
0% Functions 0/9
22.41% Lines 13/58

    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
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112

    1×

    1×
    1×
    1×
    1×
    1×

    1×

    1×

    1×

    1×

    1×

    1×

    1×

     // A writer for when we don't know what kind of thing
    // the thing is.  That is, it's not explicitly set,
    // so we're going to make it whatever the thing already
    // is, or "File"
    //
    // Until then, collect all events.

    module.exports = ProxyWriter

    var Writer = require('./writer.js')
    var getType = require('./get-type.js')
    var inherits = require('inherits')
    var collect = require('./collect.js')
    var fs = require('fs')

    inherits(ProxyWriter, Writer)

    function ProxyWriter (props) {
      var self = this
      if (!(self instanceof ProxyWriter)) {
        throw new Error('ProxyWriter must be called as constructor.')
      }

      self.props = props
      self._needDrain = false

      Writer.call(self, props)
    }

    ProxyWriter.prototype._stat = function () {
      var self = this
      var props = self.props
      // stat the thing to see what the proxy should be.
      var stat = props.follow ? 'stat' : 'lstat'

      fs[stat](props.path, function (er, current) {
        var type
        if (er || !current) {
          type = 'File'
        } else {
          type = getType(current)
        }

        props[type] = true
        props.type = self.type = type

        self._old = current
        self._addProxy(Writer(props, current))
      })
    }

    ProxyWriter.prototype._addProxy = function (proxy) {
      // console.error("~~ set proxy", this.path)
      var self = this
      if (self._proxy) {
        return self.error('proxy already set')
      }

      self._proxy = proxy
      ;[
        'ready',
        'error',
        'close',
        'pipe',
        'drain',
        'warn'
      ].forEach(function (ev) {
        proxy.on(ev, self.emit.bind(self, ev))
      })

      self.emit('proxy', proxy)

      var calls = self._buffer
      calls.forEach(function (c) {
        // console.error("~~ ~~ proxy buffered call", c[0], c[1])
        proxy[c[0]].apply(proxy, c[1])
      })
      self._buffer.length = 0
      if (self._needsDrain) self.emit('drain')
    }

    ProxyWriter.prototype.add = function (entry) {
      // console.error("~~ proxy add")
      collect(entry)

      if (!this._proxy) {
        this._buffer.push(['add', [entry]])
        this._needDrain = true
        return false
      }
      return this._proxy.add(entry)
    }

    ProxyWriter.prototype.write = function (c) {
      // console.error('~~ proxy write')
      if (!this._proxy) {
        this._buffer.push(['write', [c]])
        this._needDrain = true
        return false
      }
      return this._proxy.write(c)
    }

    ProxyWriter.prototype.end = function (c) {
      // console.error('~~ proxy end')
      if (!this._proxy) {
        this._buffer.push(['end', [c]])
        return false
      }
      return this._proxy.end(c)
    }