jfrog-cli-v2-jf 2.6.0

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

@@ -0,0 +1,200 @@
+'use strict'
+
+const BB = require('bluebird')
+
+const cacache = require('cacache')
+const createReadStream = require('graceful-fs').createReadStream
+const getPublishConfig = require('./utils/get-publish-config.js')
+const lifecycle = BB.promisify(require('./utils/lifecycle.js'))
+const log = require('npmlog')
+const mapToRegistry = require('./utils/map-to-registry.js')
+const npa = require('npm-package-arg')
+const npm = require('./npm.js')
+const output = require('./utils/output.js')
+const pack = require('./pack')
+const pacote = require('pacote')
+const pacoteOpts = require('./config/pacote')
+const path = require('path')
+const readJson = BB.promisify(require('read-package-json'))
+const semver = require('semver')
+const statAsync = BB.promisify(require('graceful-fs').stat)
+const readUserInfo = require('./utils/read-user-info.js')
+
+publish.usage = 'npm publish [<tarball>|<folder>] [--tag <tag>] [--access <public|restricted>]' +
+                "\n\nPublishes '.' if no argument supplied" +
+                '\n\nSets tag `latest` if no --tag specified'
+
+publish.completion = function (opts, cb) {
+  // publish can complete to a folder with a package.json
+  // or a tarball, or a tarball url.
+  // for now, not yet implemented.
+  return cb()
+}
+
+module.exports = publish
+function publish (args, isRetry, cb) {
+  if (typeof cb !== 'function') {
+    cb = isRetry
+    isRetry = false
+  }
+  if (args.length === 0) args = ['.']
+  if (args.length !== 1) return cb(publish.usage)
+
+  log.verbose('publish', args)
+
+  const t = npm.config.get('tag').trim()
+  if (semver.validRange(t)) {
+    return cb(new Error('Tag name must not be a valid SemVer range: ' + t))
+  }
+
+  publish_(args[0]).then((pkg) => {
+    output(`+ ${pkg._id}`)
+    cb()
+  }, cb)
+}
+
+function publish_ (arg) {
+  return statAsync(arg).then((stat) => {
+    if (stat.isDirectory()) {
+      return stat
+    } else {
+      const err = new Error('not a directory')
+      err.code = 'ENOTDIR'
+      throw err
+    }
+  }).then(() => {
+    return publishFromDirectory(arg)
+  }, (err) => {
+    if (err.code !== 'ENOENT' && err.code !== 'ENOTDIR') {
+      throw err
+    } else {
+      return publishFromPackage(arg)
+    }
+  })
+}
+
+function publishFromDirectory (arg) {
+  // All this readJson is because any of the given scripts might modify the
+  // package.json in question, so we need to refresh after every step.
+  return pack.prepareDirectory(arg).then(() => {
+    return readJson(path.join(arg, 'package.json'))
+  }).then((pkg) => {
+    return lifecycle(pkg, 'prepublishOnly', arg)
+  }).then(() => {
+    return readJson(path.join(arg, 'package.json'))
+  }).then((pkg) => {
+    return cacache.tmp.withTmp(npm.tmp, {tmpPrefix: 'fromDir'}, (tmpDir) => {
+      const target = path.join(tmpDir, 'package.tgz')
+      return pack.packDirectory(pkg, arg, target).then(() => {
+        return upload(arg, pkg, false, target)
+      })
+    })
+  }).then(() => {
+    return readJson(path.join(arg, 'package.json'))
+  }).tap((pkg) => {
+    return lifecycle(pkg, 'publish', arg)
+  }).tap((pkg) => {
+    return lifecycle(pkg, 'postpublish', arg)
+  })
+}
+
+function publishFromPackage (arg) {
+  return cacache.tmp.withTmp(npm.tmp, {tmpPrefix: 'fromPackage'}, (tmp) => {
+    const extracted = path.join(tmp, 'package')
+    const target = path.join(tmp, 'package.json')
+    const opts = pacoteOpts()
+    return pacote.tarball.toFile(arg, target, opts)
+    .then(() => pacote.extract(arg, extracted, opts))
+    .then(() => readJson(path.join(extracted, 'package.json')))
+    .tap((pkg) => upload(arg, pkg, false, target))
+  })
+}
+
+function upload (arg, pkg, isRetry, cached) {
+  if (!pkg) {
+    return BB.reject(new Error('no package.json file found'))
+  }
+  if (pkg.private) {
+    return BB.reject(new Error(
+      'This package has been marked as private\n' +
+      "Remove the 'private' field from the package.json to publish it."
+    ))
+  }
+
+  const mappedConfig = getPublishConfig(
+    pkg.publishConfig,
+    npm.config,
+    npm.registry
+  )
+  const config = mappedConfig.config
+  const registry = mappedConfig.client
+
+  pkg._npmVersion = npm.version
+  pkg._nodeVersion = process.versions.node
+
+  delete pkg.modules
+
+  return BB.fromNode((cb) => {
+    mapToRegistry(pkg.name, config, (err, registryURI, auth, registryBase) => {
+      if (err) { return cb(err) }
+      cb(null, [registryURI, auth, registryBase])
+    })
+  }).spread((registryURI, auth, registryBase) => {
+    // we just want the base registry URL in this case
+    log.verbose('publish', 'registryBase', registryBase)
+    log.silly('publish', 'uploading', cached)
+
+    pkg._npmUser = {
+      name: auth.username,
+      email: auth.email
+    }
+
+    const params = {
+      metadata: pkg,
+      body: createReadStream(cached),
+      auth: auth
+    }
+
+    // registry-frontdoor cares about the access level, which is only
+    // configurable for scoped packages
+    if (config.get('access')) {
+      if (!npa(pkg.name).scope && config.get('access') === 'restricted') {
+        throw new Error("Can't restrict access to unscoped packages.")
+      }
+
+      params.access = config.get('access')
+    }
+
+    log.showProgress('publish:' + pkg._id)
+    return BB.fromNode((cb) => {
+      registry.publish(registryBase, params, cb)
+    }).catch((err) => {
+      if (
+        err.code === 'EPUBLISHCONFLICT' &&
+        npm.config.get('force') &&
+        !isRetry
+      ) {
+        log.warn('publish', 'Forced publish over ' + pkg._id)
+        return BB.fromNode((cb) => {
+          npm.commands.unpublish([pkg._id], cb)
+        }).finally(() => {
+          // ignore errors.  Use the force.  Reach out with your feelings.
+          return upload(arg, pkg, true, cached).catch(() => {
+            // but if it fails again, then report the first error.
+            throw err
+          })
+        })
+      } else {
+        throw err
+      }
+    })
+  }).catch((err) => {
+    if (err.code !== 'EOTP' && !(err.code === 'E401' && /one-time pass/.test(err.message))) throw err
+    // we prompt on stdout and read answers from stdin, so they need to be ttys.
+    if (!process.stdin.isTTY || !process.stdout.isTTY) throw err
+    return readUserInfo.otp('Enter OTP:  ').then((otp) => {
+      npm.config.set('otp', otp)
+      return upload(arg, pkg, isRetry, cached)
+    })
+  })
+}

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

@@ -0,0 +1,78 @@
+
+module.exports = rebuild
+
+var readInstalled = require('read-installed')
+var semver = require('semver')
+var log = require('npmlog')
+var npm = require('./npm.js')
+var npa = require('npm-package-arg')
+var usage = require('./utils/usage')
+var output = require('./utils/output.js')
+
+rebuild.usage = usage(
+  'rebuild',
+  'npm rebuild [[<@scope>/<name>]...]'
+)
+
+rebuild.completion = require('./utils/completion/installed-deep.js')
+
+function rebuild (args, cb) {
+  var opt = { depth: npm.config.get('depth'), dev: true }
+  readInstalled(npm.prefix, opt, function (er, data) {
+    log.info('readInstalled', typeof data)
+    if (er) return cb(er)
+    var set = filter(data, args)
+    var folders = Object.keys(set).filter(function (f) {
+      return f !== npm.prefix
+    })
+    if (!folders.length) return cb()
+    log.silly('rebuild set', folders)
+    cleanBuild(folders, set, cb)
+  })
+}
+
+function cleanBuild (folders, set, cb) {
+  npm.commands.build(folders, function (er) {
+    if (er) return cb(er)
+    output(folders.map(function (f) {
+      return set[f] + ' ' + f
+    }).join('\n'))
+    cb()
+  })
+}
+
+function filter (data, args, set, seen) {
+  if (!set) set = {}
+  if (!seen) seen = new Set()
+  if (set.hasOwnProperty(data.path)) return set
+  if (seen.has(data)) return set
+  seen.add(data)
+  var pass
+  if (!args.length) pass = true // rebuild everything
+  else if (data.name && data._id) {
+    for (var i = 0, l = args.length; i < l; i++) {
+      var arg = args[i]
+      var nv = npa(arg)
+      var n = nv.name
+      var v = nv.rawSpec
+      if (n !== data.name) continue
+      if (!semver.satisfies(data.version, v, true)) continue
+      pass = true
+      break
+    }
+  }
+  if (pass && data._id) {
+    log.verbose('rebuild', 'path, id', [data.path, data._id])
+    set[data.path] = data._id
+  }
+  // need to also dive through kids, always.
+  // since this isn't an install these won't get auto-built unless
+  // they're not dependencies.
+  Object.keys(data.dependencies || {}).forEach(function (d) {
+    // return
+    var dep = data.dependencies[d]
+    if (typeof dep === 'string') return
+    filter(dep, args, set, seen)
+  })
+  return set
+}

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

@@ -0,0 +1,51 @@
+module.exports = repo
+
+repo.usage = 'npm repo [<pkg>]'
+
+var npm = require('./npm.js')
+var opener = require('opener')
+var hostedGitInfo = require('hosted-git-info')
+var url_ = require('url')
+var fetchPackageMetadata = require('./fetch-package-metadata.js')
+
+repo.completion = function (opts, cb) {
+  // FIXME: there used to be registry completion here, but it stopped making
+  // sense somewhere around 50,000 packages on the registry
+  cb()
+}
+
+function repo (args, cb) {
+  var n = args.length ? args[0] : '.'
+  fetchPackageMetadata(n, '.', {fullMetadata: true}, function (er, d) {
+    if (er) return cb(er)
+    getUrlAndOpen(d, cb)
+  })
+}
+
+function getUrlAndOpen (d, cb) {
+  var r = d.repository
+  if (!r) return cb(new Error('no repository'))
+  // XXX remove this when npm@v1.3.10 from node 0.10 is deprecated
+  // from https://github.com/npm/npm-www/issues/418
+  var info = hostedGitInfo.fromUrl(r.url)
+  var url = info ? info.browse() : unknownHostedUrl(r.url)
+
+  if (!url) return cb(new Error('no repository: could not get url'))
+
+  opener(url, { command: npm.config.get('browser') }, cb)
+}
+
+function unknownHostedUrl (url) {
+  try {
+    var idx = url.indexOf('@')
+    if (idx !== -1) {
+      url = url.slice(idx + 1).replace(/:([^\d]+)/, '/$1')
+    }
+    url = url_.parse(url)
+    var protocol = url.protocol === 'https:'
+                 ? 'https:'
+                 : 'http:'
+    return protocol + '//' + (url.host || '') +
+      url.path.replace(/\.git$/, '')
+  } catch (e) {}
+}

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

@@ -0,0 +1 @@
+module.exports = require('./utils/lifecycle-cmd.js')('restart')

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

@@ -0,0 +1,15 @@
+module.exports = root
+
+var npm = require('./npm.js')
+var output = require('./utils/output.js')
+
+root.usage = 'npm root [-g]'
+
+function root (args, silent, cb) {
+  if (typeof cb !== 'function') {
+    cb = silent
+    silent = false
+  }
+  if (!silent) output(npm.dir)
+  process.nextTick(cb.bind(this, null, npm.dir))
+}

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

@@ -0,0 +1,181 @@
+module.exports = runScript
+
+var lifecycle = require('./utils/lifecycle.js')
+var npm = require('./npm.js')
+var path = require('path')
+var readJson = require('read-package-json')
+var log = require('npmlog')
+var chain = require('slide').chain
+var usage = require('./utils/usage')
+var output = require('./utils/output.js')
+
+runScript.usage = usage(
+  'run-script',
+  'npm run-script <command> [-- <args>...]'
+)
+
+runScript.completion = function (opts, cb) {
+  // see if there's already a package specified.
+  var argv = opts.conf.argv.remain
+
+  if (argv.length >= 4) return cb()
+
+  if (argv.length === 3) {
+    // either specified a script locally, in which case, done,
+    // or a package, in which case, complete against its scripts
+    var json = path.join(npm.localPrefix, 'package.json')
+    return readJson(json, function (er, d) {
+      if (er && er.code !== 'ENOENT' && er.code !== 'ENOTDIR') return cb(er)
+      if (er) d = {}
+      var scripts = Object.keys(d.scripts || {})
+      console.error('local scripts', scripts)
+      if (scripts.indexOf(argv[2]) !== -1) return cb()
+      // ok, try to find out which package it was, then
+      var pref = npm.config.get('global') ? npm.config.get('prefix')
+               : npm.localPrefix
+      var pkgDir = path.resolve(pref, 'node_modules', argv[2], 'package.json')
+      readJson(pkgDir, function (er, d) {
+        if (er && er.code !== 'ENOENT' && er.code !== 'ENOTDIR') return cb(er)
+        if (er) d = {}
+        var scripts = Object.keys(d.scripts || {})
+        return cb(null, scripts)
+      })
+    })
+  }
+
+  readJson(path.join(npm.localPrefix, 'package.json'), function (er, d) {
+    if (er && er.code !== 'ENOENT' && er.code !== 'ENOTDIR') return cb(er)
+    d = d || {}
+    cb(null, Object.keys(d.scripts || {}))
+  })
+}
+
+function runScript (args, cb) {
+  if (!args.length) return list(cb)
+
+  var pkgdir = npm.localPrefix
+  var cmd = args.shift()
+
+  readJson(path.resolve(pkgdir, 'package.json'), function (er, d) {
+    if (er) return cb(er)
+    run(d, pkgdir, cmd, args, cb)
+  })
+}
+
+function list (cb) {
+  var json = path.join(npm.localPrefix, 'package.json')
+  var cmdList = [
+    'publish',
+    'install',
+    'uninstall',
+    'test',
+    'stop',
+    'start',
+    'restart',
+    'version'
+  ].reduce(function (l, p) {
+    return l.concat(['pre' + p, p, 'post' + p])
+  }, [])
+  return readJson(json, function (er, d) {
+    if (er && er.code !== 'ENOENT' && er.code !== 'ENOTDIR') return cb(er)
+    if (er) d = {}
+    var allScripts = Object.keys(d.scripts || {})
+    var scripts = []
+    var runScripts = []
+    allScripts.forEach(function (script) {
+      if (cmdList.indexOf(script) !== -1) scripts.push(script)
+      else runScripts.push(script)
+    })
+
+    if (log.level === 'silent') {
+      return cb(null, allScripts)
+    }
+
+    if (npm.config.get('json')) {
+      output(JSON.stringify(d.scripts || {}, null, 2))
+      return cb(null, allScripts)
+    }
+
+    if (npm.config.get('parseable')) {
+      allScripts.forEach(function (script) {
+        output(script + ':' + d.scripts[script])
+      })
+      return cb(null, allScripts)
+    }
+
+    var s = '\n    '
+    var prefix = '  '
+    if (scripts.length) {
+      output('Lifecycle scripts included in %s:', d.name)
+    }
+    scripts.forEach(function (script) {
+      output(prefix + script + s + d.scripts[script])
+    })
+    if (!scripts.length && runScripts.length) {
+      output('Scripts available in %s via `npm run-script`:', d.name)
+    } else if (runScripts.length) {
+      output('\navailable via `npm run-script`:')
+    }
+    runScripts.forEach(function (script) {
+      output(prefix + script + s + d.scripts[script])
+    })
+    return cb(null, allScripts)
+  })
+}
+
+function run (pkg, wd, cmd, args, cb) {
+  if (!pkg.scripts) pkg.scripts = {}
+
+  var cmds
+  if (cmd === 'restart' && !pkg.scripts.restart) {
+    cmds = [
+      'prestop', 'stop', 'poststop',
+      'restart',
+      'prestart', 'start', 'poststart'
+    ]
+  } else {
+    if (!pkg.scripts[cmd]) {
+      if (cmd === 'test') {
+        pkg.scripts.test = 'echo \'Error: no test specified\''
+      } else if (cmd === 'env') {
+        if (process.platform === 'win32') {
+          log.verbose('run-script using default platform env: SET (Windows)')
+          pkg.scripts[cmd] = 'SET'
+        } else {
+          log.verbose('run-script using default platform env: env (Unix)')
+          pkg.scripts[cmd] = 'env'
+        }
+      } else if (npm.config.get('if-present')) {
+        return cb(null)
+      } else {
+        return cb(new Error('missing script: ' + cmd))
+      }
+    }
+    cmds = [cmd]
+  }
+
+  if (!cmd.match(/^(pre|post)/)) {
+    cmds = ['pre' + cmd].concat(cmds).concat('post' + cmd)
+  }
+
+  log.verbose('run-script', cmds)
+  chain(cmds.map(function (c) {
+    // pass cli arguments after -- to script.
+    if (pkg.scripts[c] && c === cmd) {
+      pkg.scripts[c] = pkg.scripts[c] + joinArgs(args)
+    }
+
+    // when running scripts explicitly, assume that they're trusted.
+    return [lifecycle, pkg, c, wd, { unsafePerm: true }]
+  }), cb)
+}
+
+// join arguments after '--' and pass them to script,
+// handle special characters such as ', ", ' '.
+function joinArgs (args) {
+  var joinedArgs = ''
+  args.forEach(function (arg) {
+    joinedArgs += ' "' + arg.replace(/"/g, '\\"') + '"'
+  })
+  return joinedArgs
+}