@heroku/heroku-cli-util 8.0.12

package/lib/styled.js

@@ -0,0 +1,131 @@
+'use strict'
+
+let cli = require('..')
+let util = require('util')
+
+/**
+ * styledJSON prints out colored, indented JSON
+ *
+ * @example
+ * styledHeader({foo: 'bar'}) # Outputs === {
+ *                                            "foo": "bar"
+ *                                          }
+ *
+ * @param {obj} object data to display
+ * @returns {null}
+ */
+function styledJSON (obj) {
+  let json = JSON.stringify(obj, null, 2)
+  if (cli.color.enabled) {
+    let cardinal = require('cardinal')
+    let theme = require('cardinal/themes/jq')
+    cli.log(cardinal.highlight(json, { json: true, theme: theme }))
+  } else {
+    cli.log(json)
+  }
+}
+
+/**
+ * styledHeader logs in a consistent header style
+ *
+ * @example
+ * styledHeader('MyApp') # Outputs === MyApp
+ *
+ * @param {header} header text
+ * @returns {null}
+ */
+function styledHeader (header) {
+  cli.log(cli.color.dim('=== ') + cli.color.bold(header))
+}
+
+/**
+ * styledObject logs an object in a consistent columnar style
+ *
+ * @example
+ * styledObject({name: "myapp", collaborators: ["user1@example.com", "user2@example.com"]})
+ * Collaborators: user1@example.com
+ *                user2@example.com
+ * Name:          myapp
+ *
+ * @param {obj} object data to print
+ * @param {keys} optional array of keys to sort/filter output
+ * @returns {null}
+ */
+function styledObject (obj, keys) {
+  let keyLengths = Object.keys(obj).map(key => key.toString().length)
+  let maxKeyLength = Math.max.apply(Math, keyLengths) + 2
+  function pp (obj) {
+    if (typeof obj === 'string' || typeof obj === 'number') {
+      return obj
+    } else if (typeof obj === 'object') {
+      return Object.keys(obj).map(k => k + ': ' + util.inspect(obj[k])).join(', ')
+    } else {
+      return util.inspect(obj)
+    }
+  }
+  function logKeyValue (key, value) {
+    cli.log(`${key}:` + ' '.repeat(maxKeyLength - key.length - 1) + pp(value))
+  }
+  for (var key of (keys || Object.keys(obj).sort())) {
+    let value = obj[key]
+    if (Array.isArray(value)) {
+      if (value.length > 0) {
+        logKeyValue(key, value[0])
+        for (var e of value.slice(1)) {
+          cli.log(' '.repeat(maxKeyLength) + pp(e))
+        }
+      }
+    } else if (value !== null && value !== undefined) {
+      logKeyValue(key, value)
+    }
+  }
+}
+
+/**
+ * styledNameValues logs an array of {name: '', values: ['']} objects in a consistent style
+ *
+ * @example
+ * styledNameValues([{name: "Collaborators", values: ["user1@example.com", "user2@example.com"]},
+ *               {name: "Name", values: ["myapp"]}])
+ * Collaborators: user1@example.com
+ *                user2@example.com
+ * Name:          myapp
+ *
+ * @param {nameValues} nameValues
+ * @returns {null}
+ */
+function styledNameValues (nameValues) {
+  let keys = nameValues.map(nameValue => nameValue.name)
+  let keyLengths = keys.map(name => name.toString().length)
+  let maxKeyLength = Math.max.apply(Math, keyLengths) + 2
+  function pp (obj) {
+    if (typeof obj === 'string' || typeof obj === 'number') {
+      return obj
+    } else if (typeof obj === 'object') {
+      return Object.keys(obj).map(k => k + ': ' + cli.inspect(obj[k])).join(', ')
+    } else {
+      return cli.inspect(obj)
+    }
+  }
+  function logKeyValue (key, value) {
+    cli.log(`${key}:` + ' '.repeat(maxKeyLength - key.length - 1) + pp(value))
+  }
+  for (var nameValue of nameValues) {
+    let value = nameValue.values
+    if (Array.isArray(value)) {
+      if (value.length > 0) {
+        logKeyValue(nameValue.name, value[0])
+        for (var e of value.slice(1)) {
+          cli.log(' '.repeat(maxKeyLength) + pp(e))
+        }
+      }
+    } else if (value !== null && value !== undefined) {
+      logKeyValue(nameValue.name, value)
+    }
+  }
+}
+
+module.exports.styledJSON = styledJSON
+module.exports.styledHeader = styledHeader
+module.exports.styledObject = styledObject
+module.exports.styledNameValues = styledNameValues

package/lib/table.js

@@ -0,0 +1,132 @@
+'use strict'
+
+const stripAnsi = require('strip-ansi')
+const cli = require('..')
+const { ary, defaults, get, identity, keys, noop, partial, property, result, repeat } = require('lodash')
+
+/**
+ * Generates a Unicode table and feeds it into configured printer.
+ *
+ * Top-level arguments:
+ *
+ * @arg {Object[]} data - the records to format as a table.
+ * @arg {Object} options - configuration for the table.
+ *
+ * @arg {Object[]} [options.columns] - Options for formatting and finding values for table columns.
+ * @arg {function(string)} [options.headerAnsi] - Zero-width formattter for entire header.
+ * @arg {string} [options.colSep] - Separator between columns.
+ * @arg {function(row, options)} [options.after] - Function called after each row is printed.
+ * @arg {function(string)} [options.printLine] - Function responsible for printing to terminal.
+ * @arg {function(cells)} [options.printHeader] - Function to print header cells as a row.
+ * @arg {function(cells)} [options.printRow] - Function to print cells as a row.
+ *
+ * @arg {function(row)|string} [options.columns[].key] - Path to the value in the row or function to retrieve the pre-formatted value for the cell.
+ * @arg {function(string)} [options.columns[].label] - Header name for column.
+ * @arg {function(string, row)} [options.columns[].format] - Formatter function for column value.
+ * @arg {function(row)} [options.columns[].get] - Function to return a value to be presented in cell without formatting.
+ *
+ */
+function table (data, options) {
+  let _defaults = {
+    colSep: '  ',
+    after: noop,
+    headerAnsi: identity,
+    printLine: cli.log,
+    printRow: function (cells) {
+      this.printLine(cells.join(this.colSep).trimRight())
+    },
+    printHeader: function (cells) {
+      this.printRow(cells.map(ary(this.headerAnsi, 1)))
+      this.printRow(cells.map(hdr => hdr.replace(/./g, '─')))
+    }
+  }
+
+  let colDefaults = {
+    format: value => value ? value.toString() : '',
+    width: 0,
+    label: function () { return this.key.toString() },
+
+    get: function (row) {
+      let value
+      let path = result(this, 'key')
+
+      if (!path) {
+        value = row
+      } else {
+        value = get(row, path)
+      }
+
+      let formatted = this.format(value, row)
+      return formatted == null ? '' : formatted.toString()
+    }
+  }
+
+  function calcWidth (cell) {
+    let lines = stripAnsi(cell).split(/[\r\n]+/)
+    let lineLengths = lines.map(property('length'))
+    return Math.max.apply(Math, lineLengths)
+  }
+
+  function pad (string, length) {
+    let visibleLength = stripAnsi(string).length
+    let diff = length - visibleLength
+
+    return string + repeat(' ', Math.max(0, diff))
+  }
+
+  function render () {
+    let columns = options.columns || keys(data[0] || {})
+
+    if (typeof columns[0] === 'string') {
+      columns = columns.map(key => ({ key }))
+    }
+
+    let defaultsApplied = false
+    for (let row of data) {
+      row.height = 1
+      for (let col of columns) {
+        if (!defaultsApplied) defaults(col, colDefaults)
+
+        let cell = col.get(row)
+
+        col.width = Math.max(
+          result(col, 'label').length,
+          col.width,
+          calcWidth(cell)
+        )
+
+        row.height = Math.max(
+          row.height,
+          cell.split(/[\r\n]+/).length
+        )
+      }
+      defaultsApplied = true
+    }
+
+    if (options.printHeader) {
+      options.printHeader(columns.map(function (col) {
+        let label = result(col, 'label')
+        return pad(label, col.width || label.length)
+      }))
+    }
+
+    function getNthLineOfCell (n, row, col) {
+      // TODO memoize this
+      let lines = col.get(row).split(/[\r\n]+/)
+      return pad(lines[n] || '', col.width)
+    }
+
+    for (let row of data) {
+      for (let i = 0; i < row.height; i++) {
+        let cells = columns.map(partial(getNthLineOfCell, i, row))
+        options.printRow(cells)
+      }
+      options.after(row, options)
+    }
+  }
+
+  defaults(options, _defaults)
+  render()
+}
+
+module.exports = table

package/lib/util.js

@@ -0,0 +1,38 @@
+'use strict'
+
+/**
+ * promiseOrCallback will convert a function that returns a promise
+ * into one that will either make a node-style callback or return a promise
+ * based on whether or not a callback is passed in.
+ *
+ * @example
+ * prompt('input? ').then(function (input) {
+ *   // deal with input
+ * })
+ * var prompt2 = promiseOrCallback(prompt)
+ * prompt('input? ', function (err, input) {
+ *   // deal with input
+ * })
+ *
+ * @param {Function} fn a promise returning function to wrap
+ * @returns {Function} a function that behaves like before unless called with a callback
+ */
+function promiseOrCallback (fn) {
+  return function () {
+    if (typeof arguments[arguments.length - 1] === 'function') {
+      let args = Array.prototype.slice.call(arguments)
+      let callback = args.pop()
+      fn.apply(null, args).then(function () {
+        let args = Array.prototype.slice.call(arguments)
+        args.unshift(null)
+        callback.apply(null, args)
+      }).catch(function (err) {
+        callback(err)
+      })
+    } else {
+      return fn.apply(null, arguments)
+    }
+  }
+}
+
+exports.promiseOrCallback = promiseOrCallback

package/lib/vars.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const url = require('url')
+
+class Vars {
+  constructor (env) {
+    this.env = env
+  }
+
+  get host () { return this.env.HEROKU_HOST || 'heroku.com' }
+  get apiUrl () { return this.host.startsWith('http') ? this.host : `https://api.${this.host}` }
+  get apiHost () {
+    if (this.host.startsWith('http')) {
+      const u = url.parse(this.host)
+      if (u.host) return u.host
+    }
+    return `api.${this.host}`
+  }
+  get httpGitHost () {
+    if (this.env.HEROKU_GIT_HOST) return this.env.HEROKU_GIT_HOST
+    if (this.host.startsWith('http')) {
+      const u = url.parse(this.host)
+      if (u.host) return u.host
+    }
+    return `git.${this.host}`
+  }
+}
+
+module.exports = new Vars(process.env)

package/lib/yubikey.js

@@ -0,0 +1,14 @@
+'use strict'
+
+function toggle (onoff) {
+  const cp = require('child_process')
+  if (exports.platform !== 'darwin') return
+  try {
+    cp.execSync(`osascript -e 'if application "yubiswitch" is running then tell application "yubiswitch" to ${onoff}'`, { stdio: 'inherit' })
+  } catch (err) {}
+}
+
+exports.enable = () => toggle('KeyOn')
+exports.disable = () => toggle('KeyOff')
+
+exports.platform = process.platform

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@heroku/heroku-cli-util",
+  "description": "Set of helpful CLI utilities",
+  "version": "8.0.12",
+  "author": "Heroku",
+  "bugs": {
+    "url": "https://github.com/heroku/heroku-cli-util/issues"
+  },
+  "dependencies": {
+    "@heroku-cli/color": "^1.1.3",
+    "ansi-escapes": "^3.1.0",
+    "ansi-styles": "^3.2.1",
+    "cardinal": "^2.0.1",
+    "chalk": "^2.4.1",
+    "got": "^11.8.6",
+    "heroku-client": "^3.1.0",
+    "lodash": "^4.17.10",
+    "netrc-parser": "^3.1.4",
+    "opn": "^3.0.3",
+    "strip-ansi": "^4.0.0",
+    "supports-color": "^5.4.0",
+    "tslib": "^1.9.0",
+    "tunnel-agent": "^0.6.0"
+  },
+  "devDependencies": {
+    "chai": "^4.1.2",
+    "co": "^4.6.0",
+    "hook-std": "^0.4.0",
+    "mocha": "^10.2.0",
+    "mocha-junit-reporter": "^1.17.0",
+    "nock": "^11.9.1",
+    "nyc": "^15.1.0",
+    "proxyquire": "^1.7.11",
+    "sinon": "^1.17.7",
+    "standard": "^12.0.1",
+    "tmp": "^0.0.33",
+    "unexpected": "^11.15.1"
+  },
+  "engines": {
+    "node": ">= 14"
+  },
+  "files": [
+    "lib",
+    "index.js"
+  ],
+  "homepage": "https://github.com/heroku/heroku-cli-util",
+  "license": "ISC",
+  "main": "index.js",
+  "mocha": {
+    "require": [
+      "./test/init"
+    ]
+  },
+  "nyc": {
+    "exclude": [
+      "lib/linewrap.js"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/heroku/heroku-cli-util.git"
+  },
+  "scripts": {
+    "test": "mocha",
+    "posttest": "standard"
+  },
+  "standard": {
+    "env": "mocha",
+    "ignore": [
+      "lib/linewrap.js"
+    ]
+  },
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  },
+  "keywords": [
+    "heroku-cli-util"
+  ]
+}