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

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

@@ -0,0 +1,222 @@
+var lineReader             = require('../lib/line_reader'),
+    assert                 = require('assert'),
+    testFilePath           = __dirname + '/data/normal_file.txt',
+    separatorFilePath      = __dirname + '/data/separator_file.txt',
+    multiSeparatorFilePath = __dirname + '/data/multi_separator_file.txt',
+    multibyteFilePath      = __dirname + '/data/multibyte_file.txt',
+    emptyFilePath          = __dirname + '/data/empty_file.txt',
+    oneLineFilePath        = __dirname + '/data/one_line_file.txt',
+    threeLineFilePath      = __dirname + '/data/three_line_file.txt',
+    testSeparatorFile      = ['foo', 'bar\n', 'baz\n'],
+    testFile = [
+      'Jabberwocky',
+      '',
+      '’Twas brillig, and the slithy toves',
+      'Did gyre and gimble in the wabe;',
+      '',
+      ''
+    ];
+
+describe("lineReader", function() {
+  describe("eachLine", function() {
+    it("should read lines using the defalut separator", function(done) {
+      var i = 0;
+
+      lineReader.eachLine(testFilePath, function(line, last) {
+        assert.equal(testFile[i], line, 'Each line should be what we expect');
+        i += 1;
+
+        if (i === 6) {
+          assert.ok(last);
+        } else {
+          assert.ok(!last);
+        }
+      }).then(function() {
+        assert.equal(6, i);
+        done();
+      });
+    });
+
+    it("should allow continuation of line reading via a callback", function(done) {
+      var i = 0;
+
+      lineReader.eachLine(testFilePath, function(line, last, cb) {
+        assert.equal(testFile[i], line, 'Each line should be what we expect');
+        i += 1;
+
+        if (i === 6) {
+          assert.ok(last);
+        } else {
+          assert.ok(!last);
+        }
+
+        process.nextTick(cb);
+      }).then(function() {
+        assert.equal(6, i);
+        done();
+      });
+    });
+
+    it("should separate files using given separator", function(done) {
+      var i = 0;
+      lineReader.eachLine(separatorFilePath, function(line, last) {
+        assert.equal(testSeparatorFile[i], line);
+        i += 1;
+      
+        if (i === 3) {
+          assert.ok(last);
+        } else {
+          assert.ok(!last);
+        }
+      }, ';').then(function() {
+        assert.equal(3, i);
+        done();
+      });
+    });
+
+    it("should separate files using given separator with more than one character", function(done) {
+      var i = 0;
+      lineReader.eachLine(multiSeparatorFilePath, function(line, last) {
+        assert.equal(testSeparatorFile[i], line);
+        i += 1;
+      
+        if (i === 3) {
+          assert.ok(last);
+        } else {
+          assert.ok(!last);
+        }
+      }, '||').then(function() {
+        assert.equal(3, i);
+        done();
+      });
+    });
+
+    it("should allow early termination of line reading", function(done) {
+      var i = 0;
+      lineReader.eachLine(testFilePath, function(line, last) {
+        assert.equal(testFile[i], line, 'Each line should be what we expect');
+        i += 1;
+
+        if (i === 2) {
+          return false;
+        }
+      }).then(function() {
+        assert.equal(2, i);
+        done();
+      });
+    });
+
+    it("should allow early termination of line reading via a callback", function(done) {
+      var i = 0;
+      lineReader.eachLine(testFilePath, function(line, last, cb) {
+        assert.equal(testFile[i], line, 'Each line should be what we expect');
+        i += 1;
+
+        if (i === 2) {
+          cb(false);
+        } else {
+          cb();
+        }
+
+      }).then(function() {
+        assert.equal(2, i);
+        done();
+      });
+    });
+
+    it("should not call callback on empty file", function(done) {
+      lineReader.eachLine(emptyFilePath, function(line) {
+        assert.ok(false, "Empty file should not cause any callbacks");
+      }).then(function() {
+        done()
+      });
+    });
+
+    it("should work with a file containing only one line", function(done) {
+      lineReader.eachLine(oneLineFilePath, function(line, last) {
+        done();
+        return false;
+      });
+    });
+
+  });
+
+  describe("open", function() {
+    it("should return a reader object and allow calls to nextLine", function(done) {
+      lineReader.open(testFilePath, function(reader) {
+        assert.ok(reader.hasNextLine());
+      
+        assert.ok(reader.hasNextLine(), 'Calling hasNextLine multiple times should be ok');
+      
+        reader.nextLine(function(line) {
+          assert.equal('Jabberwocky', line);
+          assert.ok(reader.hasNextLine());
+          reader.nextLine(function(line) {
+            assert.equal('', line);
+            assert.ok(reader.hasNextLine());
+            reader.nextLine(function(line) {
+              assert.equal('’Twas brillig, and the slithy toves', line);
+              assert.ok(reader.hasNextLine());
+              reader.nextLine(function(line) {
+                assert.equal('Did gyre and gimble in the wabe;', line);
+                assert.ok(reader.hasNextLine());
+                reader.nextLine(function(line) {
+                  assert.equal('', line);
+                  assert.ok(reader.hasNextLine());
+                  reader.nextLine(function(line) {
+                    assert.equal('', line);
+                    assert.ok(!reader.hasNextLine());
+      
+                    assert.throws(function() {
+                      reader.nextLine(function() {
+                      });
+                    }, Error, "Should be able to read next line at EOF");
+
+                    done();
+                  });
+                });
+              });
+            });
+          });
+        });
+      });
+    });
+
+    it("should work with a file containing only one line", function(done) {
+      lineReader.open(oneLineFilePath, function(reader) {
+        done();
+      });
+    });
+
+    it("should read multibyte characters on the buffer boundary", function(done) {
+      lineReader.open(multibyteFilePath, function(reader) {
+        assert.ok(reader.hasNextLine());
+        reader.nextLine(function(line) {
+          assert.equal('ふうりうの初やおくの田植うた', line,
+                       "Should read multibyte characters on buffer boundary");
+          done();
+        });
+      }, '\n', 'utf8', 2);
+    });
+
+    describe("hasNextLine", function() {
+      it("should return true when buffer is empty but not at EOF", function(done) {
+        lineReader.open(threeLineFilePath, function(reader) {
+          reader.nextLine(function(line) {
+            assert.equal("This is line one.", line);
+            assert.ok(reader.hasNextLine());
+            reader.nextLine(function(line) {
+              assert.equal("This is line two.", line);
+              assert.ok(reader.hasNextLine());
+              reader.nextLine(function(line) {
+                assert.equal("This is line three.", line);
+                assert.ok(!reader.hasNextLine());
+                done();
+              });
+            });
+          });
+        }, '\n', 'utf-8', 36);
+      });
+    });
+  });
+});

package/node_modules/lru-cache/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/node_modules/lru-cache/README.md

@@ -0,0 +1,166 @@
+# lru cache
+
+A cache object that deletes the least-recently-used items.
+
+[![Build Status](https://travis-ci.org/isaacs/node-lru-cache.svg?branch=master)](https://travis-ci.org/isaacs/node-lru-cache) [![Coverage Status](https://coveralls.io/repos/isaacs/node-lru-cache/badge.svg?service=github)](https://coveralls.io/github/isaacs/node-lru-cache)
+
+## Installation:
+
+```javascript
+npm install lru-cache --save
+```
+
+## Usage:
+
+```javascript
+var LRU = require("lru-cache")
+  , options = { max: 500
+              , length: function (n, key) { return n * 2 + key.length }
+              , dispose: function (key, n) { n.close() }
+              , maxAge: 1000 * 60 * 60 }
+  , cache = new LRU(options)
+  , otherCache = new LRU(50) // sets just the max size
+
+cache.set("key", "value")
+cache.get("key") // "value"
+
+// non-string keys ARE fully supported
+// but note that it must be THE SAME object, not
+// just a JSON-equivalent object.
+var someObject = { a: 1 }
+cache.set(someObject, 'a value')
+// Object keys are not toString()-ed
+cache.set('[object Object]', 'a different value')
+assert.equal(cache.get(someObject), 'a value')
+// A similar object with same keys/values won't work,
+// because it's a different object identity
+assert.equal(cache.get({ a: 1 }), undefined)
+
+cache.reset()    // empty the cache
+```
+
+If you put more stuff in it, then items will fall out.
+
+If you try to put an oversized thing in it, then it'll fall out right
+away.
+
+## Options
+
+* `max` The maximum size of the cache, checked by applying the length
+  function to all values in the cache.  Not setting this is kind of
+  silly, since that's the whole purpose of this lib, but it defaults
+  to `Infinity`.  Setting it to a non-number or negative number will
+  throw a `TypeError`.  Setting it to 0 makes it be `Infinity`.
+* `maxAge` Maximum age in ms.  Items are not pro-actively pruned out
+  as they age, but if you try to get an item that is too old, it'll
+  drop it and return undefined instead of giving it to you.
+  Setting this to a negative value will make everything seem old!
+  Setting it to a non-number will throw a `TypeError`.
+* `length` Function that is used to calculate the length of stored
+  items.  If you're storing strings or buffers, then you probably want
+  to do something like `function(n, key){return n.length}`.  The default is
+  `function(){return 1}`, which is fine if you want to store `max`
+  like-sized things.  The item is passed as the first argument, and
+  the key is passed as the second argumnet.
+* `dispose` Function that is called on items when they are dropped
+  from the cache.  This can be handy if you want to close file
+  descriptors or do other cleanup tasks when items are no longer
+  accessible.  Called with `key, value`.  It's called *before*
+  actually removing the item from the internal cache, so if you want
+  to immediately put it back in, you'll have to do that in a
+  `nextTick` or `setTimeout` callback or it won't do anything.
+* `stale` By default, if you set a `maxAge`, it'll only actually pull
+  stale items out of the cache when you `get(key)`.  (That is, it's
+  not pre-emptively doing a `setTimeout` or anything.)  If you set
+  `stale:true`, it'll return the stale value before deleting it.  If
+  you don't set this, then it'll return `undefined` when you try to
+  get a stale entry, as if it had already been deleted.
+* `noDisposeOnSet` By default, if you set a `dispose()` method, then
+  it'll be called whenever a `set()` operation overwrites an existing
+  key.  If you set this option, `dispose()` will only be called when a
+  key falls out of the cache, not when it is overwritten.
+* `updateAgeOnGet` When using time-expiring entries with `maxAge`,
+  setting this to `true` will make each item's effective time update
+  to the current time whenever it is retrieved from cache, causing it
+  to not expire.  (It can still fall out of cache based on recency of
+  use, of course.)
+
+## API
+
+* `set(key, value, maxAge)`
+* `get(key) => value`
+
+    Both of these will update the "recently used"-ness of the key.
+    They do what you think. `maxAge` is optional and overrides the
+    cache `maxAge` option if provided.
+
+    If the key is not found, `get()` will return `undefined`.
+
+    The key and val can be any value.
+
+* `peek(key)`
+
+    Returns the key value (or `undefined` if not found) without
+    updating the "recently used"-ness of the key.
+
+    (If you find yourself using this a lot, you *might* be using the
+    wrong sort of data structure, but there are some use cases where
+    it's handy.)
+
+* `del(key)`
+
+    Deletes a key out of the cache.
+
+* `reset()`
+
+    Clear the cache entirely, throwing away all values.
+
+* `has(key)`
+
+    Check if a key is in the cache, without updating the recent-ness
+    or deleting it for being stale.
+
+* `forEach(function(value,key,cache), [thisp])`
+
+    Just like `Array.prototype.forEach`.  Iterates over all the keys
+    in the cache, in order of recent-ness.  (Ie, more recently used
+    items are iterated over first.)
+
+* `rforEach(function(value,key,cache), [thisp])`
+
+    The same as `cache.forEach(...)` but items are iterated over in
+    reverse order.  (ie, less recently used items are iterated over
+    first.)
+
+* `keys()`
+
+    Return an array of the keys in the cache.
+
+* `values()`
+
+    Return an array of the values in the cache.
+
+* `length`
+
+    Return total length of objects in cache taking into account
+    `length` options function.
+
+* `itemCount`
+
+    Return total quantity of objects currently in cache. Note, that
+    `stale` (see options) items are returned as part of this item
+    count.
+
+* `dump()`
+
+    Return an array of the cache entries ready for serialization and usage
+    with 'destinationCache.load(arr)`.
+
+* `load(cacheEntriesArray)`
+
+    Loads another cache entries array, obtained with `sourceCache.dump()`,
+    into the cache. The destination cache is reset before loading new entries
+
+* `prune()`
+
+    Manually iterates over the entire cache proactively pruning old entries