isomorfeus-puppetmaster 0.5.6 → 0.6.2

data/node_modules/tar-stream/pack.js

@@ -1,255 +0,0 @@
-var constants = require('fs-constants')
-var eos = require('end-of-stream')
-var inherits = require('inherits')
-var alloc = Buffer.alloc
-
-var Readable = require('readable-stream').Readable
-var Writable = require('readable-stream').Writable
-var StringDecoder = require('string_decoder').StringDecoder
-
-var headers = require('./headers')
-
-var DMODE = parseInt('755', 8)
-var FMODE = parseInt('644', 8)
-
-var END_OF_TAR = alloc(1024)
-
-var noop = function () {}
-
-var overflow = function (self, size) {
-  size &= 511
-  if (size) self.push(END_OF_TAR.slice(0, 512 - size))
-}
-
-function modeToType (mode) {
-  switch (mode & constants.S_IFMT) {
-    case constants.S_IFBLK: return 'block-device'
-    case constants.S_IFCHR: return 'character-device'
-    case constants.S_IFDIR: return 'directory'
-    case constants.S_IFIFO: return 'fifo'
-    case constants.S_IFLNK: return 'symlink'
-  }
-
-  return 'file'
-}
-
-var Sink = function (to) {
-  Writable.call(this)
-  this.written = 0
-  this._to = to
-  this._destroyed = false
-}
-
-inherits(Sink, Writable)
-
-Sink.prototype._write = function (data, enc, cb) {
-  this.written += data.length
-  if (this._to.push(data)) return cb()
-  this._to._drain = cb
-}
-
-Sink.prototype.destroy = function () {
-  if (this._destroyed) return
-  this._destroyed = true
-  this.emit('close')
-}
-
-var LinkSink = function () {
-  Writable.call(this)
-  this.linkname = ''
-  this._decoder = new StringDecoder('utf-8')
-  this._destroyed = false
-}
-
-inherits(LinkSink, Writable)
-
-LinkSink.prototype._write = function (data, enc, cb) {
-  this.linkname += this._decoder.write(data)
-  cb()
-}
-
-LinkSink.prototype.destroy = function () {
-  if (this._destroyed) return
-  this._destroyed = true
-  this.emit('close')
-}
-
-var Void = function () {
-  Writable.call(this)
-  this._destroyed = false
-}
-
-inherits(Void, Writable)
-
-Void.prototype._write = function (data, enc, cb) {
-  cb(new Error('No body allowed for this entry'))
-}
-
-Void.prototype.destroy = function () {
-  if (this._destroyed) return
-  this._destroyed = true
-  this.emit('close')
-}
-
-var Pack = function (opts) {
-  if (!(this instanceof Pack)) return new Pack(opts)
-  Readable.call(this, opts)
-
-  this._drain = noop
-  this._finalized = false
-  this._finalizing = false
-  this._destroyed = false
-  this._stream = null
-}
-
-inherits(Pack, Readable)
-
-Pack.prototype.entry = function (header, buffer, callback) {
-  if (this._stream) throw new Error('already piping an entry')
-  if (this._finalized || this._destroyed) return
-
-  if (typeof buffer === 'function') {
-    callback = buffer
-    buffer = null
-  }
-
-  if (!callback) callback = noop
-
-  var self = this
-
-  if (!header.size || header.type === 'symlink') header.size = 0
-  if (!header.type) header.type = modeToType(header.mode)
-  if (!header.mode) header.mode = header.type === 'directory' ? DMODE : FMODE
-  if (!header.uid) header.uid = 0
-  if (!header.gid) header.gid = 0
-  if (!header.mtime) header.mtime = new Date()
-
-  if (typeof buffer === 'string') buffer = Buffer.from(buffer)
-  if (Buffer.isBuffer(buffer)) {
-    header.size = buffer.length
-    this._encode(header)
-    var ok = this.push(buffer)
-    overflow(self, header.size)
-    if (ok) process.nextTick(callback)
-    else this._drain = callback
-    return new Void()
-  }
-
-  if (header.type === 'symlink' && !header.linkname) {
-    var linkSink = new LinkSink()
-    eos(linkSink, function (err) {
-      if (err) { // stream was closed
-        self.destroy()
-        return callback(err)
-      }
-
-      header.linkname = linkSink.linkname
-      self._encode(header)
-      callback()
-    })
-
-    return linkSink
-  }
-
-  this._encode(header)
-
-  if (header.type !== 'file' && header.type !== 'contiguous-file') {
-    process.nextTick(callback)
-    return new Void()
-  }
-
-  var sink = new Sink(this)
-
-  this._stream = sink
-
-  eos(sink, function (err) {
-    self._stream = null
-
-    if (err) { // stream was closed
-      self.destroy()
-      return callback(err)
-    }
-
-    if (sink.written !== header.size) { // corrupting tar
-      self.destroy()
-      return callback(new Error('size mismatch'))
-    }
-
-    overflow(self, header.size)
-    if (self._finalizing) self.finalize()
-    callback()
-  })
-
-  return sink
-}
-
-Pack.prototype.finalize = function () {
-  if (this._stream) {
-    this._finalizing = true
-    return
-  }
-
-  if (this._finalized) return
-  this._finalized = true
-  this.push(END_OF_TAR)
-  this.push(null)
-}
-
-Pack.prototype.destroy = function (err) {
-  if (this._destroyed) return
-  this._destroyed = true
-
-  if (err) this.emit('error', err)
-  this.emit('close')
-  if (this._stream && this._stream.destroy) this._stream.destroy()
-}
-
-Pack.prototype._encode = function (header) {
-  if (!header.pax) {
-    var buf = headers.encode(header)
-    if (buf) {
-      this.push(buf)
-      return
-    }
-  }
-  this._encodePax(header)
-}
-
-Pack.prototype._encodePax = function (header) {
-  var paxHeader = headers.encodePax({
-    name: header.name,
-    linkname: header.linkname,
-    pax: header.pax
-  })
-
-  var newHeader = {
-    name: 'PaxHeader',
-    mode: header.mode,
-    uid: header.uid,
-    gid: header.gid,
-    size: paxHeader.length,
-    mtime: header.mtime,
-    type: 'pax-header',
-    linkname: header.linkname && 'PaxHeader',
-    uname: header.uname,
-    gname: header.gname,
-    devmajor: header.devmajor,
-    devminor: header.devminor
-  }
-
-  this.push(headers.encode(newHeader))
-  this.push(paxHeader)
-  overflow(this, paxHeader.length)
-
-  newHeader.size = header.size
-  newHeader.type = header.type
-  this.push(headers.encode(newHeader))
-}
-
-Pack.prototype._read = function (n) {
-  var drain = this._drain
-  this._drain = noop
-  drain()
-}
-
-module.exports = Pack

data/node_modules/tar-stream/package.json

@@ -1,58 +0,0 @@
-{
-  "name": "tar-stream",
-  "version": "2.2.0",
-  "description": "tar-stream is a streaming tar parser and generator and nothing else. It is streams2 and operates purely using streams which means you can easily extract/parse tarballs without ever hitting the file system.",
-  "author": "Mathias Buus <mathiasbuus@gmail.com>",
-  "dependencies": {
-    "bl": "^4.0.3",
-    "end-of-stream": "^1.4.1",
-    "fs-constants": "^1.0.0",
-    "inherits": "^2.0.3",
-    "readable-stream": "^3.1.1"
-  },
-  "devDependencies": {
-    "concat-stream": "^2.0.0",
-    "standard": "^12.0.1",
-    "tape": "^4.9.2"
-  },
-  "scripts": {
-    "test": "standard && tape test/extract.js test/pack.js",
-    "test-all": "standard && tape test/*.js"
-  },
-  "keywords": [
-    "tar",
-    "tarball",
-    "parse",
-    "parser",
-    "generate",
-    "generator",
-    "stream",
-    "stream2",
-    "streams",
-    "streams2",
-    "streaming",
-    "pack",
-    "extract",
-    "modify"
-  ],
-  "bugs": {
-    "url": "https://github.com/mafintosh/tar-stream/issues"
-  },
-  "homepage": "https://github.com/mafintosh/tar-stream",
-  "main": "index.js",
-  "files": [
-    "*.js",
-    "LICENSE"
-  ],
-  "directories": {
-    "test": "test"
-  },
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/mafintosh/tar-stream.git"
-  },
-  "engines": {
-    "node": ">=6"
-  }
-}

data/node_modules/tar-stream/sandbox.js

@@ -1,11 +0,0 @@
-const tar = require('tar-stream')
-const fs = require('fs')
-const path = require('path')
-const pipeline = require('pump') // eequire('stream').pipeline
-
-fs.createReadStream('test.tar')
-  .pipe(tar.extract())
-  .on('entry', function (header, stream, done) {
-    console.log(header.name)
-    pipeline(stream, fs.createWriteStream(path.join('/tmp', header.name)), done)
-  })

data/node_modules/through/.travis.yml

@@ -1,5 +0,0 @@
-language: node_js
-node_js:
-  - 0.6
-  - 0.8
-  - "0.10"

data/node_modules/through/LICENSE.APACHE2

@@ -1,15 +0,0 @@
-Apache License, Version 2.0
-
-Copyright (c) 2011 Dominic Tarr
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

data/node_modules/through/LICENSE.MIT

@@ -1,24 +0,0 @@
-The MIT License
-
-Copyright (c) 2011 Dominic Tarr
-
-Permission is hereby granted, free of charge, 
-to any person obtaining a copy of this software and 
-associated documentation files (the "Software"), to 
-deal in the Software without restriction, including 
-without limitation the rights to use, copy, modify, 
-merge, publish, distribute, sublicense, and/or sell 
-copies of the Software, and to permit persons to whom 
-the Software is furnished to do so, 
-subject to the following conditions:
-
-The above copyright notice and this permission notice 
-shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR 
-ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/node_modules/through/index.js

@@ -1,108 +0,0 @@
-var Stream = require('stream')
-
-// through
-//
-// a stream that does nothing but re-emit the input.
-// useful for aggregating a series of changing but not ending streams into one stream)
-
-exports = module.exports = through
-through.through = through
-
-//create a readable writable stream.
-
-function through (write, end, opts) {
-  write = write || function (data) { this.queue(data) }
-  end = end || function () { this.queue(null) }
-
-  var ended = false, destroyed = false, buffer = [], _ended = false
-  var stream = new Stream()
-  stream.readable = stream.writable = true
-  stream.paused = false
-
-//  stream.autoPause   = !(opts && opts.autoPause   === false)
-  stream.autoDestroy = !(opts && opts.autoDestroy === false)
-
-  stream.write = function (data) {
-    write.call(this, data)
-    return !stream.paused
-  }
-
-  function drain() {
-    while(buffer.length && !stream.paused) {
-      var data = buffer.shift()
-      if(null === data)
-        return stream.emit('end')
-      else
-        stream.emit('data', data)
-    }
-  }
-
-  stream.queue = stream.push = function (data) {
-//    console.error(ended)
-    if(_ended) return stream
-    if(data === null) _ended = true
-    buffer.push(data)
-    drain()
-    return stream
-  }
-
-  //this will be registered as the first 'end' listener
-  //must call destroy next tick, to make sure we're after any
-  //stream piped from here.
-  //this is only a problem if end is not emitted synchronously.
-  //a nicer way to do this is to make sure this is the last listener for 'end'
-
-  stream.on('end', function () {
-    stream.readable = false
-    if(!stream.writable && stream.autoDestroy)
-      process.nextTick(function () {
-        stream.destroy()
-      })
-  })
-
-  function _end () {
-    stream.writable = false
-    end.call(stream)
-    if(!stream.readable && stream.autoDestroy)
-      stream.destroy()
-  }
-
-  stream.end = function (data) {
-    if(ended) return
-    ended = true
-    if(arguments.length) stream.write(data)
-    _end() // will emit or queue
-    return stream
-  }
-
-  stream.destroy = function () {
-    if(destroyed) return
-    destroyed = true
-    ended = true
-    buffer.length = 0
-    stream.writable = stream.readable = false
-    stream.emit('close')
-    return stream
-  }
-
-  stream.pause = function () {
-    if(stream.paused) return
-    stream.paused = true
-    return stream
-  }
-
-  stream.resume = function () {
-    if(stream.paused) {
-      stream.paused = false
-      stream.emit('resume')
-    }
-    drain()
-    //may have become paused again,
-    //as drain emits 'data'.
-    if(!stream.paused)
-      stream.emit('drain')
-    return stream
-  }
-  return stream
-}
-

data/node_modules/through/package.json

@@ -1,36 +0,0 @@
-{
-  "name": "through",
-  "version": "2.3.8",
-  "description": "simplified stream construction",
-  "main": "index.js",
-  "scripts": {
-    "test": "set -e; for t in test/*.js; do node $t; done"
-  },
-  "devDependencies": {
-    "stream-spec": "~0.3.5",
-    "tape": "~2.3.2",
-    "from": "~0.1.3"
-  },
-  "keywords": [
-    "stream",
-    "streams",
-    "user-streams",
-    "pipe"
-  ],
-  "author": "Dominic Tarr <dominic.tarr@gmail.com> (dominictarr.com)",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/dominictarr/through.git"
-  },
-  "homepage": "https://github.com/dominictarr/through",
-  "testling": {
-    "browsers": [
-      "ie/8..latest",
-      "ff/15..latest",
-      "chrome/20..latest",
-      "safari/5.1..latest"
-    ],
-    "files": "test/*.js"
-  }
-}

data/node_modules/through/readme.markdown

@@ -1,64 +0,0 @@
-#through
-
-[![build status](https://secure.travis-ci.org/dominictarr/through.png)](http://travis-ci.org/dominictarr/through)
-[![testling badge](https://ci.testling.com/dominictarr/through.png)](https://ci.testling.com/dominictarr/through)
-
-Easy way to create a `Stream` that is both `readable` and `writable`. 
-
-* Pass in optional `write` and `end` methods.
-* `through` takes care of pause/resume logic if you use `this.queue(data)` instead of `this.emit('data', data)`.
-* Use `this.pause()` and `this.resume()` to manage flow.
-* Check `this.paused` to see current flow state. (`write` always returns `!this.paused`).
-
-This function is the basis for most of the synchronous streams in 
-[event-stream](http://github.com/dominictarr/event-stream).
-
-``` js
-var through = require('through')
-
-through(function write(data) {
-    this.queue(data) //data *must* not be null
-  },
-  function end () { //optional
-    this.queue(null)
-  })
-```
-
-Or, can also be used _without_ buffering on pause, use `this.emit('data', data)`,
-and this.emit('end')
-
-``` js
-var through = require('through')
-
-through(function write(data) {
-    this.emit('data', data)
-    //this.pause() 
-  },
-  function end () { //optional
-    this.emit('end')
-  })
-```
-
-## Extended Options
-
-You will probably not need these 99% of the time.
-
-### autoDestroy=false
-
-By default, `through` emits close when the writable
-and readable side of the stream has ended.
-If that is not desired, set `autoDestroy=false`.
-
-``` js
-var through = require('through')
-
-//like this
-var ts = through(write, end, {autoDestroy: false})
-//or like this
-var ts = through(write, end)
-ts.autoDestroy = false
-```
-
-## License
-
-MIT / Apache2

data/node_modules/through/test/async.js

@@ -1,28 +0,0 @@
-var from = require('from')
-var through = require('../')
-
-var tape = require('tape')
-
-tape('simple async example', function (t) {
- 
-  var n = 0, expected = [1,2,3,4,5], actual = []
-  from(expected)
-  .pipe(through(function(data) {
-    this.pause()
-    n ++
-    setTimeout(function(){
-      console.log('pushing data', data)
-      this.push(data)
-      this.resume()
-    }.bind(this), 300)
-  })).pipe(through(function(data) {
-    console.log('pushing data second time', data);
-    this.push(data)
-  })).on('data', function (d) {
-    actual.push(d)
-  }).on('end', function() {
-    t.deepEqual(actual, expected)
-    t.end()
-  })
-
-})

data/node_modules/through/test/auto-destroy.js

@@ -1,30 +0,0 @@
-var test = require('tape')
-var through = require('../')
-
-// must emit end before close.
-
-test('end before close', function (assert) {
-  var ts = through()
-  ts.autoDestroy = false
-  var ended = false, closed = false
-
-  ts.on('end', function () {
-    assert.ok(!closed)
-    ended = true
-  })
-  ts.on('close', function () {
-    assert.ok(ended)
-    closed = true
-  })
-
-  ts.write(1)
-  ts.write(2)
-  ts.write(3)
-  ts.end()
-  assert.ok(ended)
-  assert.notOk(closed)
-  ts.destroy()
-  assert.ok(closed)
-  assert.end()
-})
-