@oneblink/release-cli 1.1.1 → 1.2.0-beta.3

package/node_modules/klaw-sync/README.md

@@ -0,0 +1,164 @@
+node-klaw-sync
+==============
+
+[![npm Package](https://img.shields.io/npm/v/klaw-sync.svg?style=flat-square)](https://www.npmjs.com/package/klaw-sync)
+[![Build Status](https://travis-ci.org/manidlou/node-klaw-sync.svg?branch=master)](https://travis-ci.org/manidlou/node-klaw-sync)
+[![windows Build status](https://ci.appveyor.com/api/projects/status/braios34k6qw4h5p/branch/master?svg=true)](https://ci.appveyor.com/project/manidlou/node-klaw-sync/branch/master)
+[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg?style=flat-square)](https://standardjs.com)
+[![Known Vulnerabilities](https://snyk.io/test/npm/klaw-sync/badge.svg?style=flat-square)](https://snyk.io/test/npm/klaw-sync)
+
+`klaw-sync` is a Node.js recursive and fast file system walker, which is the synchronous counterpart of [klaw](https://github.com/jprichardson/node-klaw). It lists all files and directories inside a directory recursively and returns an array of objects that each object has two properties: `path` and `stats`. `path` is the full path of the file or directory and `stats` is an instance of [fs.Stats](https://nodejs.org/api/fs.html#fs_class_fs_stats).
+
+Install
+-------
+
+    npm i klaw-sync
+
+Usage
+-----
+
+### klawSync(directory[, options])
+
+- `directory` `<String>`
+- `options` `<Object>` (optional) _all options are `false` by default_
+  - `nodir` `<Boolean>`
+    - return only files (ignore directories).
+  - `nofile` `<Boolean>`
+    - return only directories (ignore files).
+  - `depthLimit`: `<Number>`
+    - the number of times to recurse before stopping. `-1` for unlimited.
+  - `fs`: `<Object>`
+    - custom `fs`, useful when mocking `fs` object.
+  - `filter` `<Function>`
+    - function that gets one argument `fn({path: '', stats: {}})` and returns true to include or false to exclude the item.
+  - `traverseAll` `<Boolean>`
+    - traverse all subdirectories, regardless of `filter` option. (When set to `true`, `traverseAll` produces similar behavior to the default behavior prior to v4.0.0. The current default of  `traverseAll: false` is equivalent to the old `noRecurseOnFailedFilter: true`).
+- **Return:** `<Array<Object>>` `[{path: '', stats: {}}]`
+
+Examples
+--------
+
+```js
+const klawSync = require('klaw-sync')
+
+const paths = klawSync('/some/dir')
+// paths = [{path: '/some/dir/dir1', stats: {}}, {path: '/some/dir/file1', stats: {}}]
+```
+
+_**catch error**_
+
+```js
+const klawSync = require('klaw-sync')
+
+let paths
+try {
+  paths = klawSync('/some/dir')
+} catch (er) {
+  console.error(er)
+}
+console.dir(paths)
+```
+
+_**files only**_
+
+```js
+const klawSync = require('klaw-sync')
+
+const files = klawSync('/some/dir', {nodir: true})
+// files = [{path: '/some/dir/file1', stats: {}}, {path: '/some/dir/file2', stats: {}}]
+```
+
+_**directories only**_
+
+```js
+const klawSync = require('klaw-sync')
+
+const dirs = klawSync('/some/dir', {nofile: true})
+// dirs = [{path: '/some/dir/dir1', stats: {}}, {path: '/some/dir/dir2', stats: {}}]
+```
+
+_**ignore hidden directories**_
+
+
+```js
+const path = require('path')
+const klawSync = require('klaw-sync')
+
+const filterFn = item => {
+  const basename = path.basename(item.path)
+  return basename === '.' || basename[0] !== '.'
+}
+
+const paths = klawSync('/some/dir', { filter: filterFn})
+```
+
+_**filter based on stats**_
+
+Here `traverseAll` option is required since we still want to read all directories even if they don't pass the `filter` function, to see if their contents do pass the `filter` function.
+
+```js
+const klawSync = require('klaw-sync')
+
+const refTime = new Date(2017, 3, 24).getTime()
+const filterFn = item => item.stats.mtime.getTime() > refTime
+
+const paths = klawSync('/some/dir', { filter: filterFn })
+```
+
+Run tests
+---------
+
+lint: `npm run lint`
+
+unit test: `npm run unit`
+
+lint & unit: `npm test`
+
+benchmark: `npm run benchmark`
+
+Performance compare to other similar modules
+-----------------------------------------------
+
+Running some [benchmark](https://github.com/bestiejs/benchmark.js) tests on these modules:
+
+- `klaw-sync`
+- [walk-sync](https://github.com/joliss/node-walk-sync)
+
+(as of Jan 25, 2017) `klaw-sync` is the fastest module!
+
+##### results (tested on Ubuntu 18.04, Intel(R) Core(TM) i7-2630QM CPU @ 2.00GHz, 8 CPUs, 8g RAM, node v10.9.0)
+
+```bash
+Running benchmark tests..
+
+root dir length: 1110
+walk-sync x 139 ops/sec ±2.48% (76 runs sampled)
+klaw-sync x 163 ops/sec ±1.20% (80 runs sampled)
+Fastest is klaw-sync
+
+root dir length: 11110
+walk-sync x 13.23 ops/sec ±1.10% (37 runs sampled)
+klaw-sync x 15.10 ops/sec ±1.06% (41 runs sampled)
+Fastest is klaw-sync
+
+root dir length: 111110
+walk-sync x 1.17 ops/sec ±2.06% (7 runs sampled)
+klaw-sync x 1.25 ops/sec ±2.10% (8 runs sampled)
+Fastest is klaw-sync
+```
+
+Credit
+------
+
+Special thanks to:
+
+- [agnivade](https://github.com/agnivade)
+- [jprichardson](https://github.com/jprichardson)
+- [RyanZim](https://github.com/RyanZim)
+
+for their contribution and support.
+
+License
+-------
+
+Licensed under MIT

package/node_modules/klaw-sync/klaw-sync.js

@@ -0,0 +1,29 @@
+'use strict'
+const fs = require('graceful-fs')
+const path = require('path')
+
+function klawSync (dir, opts, ls) {
+  if (!ls) {
+    ls = []
+    dir = path.resolve(dir)
+    opts = opts || {}
+    opts.fs = opts.fs || fs
+    if (opts.depthLimit > -1) opts.rootDepth = dir.split(path.sep).length + 1
+  }
+  const paths = opts.fs.readdirSync(dir).map(p => dir + path.sep + p)
+  for (var i = 0; i < paths.length; i += 1) {
+    const pi = paths[i]
+    const st = opts.fs.statSync(pi)
+    const item = {path: pi, stats: st}
+    const isUnderDepthLimit = (!opts.rootDepth || pi.split(path.sep).length - opts.rootDepth < opts.depthLimit)
+    const filterResult = opts.filter ? opts.filter(item) : true
+    const isDir = st.isDirectory()
+    const shouldAdd = filterResult && (isDir ? !opts.nodir : !opts.nofile)
+    const shouldTraverse = isDir && isUnderDepthLimit && (opts.traverseAll || filterResult)
+    if (shouldAdd) ls.push(item)
+    if (shouldTraverse) ls = klawSync(pi, opts, ls)
+  }
+  return ls
+}
+
+module.exports = klawSync

package/node_modules/klaw-sync/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "klaw-sync",
+  "version": "6.0.0",
+  "description": "Recursive, synchronous, and fast file system walker",
+  "main": "klaw-sync.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/manidlou/node-klaw-sync.git"
+  },
+  "keywords": [
+    "fs",
+    "walk",
+    "walker",
+    "walk-sync",
+    "klaw",
+    "readdir-sync"
+  ],
+  "author": "Mani Maghsoudlou",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/manidlou/node-klaw-sync/issues"
+  },
+  "homepage": "https://github.com/manidlou/node-klaw-sync#readme",
+  "dependencies": {
+    "graceful-fs": "^4.1.11"
+  },
+  "devDependencies": {
+    "benchmark": "^2.1.4",
+    "fs-extra": "^5.0.0",
+    "memory-fs": "^0.4.1",
+    "mkp": "^1.0.1",
+    "mocha": "^5.1.1",
+    "standard": "^11.0.1",
+    "walk-sync": "^0.3.3"
+  },
+  "standard": {
+    "env": [
+      "mocha"
+    ]
+  },
+  "scripts": {
+    "lint": "standard",
+    "unit": "mocha",
+    "test": "npm run lint && npm run unit",
+    "benchmark": "node ./benchmark/bm.js"
+  }
+
+,"_resolved": "https://registry.npmjs.org/klaw-sync/-/klaw-sync-6.0.0.tgz"
+,"_integrity": "sha512-nIeuVSzdCCs6TDPTqI8w1Yre34sSq7AkZ4B3sfOBbI2CgVSB4Du4aLQijFU2+lhAFCwt9+42Hel6lQNIv6AntQ=="
+,"_from": "klaw-sync@6.0.0"
+}

package/node_modules/line-reader/LICENSE

@@ -0,0 +1,20 @@
+Copyright (C) 2012 by Nick Ewing
+
+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.
+

package/node_modules/line-reader/README.md

@@ -0,0 +1,75 @@
+Line Reader
+===========
+
+Asynchronous line-by-line file reader.
+
+Install
+-------
+
+`npm install line-reader`
+
+Usage
+-----
+
+The `eachLine` function reads each line of the given file.  Upon each new line,
+the given callback function is called with two parameters: the line read and a
+boolean value specifying whether the line read was the last line of the file.
+If the callback returns `false`, reading will stop and the file will be closed.
+
+    var lineReader = require('line-reader');
+
+    lineReader.eachLine('file.txt', function(line, last) {
+      console.log(line);
+
+      if (/* done */) {
+        return false; // stop reading
+      }
+    });
+
+`eachLine` can also be used in an asynchronous manner by providing a third
+callback parameter like so:
+
+    var lineReader = require('line-reader');
+
+    lineReader.eachLine('file.txt', function(line, last, cb) {
+      console.log(line);
+
+      if (/* done */) {
+        cb(false); // stop reading
+      } else {
+        cb();
+      }
+    });
+
+The `eachLine` function also returns an object with one property, `then`.  If a
+callback is provided to `then`, it will be called once all lines have been read.
+
+    var lineReader = require('line-reader');
+
+    // read all lines:
+    lineReader.eachLine('file.txt', function(line) {
+      console.log(line);
+    }).then(function () {
+      console.log("I'm done!!");
+    });
+
+
+For more granular control, `open`, `hasNextLine`, and `nextLine` maybe be used
+to iterate a file:
+
+    // or read line by line:
+    lineReader.open('file.txt', function(reader) {
+      if (reader.hasNextLine()) {
+        reader.nextLine(function(line) {
+          console.log(line);
+        });
+      }
+    });
+
+Contributors
+------------
+
+* Nick Ewing
+* Jameson Little (beatgammit)
+
+Copyright 2011 Nick Ewing.

package/node_modules/line-reader/lib/line_reader.js

@@ -0,0 +1,174 @@
+(function() {
+  "use strict";
+
+  var fs = require('fs'),
+      StringDecoder = require('string_decoder').StringDecoder;
+
+  function LineReader(fd, cb, separator, encoding, bufferSize) {
+    var filePosition   = 0,
+        encoding       = encoding || 'utf8',
+        separator      = separator || '\n',
+        bufferSize     = bufferSize || 1024,
+        buffer         = new Buffer(bufferSize),
+        bufferStr      = '',
+        decoder        = new StringDecoder(encoding),
+        closed         = false,
+        eof            = false,
+        separatorIndex = -1;
+
+    function close() {
+      if (!closed) {
+        fs.close(fd, function(err) {
+          if (err) {
+            throw err;
+          }
+        });
+        closed = true;
+      }
+    }
+
+    function readToSeparator(cb) {
+      function readChunk() {
+        fs.read(fd, buffer, 0, bufferSize, filePosition, function(err, bytesRead) {
+          var separatorAtEnd;
+
+          if (err) {
+            throw err;
+          }
+
+          if (bytesRead < bufferSize) {
+            eof = true;
+            close();
+          }
+
+          filePosition += bytesRead;
+
+          bufferStr += decoder.write(buffer.slice(0, bytesRead));
+
+          if (separatorIndex < 0) {
+            separatorIndex = bufferStr.indexOf(separator);
+          }
+
+          separatorAtEnd = separatorIndex === bufferStr.length - 1;
+          if (bytesRead && (separatorIndex === -1 || separatorAtEnd) && !eof) {
+            readChunk();
+          } else {
+            cb();
+          }
+        });
+      }
+
+      readChunk();
+    }
+
+    function hasNextLine() {
+      return bufferStr.length > 0 || !eof;
+    }
+
+    function nextLine(cb) {
+      function getLine() {
+        var ret = bufferStr.substring(0, separatorIndex);
+
+        bufferStr = bufferStr.substring(separatorIndex + separator.length);
+        separatorIndex = -1;
+        cb(ret);
+      }
+
+      if (separatorIndex < 0) {
+        separatorIndex = bufferStr.indexOf(separator);
+      }
+
+      if (separatorIndex < 0) {
+        if (eof) {
+          if (hasNextLine()) {
+            separatorIndex = bufferStr.length;
+            getLine();
+          } else {
+            throw new Error('No more lines to read.');
+          }
+        } else {
+          readToSeparator(getLine);
+        }
+      } else {
+        getLine();
+      }
+    }
+
+    this.hasNextLine = hasNextLine;
+    this.nextLine = nextLine;
+    this.close = close;
+
+    readToSeparator(cb);
+  }
+
+  function open(filename, cb, separator, encoding, bufferSize) {
+    fs.open(filename, 'r', parseInt('666', 8), function(err, fd) {
+      var reader;
+      if (err) {
+        throw err;
+      }
+
+      reader = new LineReader(fd, function() {
+        cb(reader);
+      }, separator, encoding, bufferSize);
+    });
+  }
+
+  function eachLine(filename, cb, separator, encoding, bufferSize) {
+    var finalFn,
+        asyncCb = cb.length == 3;
+
+    function finish() {
+      if (finalFn && typeof finalFn === 'function') {
+        finalFn();
+      }
+    }
+
+    open(filename, function(reader) {
+      function newRead() {
+        if (reader.hasNextLine()) {
+          setImmediate(readNext);
+        } else {
+          finish();
+        }
+      }
+
+      function continueCb(continueReading) {
+        if (continueReading !== false) {
+          newRead();
+        } else {
+          finish();
+          reader.close();
+        }
+      }
+
+      function readNext() {
+        reader.nextLine(function(line) {
+          var last = !reader.hasNextLine();
+
+          if (asyncCb) {
+            cb(line, last, continueCb);
+          } else {
+            if (cb(line, last) !== false) {
+              newRead();
+            } else {
+              finish();
+              reader.close();
+            }
+          }
+        });
+      }
+
+      newRead();
+    }, separator, encoding, bufferSize);
+
+    return {
+      then: function(cb) {
+        finalFn = cb;
+      }
+    };
+  }
+
+  module.exports.open = open;
+  module.exports.eachLine = eachLine;
+}());

package/node_modules/line-reader/package.json

@@ -0,0 +1,18 @@
+{
+  "name":        "line-reader",
+  "version":     "0.2.4",
+  "description": "Asynchronous line-by-line file reader",
+  "url":         "https://github.com/nickewing/line-reader",
+  "keywords":    ["file", "line", "reader", "scanner"],
+  "author":      "Nick Ewing <nick@nickewing.net>",
+  "directories": {"lib" : "./lib"},
+  "main":        "./lib/line_reader",
+  "repository": {
+    "type": "git",
+    "url": "https://nickewing@github.com/nickewing/line-reader.git"
+  }
+
+,"_resolved": "https://registry.npmjs.org/line-reader/-/line-reader-0.2.4.tgz"
+,"_integrity": "sha1-xDkrWH3qOFgMlnhXDm6OSfzlJiI="
+,"_from": "line-reader@0.2.4"
+}

package/node_modules/line-reader/test/data/multi_separator_file.txt

@@ -0,0 +1,2 @@
+foo||bar
+||baz

package/node_modules/line-reader/test/data/multibyte_file.txt

@@ -0,0 +1,2 @@
+ふうりうの初やおくの田植うた
+

package/node_modules/line-reader/test/data/normal_file.txt

@@ -0,0 +1,6 @@
+Jabberwocky
+
+’Twas brillig, and the slithy toves
+Did gyre and gimble in the wabe;
+
+

package/node_modules/line-reader/test/data/one_line_file.txt

@@ -0,0 +1 @@
+one line file

package/node_modules/line-reader/test/data/separator_file.txt

@@ -0,0 +1,2 @@
+foo;bar
+;baz

package/node_modules/line-reader/test/data/three_line_file.txt

@@ -0,0 +1,3 @@
+This is line one.
+This is line two.
+This is line three.