node_modules

8 files changed, 809 insertions, 0 deletions

diff --git a/node_modules/cliui/.coveralls.yml b/node_modules/cliui/.coveralls.yml
new file mode 100644
index 000000000..73367dbd7
--- /dev/null
+++ b/node_modules/cliui/.coveralls.yml
@@ -0,0 +1 @@
+repo_token: NiRhyj91Z2vtgob6XdEAqs83rzNnbMZUu
diff --git a/node_modules/cliui/.npmignore b/node_modules/cliui/.npmignore
new file mode 100644
index 000000000..9daa8247d
--- /dev/null
+++ b/node_modules/cliui/.npmignore
@@ -0,0 +1,2 @@
+.DS_Store
+node_modules
diff --git a/node_modules/cliui/.travis.yml b/node_modules/cliui/.travis.yml
new file mode 100644
index 000000000..d96edf8ec
--- /dev/null
+++ b/node_modules/cliui/.travis.yml
@@ -0,0 +1,7 @@
+language: node_js
+node_js:
+  - "0.10"
+  - "0.11"
+  - "0.12"
+  - "iojs"
+after_script: "NODE_ENV=test YOURPACKAGE_COVERAGE=1 ./node_modules/.bin/mocha --require patched-blanket --reporter mocha-lcov-reporter | ./node_modules/coveralls/bin/coveralls.js"
diff --git a/node_modules/cliui/LICENSE.txt b/node_modules/cliui/LICENSE.txt
new file mode 100644
index 000000000..c7e27478a
--- /dev/null
+++ b/node_modules/cliui/LICENSE.txt
@@ -0,0 +1,14 @@
+Copyright (c) 2015, 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.
diff --git a/node_modules/cliui/README.md b/node_modules/cliui/README.md
new file mode 100644
index 000000000..edcafa8ed
--- /dev/null
+++ b/node_modules/cliui/README.md
@@ -0,0 +1,104 @@
+# cliui
+
+[![Build Status](https://travis-ci.org/bcoe/cliui.png)](https://travis-ci.org/bcoe/cliui)
+[![Coverage Status](https://coveralls.io/repos/bcoe/cliui/badge.svg?branch=)](https://coveralls.io/r/bcoe/cliui?branch=)
+[![NPM version](https://img.shields.io/npm/v/cliui.svg)](https://www.npmjs.com/package/cliui)
+
+easily create complex multi-column command-line-interfaces.
+
+## Example
+
+```js
+var ui = require('cliui')({
+  width: 80
+})
+
+ui.div('Usage: $0 [command] [options]')
+
+ui.div({
+  text: 'Options:',
+  padding: [2, 0, 2, 0]
+})
+
+ui.div(
+  {
+    text: "-f, --file",
+    width: 40,
+    padding: [0, 4, 0, 4]
+  },
+  {
+    text: "the file to load",
+    width: 25
+  },
+  {
+    text: "[required]",
+    align: 'right'
+  }
+)
+
+console.log(ui.toString())
+```
+
+## Layout DSL
+
+cliui exposes a simple layout DSL:
+
+If you create a single `ui.row`, passing a string rather than an
+object:
+
+* `\n`: characters will be interpreted as new rows.
+* `\t`: characters will be interpreted as new columns.
+* ` `: characters will be interpreted as padding.
+
+**as an example...**
+
+```js
+var ui = require('./')({
+  width: 60
+})
+
+ui.div(
+  'Usage: node ./bin/foo.js\n' +
+  '  <regex>\t  provide a regex\n' +
+  '  <glob>\t  provide a glob\t [required]'
+)
+
+console.log(ui.toString())
+```
+
+**will output:**
+
+```shell
+Usage: node ./bin/foo.js
+  <regex>  provide a regex
+  <glob>   provide a glob          [required]
+```
+
+## Methods
+
+```js
+cliui = require('cliui')
+```
+
+### cliui({width: integer})
+
+Specify the maximum width of the UI being generated.
+
+### cliui({wrap: boolean})
+
+Enable or disable the wrapping of text in a column.
+
+### cliui.div(column, column, column)
+
+Create a row with any number of columns, a column
+can either be a string, or an object with the following
+options:
+
+* **width:** the width of a column.
+* **align:** alignment, `right` or `center`.
+* **padding:** `[top, right, bottom, left]`.
+
+### cliui.span(column, column, column)
+
+Similar to `div`, except the next row will be appended without
+a new line being created.
diff --git a/node_modules/cliui/index.js b/node_modules/cliui/index.js
new file mode 100644
index 000000000..31b4aa7b7
--- /dev/null
+++ b/node_modules/cliui/index.js
@@ -0,0 +1,273 @@
+var wrap = require('wordwrap'),
+  align = {
+    right: require('right-align'),
+    center: require('center-align')
+  },
+  top = 0,
+  right = 1,
+  bottom = 2,
+  left = 3
+
+function UI (opts) {
+  this.width = opts.width
+  this.wrap = opts.wrap
+  this.rows = []
+}
+
+UI.prototype.span = function () {
+  var cols = this.div.apply(this, arguments)
+  cols.span = true
+}
+
+UI.prototype.div = function () {
+  if (arguments.length === 0) this.div('')
+  if (this.wrap && this._shouldApplyLayoutDSL.apply(this, arguments)) {
+    return this._applyLayoutDSL(arguments[0])
+  }
+
+  var cols = []
+
+  for (var i = 0, arg; (arg = arguments[i]) !== undefined; i++) {
+    if (typeof arg === 'string') cols.push(this._colFromString(arg))
+    else cols.push(arg)
+  }
+
+  this.rows.push(cols)
+  return cols
+}
+
+UI.prototype._shouldApplyLayoutDSL = function () {
+  return arguments.length === 1 && typeof arguments[0] === 'string' &&
+    /[\t\n]/.test(arguments[0])
+}
+
+UI.prototype._applyLayoutDSL = function (str) {
+  var _this = this,
+    rows = str.split('\n'),
+    leftColumnWidth = 0
+
+  // simple heuristic for layout, make sure the
+  // second column lines up along the left-hand.
+  // don't allow the first column to take up more
+  // than 50% of the screen.
+  rows.forEach(function (row) {
+    var columns = row.split('\t')
+    if (columns.length > 1 && columns[0].length > leftColumnWidth) {
+      leftColumnWidth = Math.min(
+        Math.floor(_this.width * 0.5),
+        columns[0].length
+      )
+    }
+  })
+
+  // generate a table:
+  //  replacing ' ' with padding calculations.
+  //  using the algorithmically generated width.
+  rows.forEach(function (row) {
+    var columns = row.split('\t')
+    _this.div.apply(_this, columns.map(function (r, i) {
+      return {
+        text: r.trim(),
+        padding: [0, r.match(/\s*$/)[0].length, 0, r.match(/^\s*/)[0].length],
+        width: (i === 0 && columns.length > 1) ? leftColumnWidth : undefined
+      }
+    }))
+  })
+
+  return this.rows[this.rows.length - 1]
+}
+
+UI.prototype._colFromString = function (str) {
+  return {
+    text: str
+  }
+}
+
+UI.prototype.toString = function () {
+  var _this = this,
+    lines = []
+
+  _this.rows.forEach(function (row, i) {
+    _this.rowToString(row, lines)
+  })
+
+  // don't display any lines with the
+  // hidden flag set.
+  lines = lines.filter(function (line) {
+    return !line.hidden
+  })
+
+  return lines.map(function (line) {
+    return line.text
+  }).join('\n')
+}
+
+UI.prototype.rowToString = function (row, lines) {
+  var _this = this,
+    paddingLeft,
+    rrows = this._rasterize(row),
+    str = '',
+    ts,
+    width,
+    wrapWidth
+
+  rrows.forEach(function (rrow, r) {
+    str = ''
+    rrow.forEach(function (col, c) {
+      ts = '' // temporary string used during alignment/padding.
+      width = row[c].width // the width with padding.
+      wrapWidth = _this._negatePadding(row[c]) // the width without padding.
+
+      for (var i = 0; i < Math.max(wrapWidth, col.length); i++) {
+        ts += col.charAt(i) || ' '
+      }
+
+      // align the string within its column.
+      if (row[c].align && row[c].align !== 'left' && _this.wrap) {
+        ts = align[row[c].align](ts.trim() + '\n' + new Array(wrapWidth + 1).join(' '))
+          .split('\n')[0]
+        if (ts.length < wrapWidth) ts += new Array(width - ts.length).join(' ')
+      }
+
+      // add left/right padding and print string.
+      paddingLeft = (row[c].padding || [0, 0, 0, 0])[left]
+      if (paddingLeft) str += new Array(row[c].padding[left] + 1).join(' ')
+      str += ts
+      if (row[c].padding && row[c].padding[right]) str += new Array(row[c].padding[right] + 1).join(' ')
+
+      // if prior row is span, try to render the
+      // current row on the prior line.
+      if (r === 0 && lines.length > 0) {
+        str = _this._renderInline(str, lines[lines.length - 1], paddingLeft)
+      }
+    })
+
+    // remove trailing whitespace.
+    lines.push({
+      text: str.replace(/ +$/, ''),
+      span: row.span
+    })
+  })
+
+  return lines
+}
+
+// if the full 'source' can render in
+// the target line, do so.
+UI.prototype._renderInline = function (source, previousLine, paddingLeft) {
+  var target = previousLine.text,
+    str = ''
+
+  if (!previousLine.span) return source
+
+  // if we're not applying wrapping logic,
+  // just always append to the span.
+  if (!this.wrap) {
+    previousLine.hidden = true
+    return target + source
+  }
+
+  for (var i = 0, tc, sc; i < Math.max(source.length, target.length); i++) {
+    tc = target.charAt(i) || ' '
+    sc = source.charAt(i) || ' '
+    // we tried to overwrite a character in the other string.
+    if (tc !== ' ' && sc !== ' ') return source
+    // there is not enough whitespace to maintain padding.
+    if (sc !== ' ' && i < paddingLeft + target.length) return source
+    // :thumbsup:
+    if (tc === ' ') str += sc
+    else str += tc
+  }
+
+  previousLine.hidden = true
+
+  return str
+}
+
+UI.prototype._rasterize = function (row) {
+  var _this = this,
+    i,
+    rrow,
+    rrows = [],
+    widths = this._columnWidths(row),
+    wrapped
+
+  // word wrap all columns, and create
+  // a data-structure that is easy to rasterize.
+  row.forEach(function (col, c) {
+    // leave room for left and right padding.
+    col.width = widths[c]
+    if (_this.wrap) wrapped = wrap.hard(_this._negatePadding(col))(col.text).split('\n')
+    else wrapped = col.text.split('\n')
+
+    // add top and bottom padding.
+    if (col.padding) {
+      for (i = 0; i < (col.padding[top] || 0); i++) wrapped.unshift('')
+      for (i = 0; i < (col.padding[bottom] || 0); i++) wrapped.push('')
+    }
+
+    wrapped.forEach(function (str, r) {
+      if (!rrows[r]) rrows.push([])
+
+      rrow = rrows[r]
+
+      for (var i = 0; i < c; i++) {
+        if (rrow[i] === undefined) rrow.push('')
+      }
+      rrow.push(str)
+    })
+  })
+
+  return rrows
+}
+
+UI.prototype._negatePadding = function (col) {
+  var wrapWidth = col.width
+  if (col.padding) wrapWidth -= (col.padding[left] || 0) + (col.padding[right] || 0)
+  return wrapWidth
+}
+
+UI.prototype._columnWidths = function (row) {
+  var _this = this,
+    widths = [],
+    unset = row.length,
+    unsetWidth,
+    remainingWidth = this.width
+
+  // column widths can be set in config.
+  row.forEach(function (col, i) {
+    if (col.width) {
+      unset--
+      widths[i] = col.width
+      remainingWidth -= col.width
+    } else {
+      widths[i] = undefined
+    }
+  })
+
+  // any unset widths should be calculated.
+  if (unset) unsetWidth = Math.floor(remainingWidth / unset)
+  widths.forEach(function (w, i) {
+    if (!_this.wrap) widths[i] = row[i].width || row[i].text.length
+    else if (w === undefined) widths[i] = Math.max(unsetWidth, _minWidth(row[i]))
+  })
+
+  return widths
+}
+
+// calculates the minimum width of
+// a column, based on padding preferences.
+function _minWidth (col) {
+  var padding = col.padding || []
+
+  return 1 + (padding[left] || 0) + (padding[right] || 0)
+}
+
+module.exports = function (opts) {
+  opts = opts || {}
+
+  return new UI({
+    width: (opts || {}).width || 80,
+    wrap: typeof opts.wrap === 'boolean' ? opts.wrap : true
+  })
+}
diff --git a/node_modules/cliui/package.json b/node_modules/cliui/package.json
new file mode 100644
index 000000000..868ae2eaa
--- /dev/null
+++ b/node_modules/cliui/package.json
@@ -0,0 +1,59 @@
+{
+  "name": "cliui",
+  "version": "2.1.0",
+  "description": "easily create complex multi-column command-line-interfaces",
+  "main": "index.js",
+  "scripts": {
+    "test": "standard && mocha --check-leaks --ui exports --require patched-blanket -R mocoverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/bcoe/cliui.git"
+  },
+  "config": {
+    "blanket": {
+      "pattern": [
+        "index.js"
+      ],
+      "data-cover-never": [
+        "node_modules",
+        "test"
+      ],
+      "output-reporter": "spec"
+    }
+  },
+  "standard": {
+    "ignore": [
+      "**/example/**"
+    ],
+    "globals": [
+      "it"
+    ]
+  },
+  "keywords": [
+    "cli",
+    "command-line",
+    "layout",
+    "design",
+    "console",
+    "wrap",
+    "table"
+  ],
+  "author": "Ben Coe <ben@npmjs.com>",
+  "license": "ISC",
+  "dependencies": {
+    "center-align": "^0.1.1",
+    "right-align": "^0.1.1",
+    "wordwrap": "0.0.2"
+  },
+  "devDependencies": {
+    "blanket": "^1.1.6",
+    "chai": "^2.2.0",
+    "coveralls": "^2.11.2",
+    "mocha": "^2.2.4",
+    "mocha-lcov-reporter": "0.0.2",
+    "mocoverage": "^1.0.0",
+    "patched-blanket": "^1.0.1",
+    "standard": "^3.6.1"
+  }
+}
diff --git a/node_modules/cliui/test/cliui.js b/node_modules/cliui/test/cliui.js
new file mode 100644
index 000000000..1cc6127cb
--- /dev/null
+++ b/node_modules/cliui/test/cliui.js
@@ -0,0 +1,349 @@
+/* global describe, it */
+
+require('chai').should()
+
+var cliui = require('../')
+
+describe('cliui', function () {
+  describe('div', function () {
+    it("wraps text at 'width' if a single column is given", function () {
+      var ui = cliui({
+        width: 10
+      })
+
+      ui.div('i am a string that should be wrapped')
+
+      ui.toString().split('\n').forEach(function (row) {
+        row.length.should.be.lte(10)
+      })
+    })
+
+    it('evenly divides text across columns if multiple columns are given', function () {
+      var ui = cliui({
+        width: 40
+      })
+
+      ui.div(
+        {text: 'i am a string that should be wrapped', width: 15},
+        'i am a second string that should be wrapped',
+        'i am a third string that should be wrapped'
+      )
+
+      // total width of all columns is <=
+      // the width cliui is initialized with.
+      ui.toString().split('\n').forEach(function (row) {
+        row.length.should.be.lte(40)
+      })
+
+      // it should wrap each column appropriately.
+      var expected = [
+       'i am a string  i am a      i am a third',
+       'that should be second      string that',
+       'wrapped        string that should be',
+       '               should be   wrapped',
+       '               wrapped'
+      ]
+
+      ui.toString().split('\n').should.eql(expected)
+    })
+
+    it('allows for a blank row to be appended', function () {
+      var ui = cliui({
+        width: 40
+      })
+
+      ui.div()
+
+      // it should wrap each column appropriately.
+      var expected = ['']
+
+      ui.toString().split('\n').should.eql(expected)
+    })
+  })
+
+  describe('_columnWidths', function () {
+    it('uses same width for each column by default', function () {
+      var ui = cliui({
+          width: 40
+        }),
+        widths = ui._columnWidths([{}, {}, {}])
+
+      widths[0].should.equal(13)
+      widths[1].should.equal(13)
+      widths[2].should.equal(13)
+    })
+
+    it('divides width over remaining columns if first column has width specified', function () {
+      var ui = cliui({
+          width: 40
+        }),
+        widths = ui._columnWidths([{width: 20}, {}, {}])
+
+      widths[0].should.equal(20)
+      widths[1].should.equal(10)
+      widths[2].should.equal(10)
+    })
+
+    it('divides width over remaining columns if middle column has width specified', function () {
+      var ui = cliui({
+          width: 40
+        }),
+        widths = ui._columnWidths([{}, {width: 10}, {}])
+
+      widths[0].should.equal(15)
+      widths[1].should.equal(10)
+      widths[2].should.equal(15)
+    })
+
+    it('keeps track of remaining width if multiple columns have width specified', function () {
+      var ui = cliui({
+          width: 40
+        }),
+        widths = ui._columnWidths([{width: 20}, {width: 12}, {}])
+
+      widths[0].should.equal(20)
+      widths[1].should.equal(12)
+      widths[2].should.equal(8)
+    })
+
+    it('uses a sane default if impossible widths are specified', function () {
+      var ui = cliui({
+          width: 40
+        }),
+        widths = ui._columnWidths([{width: 30}, {width: 30}, {padding: [0, 2, 0, 1]}])
+
+      widths[0].should.equal(30)
+      widths[1].should.equal(30)
+      widths[2].should.equal(4)
+    })
+  })
+
+  describe('alignment', function () {
+    it('allows a column to be right aligned', function () {
+      var ui = cliui({
+        width: 40
+      })
+
+      ui.div(
+        'i am a string',
+        {text: 'i am a second string', align: 'right'},
+        'i am a third string that should be wrapped'
+      )
+
+      // it should right-align the second column.
+      var expected = [
+       'i am a stringi am a secondi am a third',
+       '                    stringstring that',
+       '                          should be',
+       '                          wrapped'
+      ]
+
+      ui.toString().split('\n').should.eql(expected)
+    })
+
+    it('allows a column to be center aligned', function () {
+      var ui = cliui({
+        width: 60
+      })
+
+      ui.div(
+        'i am a string',
+        {text: 'i am a second string', align: 'center', padding: [0, 2, 0, 2]},
+        'i am a third string that should be wrapped'
+      )
+
+      // it should right-align the second column.
+      var expected = [
+       'i am a string          i am a second       i am a third string',
+       '                           string          that should be',
+       '                                           wrapped'
+      ]
+
+      ui.toString().split('\n').should.eql(expected)
+    })
+  })
+
+  describe('padding', function () {
+    it('handles left/right padding', function () {
+      var ui = cliui({
+        width: 40
+      })
+
+      ui.div(
+        {text: 'i have padding on my left', padding: [0, 0, 0, 4]},
+        {text: 'i have padding on my right', padding: [0, 2, 0, 0], align: 'center'},
+        {text: 'i have no padding', padding: [0, 0, 0, 0]}
+      )
+
+      // it should add left/right padding to columns.
+      var expected = [
+       '    i have     i have      i have no',
+       '    padding  padding on    padding',
+       '    on my     my right',
+       '    left'
+      ]
+
+      ui.toString().split('\n').should.eql(expected)
+    })
+
+    it('handles top/bottom padding', function () {
+      var ui = cliui({
+        width: 40
+      })
+
+      ui.div(
+        'i am a string',
+        {text: 'i am a second string', padding: [2, 0, 0, 0]},
+        {text: 'i am a third string that should be wrapped', padding: [0, 0, 1, 0]}
+      )
+
+      // it should add top/bottom padding to second
+      // and third columns.
+      var expected = [
+       'i am a string             i am a third',
+       '                          string that',
+       '             i am a secondshould be',
+       '             string       wrapped',
+       ''
+      ]
+
+      ui.toString().split('\n').should.eql(expected)
+    })
+  })
+
+  describe('wrap', function () {
+    it('allows wordwrap to be disabled', function () {
+      var ui = cliui({
+        wrap: false
+      })
+
+      ui.div(
+        {text: 'i am a string', padding: [0, 1, 0, 0]},
+        {text: 'i am a second string', padding: [0, 2, 0, 0]},
+        {text: 'i am a third string that should not be wrapped', padding: [0, 0, 0, 2]}
+      )
+
+      ui.toString().should.equal('i am a string i am a second string    i am a third string that should not be wrapped')
+    })
+  })
+
+  describe('span', function () {
+    it('appends the next row to the end of the prior row if it fits', function () {
+      var ui = cliui({
+        width: 40
+      })
+
+      ui.span(
+        {text: 'i am a string that will be wrapped', width: 30}
+      )
+
+      ui.div(
+        {text: ' [required] [default: 99]', align: 'right'}
+      )
+
+      var expected = [
+       'i am a string that will be',
+       'wrapped         [required] [default: 99]'
+      ]
+
+      ui.toString().split('\n').should.eql(expected)
+    })
+
+    it('does not append the string if it does not fit on the prior row', function () {
+      var ui = cliui({
+        width: 40
+      })
+
+      ui.span(
+        {text: 'i am a string that will be wrapped', width: 30}
+      )
+
+      ui.div(
+        {text: 'i am a second row', align: 'left'}
+      )
+
+      var expected = [
+       'i am a string that will be',
+       'wrapped',
+       'i am a second row'
+      ]
+
+      ui.toString().split('\n').should.eql(expected)
+    })
+
+    it('always appends text to prior span if wrap is disabled', function () {
+      var ui = cliui({
+        wrap: false,
+        width: 40
+      })
+
+      ui.span(
+        {text: 'i am a string that will be wrapped', width: 30}
+      )
+
+      ui.div(
+        {text: 'i am a second row', align: 'left', padding: [0, 0, 0, 3]}
+      )
+
+      ui.div('a third line')
+
+      var expected = [
+       'i am a string that will be wrapped   i am a second row',
+       'a third line'
+      ]
+
+      ui.toString().split('\n').should.eql(expected)
+    })
+  })
+
+  describe('layoutDSL', function () {
+    it('turns tab into multiple columns', function () {
+      var ui = cliui({
+        width: 60
+      })
+
+      ui.div(
+        '  <regex>  \tmy awesome regex\n  <my second thing>  \tanother row\t  a third column'
+      )
+
+      var expected = [
+       '  <regex>            my awesome regex',
+       '  <my second thing>  another row          a third column'
+      ]
+
+      ui.toString().split('\n').should.eql(expected)
+    })
+
+    it('turns newline into multiple rows', function () {
+      var ui = cliui({
+        width: 40
+      })
+
+      ui.div(
+        'Usage: $0\n  <regex>\t  my awesome regex\n  <glob>\t  my awesome glob\t  [required]'
+      )
+      var expected = [
+       'Usage: $0',
+       '  <regex>  my awesome regex',
+       '  <glob>   my awesome     [required]',
+       '           glob'
+      ]
+
+      ui.toString().split('\n').should.eql(expected)
+    })
+
+    it('does not apply DSL if wrap is false', function () {
+      var ui = cliui({
+        width: 40,
+        wrap: false
+      })
+
+      ui.div(
+        'Usage: $0\ttwo\tthree'
+      )
+
+      ui.toString().should.eql('Usage: $0\ttwo\tthree')
+    })
+
+  })
+})