@heroku/heroku-cli-util 8.0.14 → 9.0.0-beta.0

package/lib/date.js

@@ -1,18 +0,0 @@
-'use strict'
-
-/**
- * formatDate will format a date in a standard Heroku format
- *
- * @example
- * let cli = require('heroku-cli-util')
- * var d = new Date()
- * cli.formatDate(d); // '2015-05-14T18:03:10.034Z'
- *
- * @param {Date} date the date to format
- * @return {String} string representing the date
- */
-function formatDate (date) {
-  return date.toISOString()
-}
-
-exports.formatDate = formatDate

package/lib/errors.js

@@ -1,122 +0,0 @@
-'use strict'
-
-const stripAnsi = require('strip-ansi')
-let cli = require('..')
-let console = require('./console')
-let linewrap = require('./linewrap')
-let path = require('path')
-let os = require('os')
-
-function errtermwidth () {
-  if (global.columns) return global.columns
-  if (!process.stderr.isTTY || !process.stderr.getWindowSize) return 80
-  let width = process.stderr.getWindowSize()[0]
-  return width < 30 ? 30 : width
-}
-
-function wrap (msg) {
-  return linewrap(6,
-    errtermwidth(), {
-      skipScheme: 'ansi-color',
-      skip: /^\$ .*$/
-    })(msg || '')
-}
-
-function bangify (msg, c) {
-  let lines = msg.split('\n')
-  for (let i = 0; i < lines.length; i++) {
-    let line = lines[i]
-    lines[i] = ' ' + c + line.substr(2, line.length)
-  }
-  return lines.join('\n')
-}
-
-function getErrorMessage (err) {
-  if (err.body) {
-    // API error
-    if (err.body.message) {
-      return err.body.message
-    } else if (err.body.error) {
-      return err.body.error
-    }
-  }
-  // Unhandled error
-  if (err.message && err.code) {
-    return `${err.code}: ${err.message}`
-  } else if (err.message) {
-    return err.message
-  }
-  return err
-}
-
-let arrow = process.platform === 'win32' ? '!' : '▸'
-
-function error (err) {
-  console.error(bangify(wrap(getErrorMessage(err)), cli.color.red(arrow)))
-}
-
-function warn (msg) {
-  console.error(renderWarning(msg))
-}
-
-function renderWarning (msg) {
-  return bangify(wrap(msg), cli.color.yellow(arrow))
-}
-
-function logtimestamp () {
-  return new Date().toISOString()
-    .replace(/T/, ' ')
-    .replace(/-/g, '/')
-    .replace(/\..+/, '')
-}
-
-function cacheHome () {
-  let base
-  if (process.env.XDG_CACHE_HOME) base = process.env.XDG_CACHE_HOME
-  if (!base) {
-    if (process.platform === 'darwin') {
-      base = path.join(os.homedir(), 'Library', 'Caches')
-    } else if (process.platform === 'win32' && process.env.LOCALAPPDATA) {
-      base = process.env.LOCALAPPDATA
-    } else {
-      base = path.join(os.homedir(), '.cache')
-    }
-  }
-  return path.join(base, 'heroku')
-}
-
-function log (msg) {
-  let fs = require('fs')
-  let logPath = path.join(cacheHome(), 'error.log')
-  fs.appendFileSync(logPath, logtimestamp() + ' ' + stripAnsi(msg) + '\n')
-}
-
-function errorHandler (options) {
-  options = options || {}
-  function exit () {
-    if (options.exit !== false) {
-      process.exit(1)
-    }
-  }
-  return function handleErr (err) {
-    if (cli.raiseErrors) throw err
-    try {
-      if (err !== '') error(err)
-      if (err.stack) {
-        log(err.stack)
-        if (options.debug) console.error(err.stack)
-      }
-      if (err.body) log(JSON.stringify(err.body))
-      exit()
-    } catch (err) {
-      console.error(err.stack)
-      process.exit(-1)
-    }
-  }
-}
-
-module.exports.error = error
-module.exports.warn = warn
-module.exports.errorHandler = errorHandler
-module.exports.renderWarning = renderWarning
-module.exports.errtermwidth = errtermwidth

package/lib/exit.js

@@ -1,42 +0,0 @@
-'use strict'
-
-var util = require('util')
-var cli = require('./errors')
-
-function ErrorExit (code, message) {
-  Error.call(this)
-  Error.captureStackTrace(this, this.constructor)
-  this.name = this.constructor.name
-
-  this.code = code
-  this.message = message
-}
-
-util.inherits(ErrorExit, Error)
-
-var mocking
-
-function exit (code, message) {
-  if (message) {
-    cli.error(message)
-  }
-  if (mocking) {
-    throw new ErrorExit(code, message)
-  } else {
-    process.exit(code)
-  }
-}
-
-exit.mock = function (mock) {
-  if (mock === false) {
-    mocking = false
-  } else {
-    mocking = true
-  }
-}
-
-exit.ErrorExit = ErrorExit
-
-module.exports = {
-  exit
-}

package/lib/got.js

@@ -1,153 +0,0 @@
-'use strict'
-
-let hush = require('./console').hush
-
-function findProxy (urlParsed) {
-  let httpProxy = process.env.HTTP_PROXY || process.env.http_proxy
-  let httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy
-
-  if (urlParsed.protocol === 'https:') {
-    return httpsProxy || httpProxy
-  } else {
-    return httpProxy
-  }
-}
-
-function findTunnel (urlParsed) {
-  let tunnel = require('tunnel-agent')
-
-  if (urlParsed.protocol === 'https:') {
-    return tunnel.httpsOverHttp
-  } else {
-    return tunnel.httpOverHttp
-  }
-}
-
-function agent (urlParsed, proxyParsed, certs) {
-  let tunnelMethod = findTunnel(urlParsed)
-  let opts = {
-    proxy: {
-      host: proxyParsed.hostname,
-      port: proxyParsed.port || '8080'
-    }
-  }
-
-  if (proxyParsed.auth) {
-    opts.proxy.proxyAuth = proxyParsed.auth
-  }
-
-  if (certs.length > 0) {
-    opts.ca = certs
-  }
-
-  let tunnelAgent = tunnelMethod(opts)
-  if (urlParsed.protocol === 'https:') {
-    tunnelAgent.defaultPort = 443
-  }
-  return tunnelAgent
-}
-
-function sslCertFile () {
-  return process.env.SSL_CERT_FILE ? [process.env.SSL_CERT_FILE] : []
-}
-
-function sslCertDir () {
-  let certDir = process.env.SSL_CERT_DIR
-  if (certDir) {
-    const fs = require('fs')
-    const path = require('path')
-    return fs.readdirSync(certDir).map(f => path.join(certDir, f))
-  } else {
-    return []
-  }
-}
-
-function getCerts () {
-  let filenames = sslCertFile().concat(sslCertDir())
-
-  if (filenames.length > 0) {
-    hush('Adding the following trusted certificate authorities')
-  }
-
-  return filenames.map(function (filename) {
-    const fs = require('fs')
-    hush('  ' + filename)
-    return fs.readFileSync(filename)
-  })
-}
-
-function addToOpts (url, opts) {
-  const urlLib = require('url')
-
-  let urlParsed = urlLib.parse(url)
-  let proxy = findProxy(urlParsed)
-
-  let certs = getCerts()
-
-  if (proxy) {
-    let proxyParsed = urlLib.parse(proxy)
-    opts = Object.assign({}, opts, { agent: agent(urlParsed, proxyParsed, certs) })
-  }
-
-  if (certs.length > 0) {
-    opts = Object.assign({}, opts, { ca: certs })
-  }
-
-  return opts
-}
-
-let loadErrors
-
-function got (url, opts) {
-  const gotDelegate = require('got')
-  loadErrors()
-  return gotDelegate(url, addToOpts(url, opts))
-}
-
-got.stream = function (url, opts) {
-  const gotDelegate = require('got')
-  loadErrors()
-  return gotDelegate.stream(url, addToOpts(url, opts))
-}
-
-const helpers = [
-  'get',
-  'post',
-  'put',
-  'patch',
-  'head',
-  'delete'
-]
-
-helpers.forEach(el => {
-  got[el] = (url, opts) => got(url, Object.assign({}, opts, { method: el }))
-})
-
-helpers.forEach(el => {
-  got.stream[el] = function (url, opts) {
-    return got.stream(url, Object.assign({}, opts, { method: el }))
-  }
-})
-
-loadErrors = () => {
-  const gotDelegate = require('got')
-
-  const errors = [
-    'CacheError',
-    'CancelError',
-    'UnsupportedProtocolError',
-    'HTTPError',
-    'MaxRedirectsError',
-    'ParseError',
-    'ReadError',
-    'RequestError',
-    'TimeoutError',
-    'UploadError'
-  ]
-
-  errors.forEach(el => {
-    got[el] = gotDelegate[el]
-  })
-}
-
-module.exports = got