@oneblink/release-cli 1.2.0-beta.2 → 1.2.0

package/node_modules/changelog-parser/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "changelog-parser",
+  "description": "Change log parser for node.",
+  "version": "2.8.0",
+  "author": "Nate Goldman <ungoldman@gmail.com>",
+  "bin": {
+    "changelog-parser": "./bin/cli.js"
+  },
+  "bugs": {
+    "url": "https://github.com/hypermodules/changelog-parser/issues"
+  },
+  "contributors": [
+    "Nate Goldman <ungoldman@gmail.com>",
+    "Rachel Nehmer <kneemer@gmail.com>",
+    "Viktor Havrylin <fer0x.feo@gmail.com>",
+    "J R Mykolyn <jrmykolyn@gmail.com>",
+    "Bogdan Plieshka <bogdanplieshka@gmail.com>",
+    "Ciro Nunes <ciroanunes@gmail.com>",
+    "Andy Edwards <jedwards@fastmail.com>"
+  ],
+  "dependencies": {
+    "line-reader": "^0.2.4",
+    "remove-markdown": "^0.2.2"
+  },
+  "devDependencies": {
+    "gh-release": "^3.1.1",
+    "standard": "^10.0.2",
+    "tap-spec": "^4.1.1",
+    "tape": "^4.6.0"
+  },
+  "homepage": "https://github.com/hypermodules/changelog-parser",
+  "keywords": [
+    "CHANGELOG.md",
+    "changelog",
+    "parser",
+    "semantic",
+    "semver",
+    "versioning"
+  ],
+  "license": "ISC",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hypermodules/changelog-parser.git"
+  },
+  "scripts": {
+    "release": "gh-release && npm publish",
+    "test": "standard && node test | tap-spec"
+  }
+
+,"_resolved": "https://registry.npmjs.org/changelog-parser/-/changelog-parser-2.8.0.tgz"
+,"_integrity": "sha512-ZtSwN0hY7t+WpvaXqqXz98RHCNhWX9HsvCRAv1aBLlqJ7BpKtqdM6Nu6JOiUhRAWR7Gov0aN0fUnmflTz0WgZg=="
+,"_from": "changelog-parser@2.8.0"
+}

package/node_modules/changelog-parser/test/fixtures/CHANGELOG.md

@@ -0,0 +1,44 @@
+# changelog title
+
+A cool description (optional).
+
+## unreleased
+* foo
+
+## x.y.z - YYYY-MM-DD
+* bar
+
+## [a.b.c]
+
+### Changes
+
+* Update API
+* Fix bug #1
+
+# 2.3.0 - 2018-12-18
+
+### Added
+
+- Some changelog generators such as [standard-version](https://github.com/conventional-changelog/standard-version) would produce H1s for major versions and H2s for minor versions. We want the parser to be able to parse both.
+
+## 2.2.3-pre.1 - 2013-02-14
+
+### Added
+- Added an item.
+* Added another item.
+
+* Update API
+
+## 2.0.0-x.7.z.92 - 2013-02-14
+* bark bark
+* woof
+* arf
+
+## v1.3.0
+
+* make it so
+
+## [1.2.3](link)
+* init
+
+[a.b.c]: http://altavista.com

package/node_modules/changelog-parser/test/fixtures/expected.js

@@ -0,0 +1,113 @@
+var EOL = require('os').EOL
+
+module.exports = {
+  title: 'changelog title',
+  description: 'A cool description (optional).',
+  versions: [
+    {
+      version: null,
+      title: 'unreleased',
+      'date': null,
+      body: '* foo',
+      parsed: {
+        _: [
+          'foo'
+        ]
+      }
+    },
+    {
+      version: 'x.y.z',
+      title: 'x.y.z - YYYY-MM-DD',
+      'date': null,
+      body: '* bar',
+      parsed: {
+        _: [
+          'bar'
+        ]
+      }
+    },
+    {
+      version: 'a.b.c',
+      title: '[a.b.c]',
+      'date': null,
+      body: '### Changes' + EOL + EOL + '* Update API' + EOL + '* Fix bug #1',
+      parsed: {
+        _: [
+          'Update API',
+          'Fix bug #1'
+        ],
+        Changes: [
+          'Update API',
+          'Fix bug #1'
+        ]
+      }
+    },
+    {
+      version: '2.3.0',
+      title: '2.3.0 - 2018-12-18',
+      'date': '2018-12-18',
+      body: '### Added' + EOL + EOL + '- Some changelog generators such as [standard-version](https://github.com/conventional-changelog/standard-version) would produce H1s for major versions and H2s for minor versions. We want the parser to be able to parse both.',
+      parsed: {
+        _: [
+          'Some changelog generators such as standard-version would produce H1s for major versions and H2s for minor versions. We want the parser to be able to parse both.'
+        ],
+        Added: [
+          'Some changelog generators such as standard-version would produce H1s for major versions and H2s for minor versions. We want the parser to be able to parse both.'
+        ]
+      }
+    },
+    {
+      version: '2.2.3-pre.1',
+      title: '2.2.3-pre.1 - 2013-02-14',
+      'date': '2013-02-14',
+      body: '### Added' + EOL + '- Added an item.' + EOL + '* Added another item.' + EOL + EOL + '* Update API',
+      parsed: {
+        _: [
+          'Added an item.',
+          'Added another item.',
+          'Update API'
+        ],
+        Added: [
+          'Added an item.',
+          'Added another item.',
+          'Update API'
+        ]
+      }
+    },
+    {
+      version: '2.0.0-x.7.z.92',
+      title: '2.0.0-x.7.z.92 - 2013-02-14',
+      'date': '2013-02-14',
+      body: '* bark bark' + EOL + '* woof' + EOL + '* arf',
+      parsed: {
+        _: [
+          'bark bark',
+          'woof',
+          'arf'
+        ]
+      }
+    },
+    {
+      version: '1.3.0',
+      title: 'v1.3.0',
+      'date': null,
+      body: '* make it so',
+      parsed: {
+        _: [
+          'make it so'
+        ]
+      }
+    },
+    {
+      version: '1.2.3',
+      title: '[1.2.3](link)',
+      'date': null,
+      body: '* init',
+      parsed: {
+        _: [
+          'init'
+        ]
+      }
+    }
+  ]
+}

package/node_modules/changelog-parser/test/fixtures/remove-markdown-expected.js

@@ -0,0 +1,113 @@
+var EOL = require('os').EOL
+
+module.exports = {
+  title: 'changelog title',
+  description: 'A cool description (optional).',
+  versions: [
+    {
+      version: null,
+      title: 'unreleased',
+      'date': null,
+      body: '* foo',
+      parsed: {
+        _: [
+          '* foo'
+        ]
+      }
+    },
+    {
+      version: 'x.y.z',
+      title: 'x.y.z - YYYY-MM-DD',
+      'date': null,
+      body: '* bar',
+      parsed: {
+        _: [
+          '* bar'
+        ]
+      }
+    },
+    {
+      version: 'a.b.c',
+      title: '[a.b.c]',
+      'date': null,
+      body: '### Changes' + EOL + EOL + '* Update API' + EOL + '* Fix bug #1',
+      parsed: {
+        _: [
+          '* Update API',
+          '* Fix bug #1'
+        ],
+        Changes: [
+          '* Update API',
+          '* Fix bug #1'
+        ]
+      }
+    },
+    {
+      version: '2.3.0',
+      title: '2.3.0 - 2018-12-18',
+      'date': '2018-12-18',
+      body: '### Added' + EOL + EOL + '- Some changelog generators such as [standard-version](https://github.com/conventional-changelog/standard-version) would produce H1s for major versions and H2s for minor versions. We want the parser to be able to parse both.',
+      parsed: {
+        _: [
+          '- Some changelog generators such as [standard-version](https://github.com/conventional-changelog/standard-version) would produce H1s for major versions and H2s for minor versions. We want the parser to be able to parse both.'
+        ],
+        Added: [
+          '- Some changelog generators such as [standard-version](https://github.com/conventional-changelog/standard-version) would produce H1s for major versions and H2s for minor versions. We want the parser to be able to parse both.'
+        ]
+      }
+    },
+    {
+      version: '2.2.3-pre.1',
+      title: '2.2.3-pre.1 - 2013-02-14',
+      'date': '2013-02-14',
+      body: '### Added' + EOL + '- Added an item.' + EOL + '* Added another item.' + EOL + EOL + '* Update API',
+      parsed: {
+        _: [
+          '- Added an item.',
+          '* Added another item.',
+          '* Update API'
+        ],
+        Added: [
+          '- Added an item.',
+          '* Added another item.',
+          '* Update API'
+        ]
+      }
+    },
+    {
+      version: '2.0.0-x.7.z.92',
+      title: '2.0.0-x.7.z.92 - 2013-02-14',
+      'date': '2013-02-14',
+      body: '* bark bark' + EOL + '* woof' + EOL + '* arf',
+      parsed: {
+        _: [
+          '* bark bark',
+          '* woof',
+          '* arf'
+        ]
+      }
+    },
+    {
+      version: '1.3.0',
+      title: 'v1.3.0',
+      'date': null,
+      body: '* make it so',
+      parsed: {
+        _: [
+          '* make it so'
+        ]
+      }
+    },
+    {
+      version: '1.2.3',
+      title: '[1.2.3](link)',
+      'date': null,
+      body: '* init',
+      parsed: {
+        _: [
+          '* init'
+        ]
+      }
+    }
+  ]
+}

package/node_modules/changelog-parser/test/index.js

@@ -0,0 +1,105 @@
+var parseChangelog = require('..')
+var test = require('tape')
+var path = require('path')
+var fs = require('fs')
+var expected = require('./fixtures/expected')
+var removeMarkdownExpected = require('./fixtures/remove-markdown-expected')
+var filePath = path.join(__dirname, 'fixtures', 'CHANGELOG.md')
+
+test('throws on bad params', function (t) {
+  t.plan(3)
+
+  var missing = 'must provide filePath or text'
+  var invalidPath = 'invalid filePath, expected string'
+  var invalidText = 'invalid text, expected string'
+
+  t.throws(parseChangelog, missing, missing)
+  t.throws(function () {
+    parseChangelog({ filePath: 0 })
+  }, invalidPath, invalidPath)
+  t.throws(function () {
+    parseChangelog({ text: 0 })
+  }, invalidText, invalidText)
+})
+
+test('parses example changelog', function (t) {
+  t.plan(1)
+
+  parseChangelog(filePath, function (err, result) {
+    if (err) throw err
+
+    t.deepEqual(result, expected)
+    t.end()
+  })
+})
+
+test('parses example changelog as text', function (t) {
+  t.plan(1)
+
+  parseChangelog({text: fs.readFileSync(filePath, 'utf8')}, function (err, result) {
+    if (err) throw err
+
+    t.deepEqual(result, expected)
+    t.end()
+  })
+})
+
+test('returns a Promise when invoked without a valid `callback`', function (t) {
+  t.plan(2)
+
+  var result = parseChangelog(filePath)
+
+  t.true(typeof result === 'object')
+  t.true(result instanceof Promise)
+})
+
+test('resolved Promise contains a "CHANGELOG" object', function (t) {
+  t.plan(1)
+
+  parseChangelog(filePath).then(function (result) {
+    t.deepEqual(result, expected)
+    t.end()
+  })
+})
+
+test('callback and Promise methods should yield identical values', function (t) {
+  t.plan(1)
+
+  parseChangelog(filePath, function (err, resultA) {
+    if (err) t.fail()
+
+    parseChangelog(filePath)
+            .then(function (resultB) {
+              t.deepEqual(resultA, resultB)
+              t.end()
+            })
+            .catch(t.fail)
+  })
+})
+
+test('accepts object as first argument', function (t) {
+  t.plan(1)
+
+  parseChangelog({ filePath: filePath }, function (err, result) {
+    if (err) throw err
+
+    t.deepEqual(result, expected)
+    t.end()
+  })
+})
+
+test('accepts { removeMardown: false } option', function (t) {
+  t.plan(1)
+
+  var options = {
+    filePath: filePath,
+    removeMarkdown: false
+  }
+
+  parseChangelog(options, function (err, result) {
+    if (err) throw err
+
+    t.deepEqual(result, removeMarkdownExpected)
+    t.end()
+  })
+})

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;
+}());