jfrog-cli-v2-jf 2.6.0

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/help.js

@@ -0,0 +1,247 @@
+
+module.exports = help
+
+help.completion = function (opts, cb) {
+  if (opts.conf.argv.remain.length > 2) return cb(null, [])
+  getSections(cb)
+}
+
+var path = require('path')
+var spawn = require('./utils/spawn')
+var npm = require('./npm.js')
+var log = require('npmlog')
+var opener = require('opener')
+var glob = require('glob')
+var didYouMean = require('./utils/did-you-mean')
+var cmdList = require('./config/cmd-list').cmdList
+var shorthands = require('./config/cmd-list').shorthands
+var commands = cmdList.concat(Object.keys(shorthands))
+var output = require('./utils/output.js')
+
+function help (args, cb) {
+  var argv = npm.config.get('argv').cooked
+
+  var argnum = 0
+  if (args.length === 2 && ~~args[0]) {
+    argnum = ~~args.shift()
+  }
+
+  // npm help foo bar baz: search topics
+  if (args.length > 1 && args[0]) {
+    return npm.commands['help-search'](args, argnum, cb)
+  }
+
+  var section = npm.deref(args[0]) || args[0]
+
+  // npm help <noargs>:  show basic usage
+  if (!section) {
+    var valid = argv[0] === 'help' ? 0 : 1
+    return npmUsage(valid, cb)
+  }
+
+  // npm <command> -h: show command usage
+  if (npm.config.get('usage') &&
+      npm.commands[section] &&
+      npm.commands[section].usage) {
+    npm.config.set('loglevel', 'silent')
+    log.level = 'silent'
+    output(npm.commands[section].usage)
+    return cb()
+  }
+
+  // npm apihelp <section>: Prefer section 3 over section 1
+  var apihelp = argv.length && argv[0].indexOf('api') !== -1
+  var pref = apihelp ? [3, 1, 5, 7] : [1, 3, 5, 7]
+  if (argnum) {
+    pref = [ argnum ].concat(pref.filter(function (n) {
+      return n !== argnum
+    }))
+  }
+
+  // npm help <section>: Try to find the path
+  var manroot = path.resolve(__dirname, '..', 'man')
+
+  // legacy
+  if (section === 'global') section = 'folders'
+  else if (section === 'json') section = 'package.json'
+
+  // find either /section.n or /npm-section.n
+  // The glob is used in the glob.  The regexp is used much
+  // further down.  Globs and regexps are different
+  var compextglob = '.+(gz|bz2|lzma|[FYzZ]|xz)'
+  var compextre = '\\.(gz|bz2|lzma|[FYzZ]|xz)$'
+  var f = '+(npm-' + section + '|' + section + ').[0-9]?(' + compextglob + ')'
+  return glob(manroot + '/*/' + f, function (er, mans) {
+    if (er) return cb(er)
+
+    if (!mans.length) return npm.commands['help-search'](args, cb)
+
+    mans = mans.map(function (man) {
+      var ext = path.extname(man)
+      if (man.match(new RegExp(compextre))) man = path.basename(man, ext)
+
+      return man
+    })
+
+    viewMan(pickMan(mans, pref), cb)
+  })
+}
+
+function pickMan (mans, pref_) {
+  var nre = /([0-9]+)$/
+  var pref = {}
+  pref_.forEach(function (sect, i) {
+    pref[sect] = i
+  })
+  mans = mans.sort(function (a, b) {
+    var an = a.match(nre)[1]
+    var bn = b.match(nre)[1]
+    return an === bn ? (a > b ? -1 : 1)
+         : pref[an] < pref[bn] ? -1
+         : 1
+  })
+  return mans[0]
+}
+
+function viewMan (man, cb) {
+  var nre = /([0-9]+)$/
+  var num = man.match(nre)[1]
+  var section = path.basename(man, '.' + num)
+
+  // at this point, we know that the specified man page exists
+  var manpath = path.join(__dirname, '..', 'man')
+  var env = {}
+  Object.keys(process.env).forEach(function (i) {
+    env[i] = process.env[i]
+  })
+  env.MANPATH = manpath
+  var viewer = npm.config.get('viewer')
+
+  var conf
+  switch (viewer) {
+    case 'woman':
+      var a = ['-e', '(woman-find-file \'' + man + '\')']
+      conf = { env: env, stdio: 'inherit' }
+      var woman = spawn('emacsclient', a, conf)
+      woman.on('close', cb)
+      break
+
+    case 'browser':
+      opener(htmlMan(man), { command: npm.config.get('browser') }, cb)
+      break
+
+    default:
+      conf = { env: env, stdio: 'inherit' }
+      var manProcess = spawn('man', [num, section], conf)
+      manProcess.on('close', cb)
+      break
+  }
+}
+
+function htmlMan (man) {
+  var sect = +man.match(/([0-9]+)$/)[1]
+  var f = path.basename(man).replace(/([0-9]+)$/, 'html')
+  switch (sect) {
+    case 1:
+      sect = 'cli'
+      break
+    case 3:
+      sect = 'api'
+      break
+    case 5:
+      sect = 'files'
+      break
+    case 7:
+      sect = 'misc'
+      break
+    default:
+      throw new Error('invalid man section: ' + sect)
+  }
+  return path.resolve(__dirname, '..', 'html', 'doc', sect, f)
+}
+
+function npmUsage (valid, cb) {
+  npm.config.set('loglevel', 'silent')
+  log.level = 'silent'
+  output([
+    '\nUsage: npm <command>',
+    '',
+    'where <command> is one of:',
+    npm.config.get('long') ? usages()
+        : '    ' + wrap(commands),
+    '',
+    'npm <command> -h     quick help on <command>',
+    'npm -l           display full usage info',
+    'npm help <term>  search for help on <term>',
+    'npm help npm     involved overview',
+    '',
+    'Specify configs in the ini-formatted file:',
+    '    ' + npm.config.get('userconfig'),
+    'or on the command line via: npm <command> --key value',
+    'Config info can be viewed via: npm help config',
+    '',
+    'npm@' + npm.version + ' ' + path.dirname(__dirname)
+  ].join('\n'))
+
+  if (npm.argv.length > 1) {
+    didYouMean(npm.argv[1], commands)
+  }
+
+  cb(valid)
+}
+
+function usages () {
+  // return a string of <command>: <usage>
+  var maxLen = 0
+  return Object.keys(npm.commands).filter(function (c) {
+    return c === npm.deref(c)
+  }).reduce(function (set, c) {
+    set.push([c, npm.commands[c].usage || ''])
+    maxLen = Math.max(maxLen, c.length)
+    return set
+  }, []).map(function (item) {
+    var c = item[0]
+    var usage = item[1]
+    return '\n    ' +
+      c + (new Array(maxLen - c.length + 2).join(' ')) +
+      (usage.split('\n').join('\n' + (new Array(maxLen + 6).join(' '))))
+  }).join('\n')
+}
+
+function wrap (arr) {
+  var out = ['']
+  var l = 0
+  var line
+
+  line = process.stdout.columns
+  if (!line) {
+    line = 60
+  } else {
+    line = Math.min(60, Math.max(line - 16, 24))
+  }
+
+  arr.sort(function (a, b) { return a < b ? -1 : 1 })
+    .forEach(function (c) {
+      if (out[l].length + c.length + 2 < line) {
+        out[l] += ', ' + c
+      } else {
+        out[l++] += ','
+        out[l] = c
+      }
+    })
+  return out.join('\n    ').substr(2)
+}
+
+function getSections (cb) {
+  var g = path.resolve(__dirname, '../man/man[0-9]/*.[0-9]')
+  glob(g, function (er, files) {
+    if (er) return cb(er)
+
+    cb(null, Object.keys(files.reduce(function (acc, file) {
+      file = path.basename(file).replace(/\.[0-9]+$/, '')
+      file = file.replace(/^npm-/, '')
+      acc[file] = true
+      return acc
+    }, { help: true })))
+  })
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/init.js

@@ -0,0 +1,41 @@
+// initialize a package.json file
+
+module.exports = init
+
+var log = require('npmlog')
+var npm = require('./npm.js')
+var initJson = require('init-package-json')
+var output = require('./utils/output.js')
+var noProgressTillDone = require('./utils/no-progress-while-running').tillDone
+
+init.usage = 'npm init [--force|-f|--yes|-y]'
+
+function init (args, cb) {
+  var dir = process.cwd()
+  log.pause()
+  var initFile = npm.config.get('init-module')
+  if (!initJson.yes(npm.config)) {
+    output([
+      'This utility will walk you through creating a package.json file.',
+      'It only covers the most common items, and tries to guess sensible defaults.',
+      '',
+      'See `npm help json` for definitive documentation on these fields',
+      'and exactly what they do.',
+      '',
+      'Use `npm install <pkg>` afterwards to install a package and',
+      'save it as a dependency in the package.json file.',
+      '',
+      'Press ^C at any time to quit.'
+    ].join('\n'))
+  }
+  initJson(dir, initFile, npm.config, noProgressTillDone(function (er, data) {
+    log.resume()
+    log.silly('package data', data)
+    if (er && er.message === 'canceled') {
+      log.warn('init', 'canceled')
+      return cb(null, data)
+    }
+    log.info('init', 'written successfully')
+    cb(er, data)
+  }))
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/access-error.js

@@ -0,0 +1,8 @@
+'use strict'
+module.exports = function (dir, er) {
+  if (!er) return
+  var accessEr = new Error("EACCES, access '" + dir + "'", -13)
+  accessEr.code = 'EACCES'
+  accessEr.path = dir
+  return accessEr
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/action/build.js

@@ -0,0 +1,13 @@
+'use strict'
+var chain = require('slide').chain
+var build = require('../../build.js')
+var npm = require('../../npm.js')
+var packageId = require('../../utils/package-id.js')
+
+module.exports = function (staging, pkg, log, next) {
+  log.silly('build', packageId(pkg))
+  chain([
+    [build.linkStuff, pkg.package, pkg.path, npm.config.get('global')],
+    [build.writeBuiltinConf, pkg.package, pkg.path]
+  ], next)
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/action/extract-worker.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const BB = require('bluebird')
+
+const extract = require('pacote/extract')
+const npmlog = require('npmlog')
+
+module.exports = (args, cb) => {
+  const parsed = typeof args === 'string' ? JSON.parse(args) : args
+  const spec = parsed[0]
+  const extractTo = parsed[1]
+  const opts = parsed[2]
+  if (!opts.log && opts.loglevel) {
+    opts.log = npmlog
+    opts.log.level = opts.loglevel
+  }
+  BB.resolve(extract(spec, extractTo, opts)).nodeify(cb)
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/action/extract.js

@@ -0,0 +1,160 @@
+'use strict'
+
+const BB = require('bluebird')
+
+const stat = BB.promisify(require('graceful-fs').stat)
+const gentlyRm = BB.promisify(require('../../utils/gently-rm.js'))
+const log = require('npmlog')
+const mkdirp = BB.promisify(require('mkdirp'))
+const moduleName = require('../../utils/module-name.js')
+const moduleStagingPath = require('../module-staging-path.js')
+const move = require('../../utils/move.js')
+const npa = require('npm-package-arg')
+const npm = require('../../npm.js')
+const packageId = require('../../utils/package-id.js')
+let pacoteOpts
+const path = require('path')
+const localWorker = require('./extract-worker.js')
+const workerFarm = require('worker-farm')
+const isRegistry = require('../../utils/is-registry.js')
+
+const WORKER_PATH = require.resolve('./extract-worker.js')
+let workers
+
+// NOTE: temporarily disabled on non-OSX due to ongoing issues:
+//
+// * Seems to make Windows antivirus issues much more common
+// * Messes with Docker (I think)
+//
+// There are other issues that should be fixed that affect OSX too:
+//
+// * Logging is messed up right now because pacote does its own thing
+// * Global deduplication in pacote breaks due to multiple procs
+//
+// As these get fixed, we can start experimenting with re-enabling it
+// at least on some platforms.
+const ENABLE_WORKERS = process.platform === 'darwin'
+
+extract.init = () => {
+  if (ENABLE_WORKERS) {
+    workers = workerFarm({
+      maxConcurrentCallsPerWorker: npm.limit.fetch,
+      maxRetries: 1
+    }, WORKER_PATH)
+  }
+  return BB.resolve()
+}
+extract.teardown = () => {
+  if (ENABLE_WORKERS) {
+    workerFarm.end(workers)
+    workers = null
+  }
+  return BB.resolve()
+}
+module.exports = extract
+function extract (staging, pkg, log) {
+  log.silly('extract', packageId(pkg))
+  const extractTo = moduleStagingPath(staging, pkg)
+  if (!pacoteOpts) {
+    pacoteOpts = require('../../config/pacote')
+  }
+  const opts = pacoteOpts({
+    integrity: pkg.package._integrity
+  })
+  const args = [
+    pkg.package._resolved
+    ? npa.resolve(pkg.package.name, pkg.package._resolved)
+    : pkg.package._requested,
+    extractTo,
+    opts
+  ]
+  return BB.fromNode((cb) => {
+    let launcher = localWorker
+    let msg = args
+    const spec = typeof args[0] === 'string' ? npa(args[0]) : args[0]
+    args[0] = spec.raw
+    if (ENABLE_WORKERS && (isRegistry(spec) || spec.type === 'remote')) {
+      // We can't serialize these options
+      opts.loglevel = opts.log.level
+      opts.log = null
+      opts.dirPacker = null
+      // workers will run things in parallel!
+      launcher = workers
+      try {
+        msg = JSON.stringify(msg)
+      } catch (e) {
+        return cb(e)
+      }
+    }
+    launcher(msg, cb)
+  }).then(() => {
+    if (pkg.package.bundleDependencies || anyBundled(pkg)) {
+      return readBundled(pkg, staging, extractTo)
+    }
+  }).then(() => {
+    return gentlyRm(path.join(extractTo, 'node_modules'))
+  })
+}
+
+function anyBundled (top, pkg) {
+  if (!pkg) pkg = top
+  return pkg.children.some((child) => child.fromBundle === top || anyBundled(top, child))
+}
+
+function readBundled (pkg, staging, extractTo) {
+  return BB.map(pkg.children, (child) => {
+    if (!child.fromBundle) return
+    if (child.error) {
+      throw child.error
+    } else {
+      return stageBundledModule(pkg, child, staging, extractTo)
+    }
+  }, {concurrency: 10})
+}
+
+function getTree (pkg) {
+  while (pkg.parent) pkg = pkg.parent
+  return pkg
+}
+
+function warn (pkg, code, msg) {
+  const tree = getTree(pkg)
+  const err = new Error(msg)
+  err.code = code
+  tree.warnings.push(err)
+}
+
+function stageBundledModule (bundler, child, staging, parentPath) {
+  const stageFrom = path.join(parentPath, 'node_modules', child.package.name)
+  const stageTo = moduleStagingPath(staging, child)
+
+  return BB.map(child.children, (child) => {
+    if (child.error) {
+      throw child.error
+    } else {
+      return stageBundledModule(bundler, child, staging, stageFrom)
+    }
+  }).then(() => {
+    return finishModule(bundler, child, stageTo, stageFrom)
+  })
+}
+
+function finishModule (bundler, child, stageTo, stageFrom) {
+  // If we were the one's who bundled this module…
+  if (child.fromBundle === bundler) {
+    return mkdirp(path.dirname(stageTo)).then(() => {
+      return move(stageFrom, stageTo)
+    })
+  } else {
+    return stat(stageFrom).then(() => {
+      const bundlerId = packageId(bundler)
+      if (!getTree(bundler).warnings.some((w) => {
+        return w.code === 'EBUNDLEOVERRIDE'
+      })) {
+        warn(bundler, 'EBUNDLEOVERRIDE', `${bundlerId} had bundled packages that do not match the required version(s). They have been replaced with non-bundled versions.`)
+      }
+      log.verbose('bundle', `EBUNDLEOVERRIDE: Replacing ${bundlerId}'s bundled version of ${moduleName(child)} with ${packageId(child)}.`)
+      return gentlyRm(stageFrom)
+    }, () => {})
+  }
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/action/fetch.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const BB = require('bluebird')
+
+const finished = BB.promisify(require('mississippi').finished)
+const packageId = require('../../utils/package-id.js')
+const pacote = require('pacote')
+const pacoteOpts = require('../../config/pacote')
+
+module.exports = fetch
+function fetch (staging, pkg, log, next) {
+  log.silly('fetch', packageId(pkg))
+  const opts = pacoteOpts({integrity: pkg.package._integrity})
+  return finished(pacote.tarball.stream(pkg.package._requested, opts))
+  .then(() => next(), next)
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/action/finalize.js

@@ -0,0 +1,106 @@
+'use strict'
+const path = require('path')
+const fs = require('graceful-fs')
+const Bluebird = require('bluebird')
+const rimraf = Bluebird.promisify(require('rimraf'))
+const mkdirp = Bluebird.promisify(require('mkdirp'))
+const lstat = Bluebird.promisify(fs.lstat)
+const readdir = Bluebird.promisify(fs.readdir)
+const symlink = Bluebird.promisify(fs.symlink)
+const gentlyRm = Bluebird.promisify(require('../../utils/gently-rm'))
+const moduleStagingPath = require('../module-staging-path.js')
+const move = require('move-concurrently')
+const moveOpts = {fs: fs, Promise: Bluebird, maxConcurrency: 4}
+const getRequested = require('../get-requested.js')
+const log = require('npmlog')
+const packageId = require('../../utils/package-id.js')
+
+module.exports = function (staging, pkg, log) {
+  log.silly('finalize', pkg.realpath)
+
+  const extractedTo = moduleStagingPath(staging, pkg)
+
+  const delpath = path.join(path.dirname(pkg.realpath), '.' + path.basename(pkg.realpath) + '.DELETE')
+  let movedDestAway = false
+
+  const requested = pkg.package._requested || getRequested(pkg)
+  if (requested.type === 'directory') {
+    const relative = path.relative(path.dirname(pkg.path), pkg.realpath)
+    return makeParentPath(pkg.path)
+      .then(() => symlink(relative, pkg.path, 'junction'))
+      .catch((ex) => {
+        return rimraf(pkg.path).then(() => symlink(relative, pkg.path, 'junction'))
+      })
+  } else {
+    return makeParentPath(pkg.realpath)
+      .then(moveStagingToDestination)
+      .then(restoreOldNodeModules)
+      .catch((err) => {
+        if (movedDestAway) {
+          return rimraf(pkg.realpath).then(moveOldDestinationBack).then(() => {
+            throw err
+          })
+        } else {
+          throw err
+        }
+      })
+      .then(() => rimraf(delpath))
+  }
+
+  function makeParentPath (dir) {
+    return mkdirp(path.dirname(dir))
+  }
+
+  function moveStagingToDestination () {
+    return destinationIsClear()
+      .then(actuallyMoveStaging)
+      .catch(() => moveOldDestinationAway().then(actuallyMoveStaging))
+  }
+
+  function destinationIsClear () {
+    return lstat(pkg.realpath).then(() => {
+      throw new Error('destination exists')
+    }, () => {})
+  }
+
+  function actuallyMoveStaging () {
+    return move(extractedTo, pkg.realpath, moveOpts)
+  }
+
+  function moveOldDestinationAway () {
+    return rimraf(delpath).then(() => {
+      return move(pkg.realpath, delpath, moveOpts)
+    }).then(() => { movedDestAway = true })
+  }
+
+  function moveOldDestinationBack () {
+    return move(delpath, pkg.realpath, moveOpts).then(() => { movedDestAway = false })
+  }
+
+  function restoreOldNodeModules () {
+    if (!movedDestAway) return
+    return readdir(path.join(delpath, 'node_modules')).catch(() => []).then((modules) => {
+      if (!modules.length) return
+      return mkdirp(path.join(pkg.realpath, 'node_modules')).then(() => Bluebird.map(modules, (file) => {
+        const from = path.join(delpath, 'node_modules', file)
+        const to = path.join(pkg.realpath, 'node_modules', file)
+        return move(from, to, moveOpts)
+      }))
+    })
+  }
+}
+
+module.exports.rollback = function (top, staging, pkg) {
+  return Bluebird.try(() => {
+    const requested = pkg.package._requested || getRequested(pkg)
+    if (requested && requested.type === 'directory') return Promise.resolve()
+    // strictly speaking rolling back a finalize should ONLY remove module that
+    // was being finalized, not any of the things under it. But currently
+    // those modules are guaranteed to be useless so we may as well remove them too.
+    // When/if we separate `commit` step and can rollback to previous versions
+    // of upgraded modules then we'll need to revisit this…
+    return gentlyRm(pkg.path, false, top).catch((err) => {
+      log.warn('rollback', `Rolling back ${packageId(pkg)} failed (this is probably harmless): ${err.message ? err.message : err}`)
+    })
+  })
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/action/global-install.js

@@ -0,0 +1,17 @@
+'use strict'
+var path = require('path')
+var npm = require('../../npm.js')
+var Installer = require('../../install.js').Installer
+var packageId = require('../../utils/package-id.js')
+
+module.exports = function (staging, pkg, log, next) {
+  log.silly('global-install', packageId(pkg))
+  var globalRoot = path.resolve(npm.globalDir, '..')
+  npm.config.set('global', true)
+  var install = new Installer(globalRoot, false, [pkg.package.name + '@' + pkg.package._requested.fetchSpec])
+  install.link = false
+  install.run(function () {
+    npm.config.set('global', false)
+    next.apply(null, arguments)
+  })
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/action/global-link.js

@@ -0,0 +1,8 @@
+'use strict'
+var npm = require('../../npm.js')
+var packageId = require('../../utils/package-id.js')
+
+module.exports = function (staging, pkg, log, next) {
+  log.silly('global-link', packageId(pkg))
+  npm.link(pkg.package.name, next)
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/action/install.js

@@ -0,0 +1,8 @@
+'use strict'
+var lifecycle = require('../../utils/lifecycle.js')
+var packageId = require('../../utils/package-id.js')
+
+module.exports = function (staging, pkg, log, next) {
+  log.silly('install', packageId(pkg))
+  lifecycle(pkg.package, 'install', pkg.path, next)
+}