jfrog-cli-v2-jf 2.6.0

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

@@ -0,0 +1,425 @@
+/*
+
+npm outdated [pkg]
+
+Does the following:
+
+1. check for a new version of pkg
+
+If no packages are specified, then run for all installed
+packages.
+
+--parseable creates output like this:
+<fullpath>:<name@wanted>:<name@installed>:<name@latest>
+
+*/
+
+module.exports = outdated
+
+outdated.usage = 'npm outdated [[<@scope>/]<pkg> ...]'
+
+outdated.completion = require('./utils/completion/installed-deep.js')
+
+var os = require('os')
+var url = require('url')
+var path = require('path')
+var readPackageTree = require('read-package-tree')
+var readJson = require('read-package-json')
+var asyncMap = require('slide').asyncMap
+var color = require('ansicolors')
+var styles = require('ansistyles')
+var table = require('text-table')
+var semver = require('semver')
+var npa = require('npm-package-arg')
+var mutateIntoLogicalTree = require('./install/mutate-into-logical-tree.js')
+var npm = require('./npm.js')
+var long = npm.config.get('long')
+var mapToRegistry = require('./utils/map-to-registry.js')
+var isExtraneous = require('./install/is-extraneous.js')
+var computeMetadata = require('./install/deps.js').computeMetadata
+var computeVersionSpec = require('./install/deps.js').computeVersionSpec
+var moduleName = require('./utils/module-name.js')
+var output = require('./utils/output.js')
+var ansiTrim = require('./utils/ansi-trim')
+var fetchPackageMetadata = require('./fetch-package-metadata.js')
+
+function uniq (list) {
+  // we maintain the array because we need an array, not iterator, return
+  // value.
+  var uniqed = []
+  var seen = new Set()
+  list.forEach(function (item) {
+    if (seen.has(item)) return
+    seen.add(item)
+    uniqed.push(item)
+  })
+  return uniqed
+}
+
+function andComputeMetadata (next) {
+  return function (er, tree) {
+    if (er) return next(er)
+    next(null, computeMetadata(tree))
+  }
+}
+
+function outdated (args, silent, cb) {
+  if (typeof cb !== 'function') {
+    cb = silent
+    silent = false
+  }
+  var dir = path.resolve(npm.dir, '..')
+
+  // default depth for `outdated` is 0 (cf. `ls`)
+  if (npm.config.get('depth') === Infinity) npm.config.set('depth', 0)
+
+  readPackageTree(dir, andComputeMetadata(function (er, tree) {
+    if (!tree) return cb(er)
+    mutateIntoLogicalTree(tree)
+    outdated_(args, '', tree, {}, 0, function (er, list) {
+      list = uniq(list || []).sort(function (aa, bb) {
+        return aa[0].path.localeCompare(bb[0].path) ||
+          aa[1].localeCompare(bb[1])
+      })
+      if (er || silent || list.length === 0) return cb(er, list)
+      if (npm.config.get('json')) {
+        output(makeJSON(list))
+      } else if (npm.config.get('parseable')) {
+        output(makeParseable(list))
+      } else {
+        var outList = list.map(makePretty)
+        var outHead = [ 'Package',
+                        'Current',
+                        'Wanted',
+                        'Latest',
+                        'Location'
+                      ]
+        if (long) outHead.push('Package Type')
+        var outTable = [outHead].concat(outList)
+
+        if (npm.color) {
+          outTable[0] = outTable[0].map(function (heading) {
+            return styles.underline(heading)
+          })
+        }
+
+        var tableOpts = {
+          align: ['l', 'r', 'r', 'r', 'l'],
+          stringLength: function (s) { return ansiTrim(s).length }
+        }
+        output(table(outTable, tableOpts))
+      }
+      process.exitCode = 1
+      cb(null, list.map(function (item) { return [item[0].parent.path].concat(item.slice(1, 7)) }))
+    })
+  }))
+}
+
+// [[ dir, dep, has, want, latest, type ]]
+function makePretty (p) {
+  var dep = p[0]
+  var depname = p[1]
+  var dir = dep.path
+  var has = p[2]
+  var want = p[3]
+  var latest = p[4]
+  var type = p[6]
+  var deppath = p[7]
+
+  if (!npm.config.get('global')) {
+    dir = path.relative(process.cwd(), dir)
+  }
+
+  var columns = [ depname,
+                  has || 'MISSING',
+                  want,
+                  latest,
+                  deppath
+                ]
+  if (long) columns[5] = type
+
+  if (npm.color) {
+    columns[0] = color[has === want || want === 'linked' ? 'yellow' : 'red'](columns[0]) // dep
+    columns[2] = color.green(columns[2]) // want
+    columns[3] = color.magenta(columns[3]) // latest
+  }
+
+  return columns
+}
+
+function makeParseable (list) {
+  return list.map(function (p) {
+    var dep = p[0]
+    var depname = p[1]
+    var dir = dep.path
+    var has = p[2]
+    var want = p[3]
+    var latest = p[4]
+    var type = p[6]
+
+    var out = [
+      dir,
+      depname + '@' + want,
+      (has ? (depname + '@' + has) : 'MISSING'),
+      depname + '@' + latest
+    ]
+    if (long) out.push(type)
+
+    return out.join(':')
+  }).join(os.EOL)
+}
+
+function makeJSON (list) {
+  var out = {}
+  list.forEach(function (p) {
+    var dep = p[0]
+    var depname = p[1]
+    var dir = dep.path
+    var has = p[2]
+    var want = p[3]
+    var latest = p[4]
+    var type = p[6]
+    if (!npm.config.get('global')) {
+      dir = path.relative(process.cwd(), dir)
+    }
+    out[depname] = { current: has,
+                  wanted: want,
+                  latest: latest,
+                  location: dir
+                }
+    if (long) out[depname].type = type
+  })
+  return JSON.stringify(out, null, 2)
+}
+
+function outdated_ (args, path, tree, parentHas, depth, cb) {
+  if (!tree.package) tree.package = {}
+  if (path && tree.package.name) path += ' > ' + tree.package.name
+  if (!path && tree.package.name) path = tree.package.name
+  if (depth > npm.config.get('depth')) {
+    return cb(null, [])
+  }
+  var types = {}
+  var pkg = tree.package
+
+  var deps = tree.error ? tree.children : tree.children.filter((child) => !isExtraneous(child))
+
+  deps.forEach(function (dep) {
+    types[moduleName(dep)] = 'dependencies'
+  })
+
+  Object.keys(tree.missingDeps).forEach(function (name) {
+    deps.push({
+      package: { name: name },
+      path: tree.path,
+      parent: tree,
+      isMissing: true
+    })
+    types[name] = 'dependencies'
+  })
+
+  // If we explicitly asked for dev deps OR we didn't ask for production deps
+  // AND we asked to save dev-deps OR we didn't ask to save anything that's NOT
+  // dev deps then…
+  // (All the save checking here is because this gets called from npm-update currently
+  // and that requires this logic around dev deps.)
+  // FIXME: Refactor npm update to not be in terms of outdated.
+  var dev = npm.config.get('dev') || /^dev(elopment)?$/.test(npm.config.get('also'))
+  var prod = npm.config.get('production') || /^prod(uction)?$/.test(npm.config.get('only'))
+  if ((dev || !prod) &&
+      (npm.config.get('save-dev') || (
+        !npm.config.get('save') && !npm.config.get('save-optional')))) {
+    Object.keys(tree.missingDevDeps).forEach(function (name) {
+      deps.push({
+        package: { name: name },
+        path: tree.path,
+        parent: tree,
+        isMissing: true
+      })
+      if (!types[name]) {
+        types[name] = 'devDependencies'
+      }
+    })
+  }
+
+  if (npm.config.get('save-dev')) {
+    deps = deps.filter(function (dep) { return pkg.devDependencies[moduleName(dep)] })
+    deps.forEach(function (dep) {
+      types[moduleName(dep)] = 'devDependencies'
+    })
+  } else if (npm.config.get('save')) {
+    // remove optional dependencies from dependencies during --save.
+    deps = deps.filter(function (dep) { return !pkg.optionalDependencies[moduleName(dep)] })
+  } else if (npm.config.get('save-optional')) {
+    deps = deps.filter(function (dep) { return pkg.optionalDependencies[moduleName(dep)] })
+    deps.forEach(function (dep) {
+      types[moduleName(dep)] = 'optionalDependencies'
+    })
+  }
+  var doUpdate = dev || (
+    !prod &&
+    !Object.keys(parentHas).length &&
+    !npm.config.get('global')
+  )
+  if (doUpdate) {
+    Object.keys(pkg.devDependencies).forEach(function (k) {
+      if (!(k in parentHas)) {
+        deps[k] = pkg.devDependencies[k]
+        types[k] = 'devDependencies'
+      }
+    })
+  }
+
+  var has = Object.create(parentHas)
+  tree.children.forEach(function (child) {
+    if (child.package.name && child.package.private) {
+      deps = deps.filter(function (dep) { return dep !== child })
+    }
+    has[child.package.name] = {
+      version: child.package.version,
+      from: child.package._from
+    }
+  })
+
+  // now get what we should have, based on the dep.
+  // if has[dep] !== shouldHave[dep], then cb with the data
+  // otherwise dive into the folder
+  asyncMap(deps, function (dep, cb) {
+    var name = moduleName(dep)
+    var required = (tree.package.dependencies)[name] ||
+                   (tree.package.optionalDependencies)[name] ||
+                   (tree.package.devDependencies)[name] ||
+                   computeVersionSpec(tree, dep) ||
+                   '*'
+    if (!long) return shouldUpdate(args, dep, name, has, required, depth, path, cb)
+
+    shouldUpdate(args, dep, name, has, required, depth, path, cb, types[name])
+  }, cb)
+}
+
+function shouldUpdate (args, tree, dep, has, req, depth, pkgpath, cb, type) {
+  // look up the most recent version.
+  // if that's what we already have, or if it's not on the args list,
+  // then dive into it.  Otherwise, cb() with the data.
+
+  // { version: , from: }
+  var curr = has[dep]
+
+  function skip (er) {
+    // show user that no viable version can be found
+    if (er) return cb(er)
+    outdated_(args,
+              pkgpath,
+              tree,
+              has,
+              depth + 1,
+              cb)
+  }
+
+  function doIt (wanted, latest) {
+    if (!long) {
+      return cb(null, [[tree, dep, curr && curr.version, wanted, latest, req, null, pkgpath]])
+    }
+    cb(null, [[tree, dep, curr && curr.version, wanted, latest, req, type, pkgpath]])
+  }
+
+  if (args.length && args.indexOf(dep) === -1) return skip()
+  var parsed = npa.resolve(dep, req)
+  if (tree.isLink && tree.parent && tree.parent.isTop) {
+    return doIt('linked', 'linked')
+  }
+  if (parsed.type === 'git' || parsed.type === 'hosted') {
+    return doIt('git', 'git')
+  }
+
+  // search for the latest package
+  mapToRegistry(dep, npm.config, function (er, uri, auth) {
+    if (er) return cb(er)
+
+    npm.registry.get(uri, { auth: auth }, updateDeps)
+  })
+
+  function updateLocalDeps (latestRegistryVersion) {
+    readJson(path.resolve(parsed.fetchSpec, 'package.json'), function (er, localDependency) {
+      if (er) return cb()
+
+      var wanted = localDependency.version
+      var latest = localDependency.version
+
+      if (latestRegistryVersion) {
+        latest = latestRegistryVersion
+        if (semver.lt(wanted, latestRegistryVersion)) {
+          wanted = latestRegistryVersion
+          req = dep + '@' + latest
+        }
+      }
+
+      if (!curr || curr.version !== wanted) {
+        doIt(wanted, latest)
+      } else {
+        skip()
+      }
+    })
+  }
+
+  function updateDeps (er, d) {
+    if (er) {
+      if (parsed.type !== 'directory' && parsed.type !== 'file') return cb(er)
+      return updateLocalDeps()
+    }
+
+    if (!d || !d['dist-tags'] || !d.versions) return cb()
+    var l = d.versions[d['dist-tags'].latest]
+    if (!l) return cb()
+
+    var r = req
+    if (d['dist-tags'][req]) {
+      r = d['dist-tags'][req]
+    }
+
+    if (semver.validRange(r, true)) {
+      // some kind of semver range.
+      // see if it's in the doc.
+      var vers = Object.keys(d.versions)
+      var v = semver.maxSatisfying(vers, r, true)
+      if (v) {
+        return onCacheAdd(null, d.versions[v])
+      }
+    }
+
+    // We didn't find the version in the doc.  See if we can find it in metadata.
+    var spec = dep
+    if (req) {
+      spec = dep + '@' + req
+    }
+    fetchPackageMetadata(spec, '', onCacheAdd)
+
+    function onCacheAdd (er, d) {
+      // if this fails, then it means we can't update this thing.
+      // it's probably a thing that isn't published.
+      if (er) {
+        if (er.code && er.code === 'ETARGET') {
+          // no viable version found
+          return skip(er)
+        }
+        return skip()
+      }
+
+      // check that the url origin hasn't changed (#1727) and that
+      // there is no newer version available
+      var dFromUrl = d._from && url.parse(d._from).protocol
+      var cFromUrl = curr && curr.from && url.parse(curr.from).protocol
+
+      if (!curr ||
+          dFromUrl && cFromUrl && d._from !== curr.from ||
+          d.version !== curr.version ||
+          d.version !== l.version) {
+        if (parsed.type === 'file' || parsed.type === 'directory') return updateLocalDeps(l.version)
+
+        doIt(d.version, l.version)
+      } else {
+        skip()
+      }
+    }
+  }
+}

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

@@ -0,0 +1,277 @@
+module.exports = owner
+
+var npm = require('./npm.js')
+var log = require('npmlog')
+var mapToRegistry = require('./utils/map-to-registry.js')
+var readLocalPkg = require('./utils/read-local-package.js')
+var usage = require('./utils/usage')
+var output = require('./utils/output.js')
+
+owner.usage = usage(
+  'owner',
+  'npm owner add <user> [<@scope>/]<pkg>' +
+  '\nnpm owner rm <user> [<@scope>/]<pkg>' +
+  '\nnpm owner ls [<@scope>/]<pkg>'
+)
+owner.completion = function (opts, cb) {
+  var argv = opts.conf.argv.remain
+  if (argv.length > 4) return cb()
+  if (argv.length <= 2) {
+    var subs = ['add', 'rm']
+    if (opts.partialWord === 'l') subs.push('ls')
+    else subs.push('ls', 'list')
+    return cb(null, subs)
+  }
+
+  npm.commands.whoami([], true, function (er, username) {
+    if (er) return cb()
+
+    var un = encodeURIComponent(username)
+    var byUser, theUser
+    switch (argv[2]) {
+      case 'ls':
+        // FIXME: there used to be registry completion here, but it stopped
+        // making sense somewhere around 50,000 packages on the registry
+        return cb()
+
+      case 'rm':
+        if (argv.length > 3) {
+          theUser = encodeURIComponent(argv[3])
+          byUser = '-/by-user/' + theUser + '|' + un
+          return mapToRegistry(byUser, npm.config, function (er, uri, auth) {
+            if (er) return cb(er)
+
+            console.error(uri)
+            npm.registry.get(uri, { auth: auth }, function (er, d) {
+              if (er) return cb(er)
+              // return the intersection
+              return cb(null, d[theUser].filter(function (p) {
+                // kludge for server adminery.
+                return un === 'isaacs' || d[un].indexOf(p) === -1
+              }))
+            })
+          })
+        }
+        // else fallthrough
+        /*eslint no-fallthrough:0*/
+      case 'add':
+        if (argv.length > 3) {
+          theUser = encodeURIComponent(argv[3])
+          byUser = '-/by-user/' + theUser + '|' + un
+          return mapToRegistry(byUser, npm.config, function (er, uri, auth) {
+            if (er) return cb(er)
+
+            console.error(uri)
+            npm.registry.get(uri, { auth: auth }, function (er, d) {
+              console.error(uri, er || d)
+              // return mine that they're not already on.
+              if (er) return cb(er)
+              var mine = d[un] || []
+              var theirs = d[theUser] || []
+              return cb(null, mine.filter(function (p) {
+                return theirs.indexOf(p) === -1
+              }))
+            })
+          })
+        }
+        // just list all users who aren't me.
+        return mapToRegistry('-/users', npm.config, function (er, uri, auth) {
+          if (er) return cb(er)
+
+          npm.registry.get(uri, { auth: auth }, function (er, list) {
+            if (er) return cb()
+            return cb(null, Object.keys(list).filter(function (n) {
+              return n !== un
+            }))
+          })
+        })
+
+      default:
+        return cb()
+    }
+  })
+}
+
+function owner (args, cb) {
+  var action = args.shift()
+  switch (action) {
+    case 'ls': case 'list': return ls(args[0], cb)
+    case 'add': return add(args[0], args[1], cb)
+    case 'rm': case 'remove': return rm(args[0], args[1], cb)
+    default: return unknown(action, cb)
+  }
+}
+
+function ls (pkg, cb) {
+  if (!pkg) {
+    return readLocalPkg(function (er, pkg) {
+      if (er) return cb(er)
+      if (!pkg) return cb(owner.usage)
+      ls(pkg, cb)
+    })
+  }
+
+  mapToRegistry(pkg, npm.config, function (er, uri, auth) {
+    if (er) return cb(er)
+
+    npm.registry.get(uri, { auth: auth }, function (er, data) {
+      var msg = ''
+      if (er) {
+        log.error('owner ls', "Couldn't get owner data", pkg)
+        return cb(er)
+      }
+      var owners = data.maintainers
+      if (!owners || !owners.length) {
+        msg = 'admin party!'
+      } else {
+        msg = owners.map(function (o) {
+          return o.name + ' <' + o.email + '>'
+        }).join('\n')
+      }
+      output(msg)
+      cb(er, owners)
+    })
+  })
+}
+
+function add (user, pkg, cb) {
+  if (!user) return cb(owner.usage)
+  if (!pkg) {
+    return readLocalPkg(function (er, pkg) {
+      if (er) return cb(er)
+      if (!pkg) return cb(new Error(owner.usage))
+      add(user, pkg, cb)
+    })
+  }
+
+  log.verbose('owner add', '%s to %s', user, pkg)
+  mutate(pkg, user, function (u, owners) {
+    if (!owners) owners = []
+    for (var i = 0, l = owners.length; i < l; i++) {
+      var o = owners[i]
+      if (o.name === u.name) {
+        log.info(
+          'owner add',
+          'Already a package owner: ' + o.name + ' <' + o.email + '>'
+        )
+        return false
+      }
+    }
+    owners.push(u)
+    return owners
+  }, cb)
+}
+
+function rm (user, pkg, cb) {
+  if (!pkg) {
+    return readLocalPkg(function (er, pkg) {
+      if (er) return cb(er)
+      if (!pkg) return cb(new Error(owner.usage))
+      rm(user, pkg, cb)
+    })
+  }
+
+  log.verbose('owner rm', '%s from %s', user, pkg)
+  mutate(pkg, user, function (u, owners) {
+    var found = false
+    var m = owners.filter(function (o) {
+      var match = (o.name === user)
+      found = found || match
+      return !match
+    })
+
+    if (!found) {
+      log.info('owner rm', 'Not a package owner: ' + user)
+      return false
+    }
+
+    if (!m.length) {
+      return new Error(
+        'Cannot remove all owners of a package.  Add someone else first.'
+      )
+    }
+
+    return m
+  }, cb)
+}
+
+function mutate (pkg, user, mutation, cb) {
+  if (user) {
+    var byUser = '-/user/org.couchdb.user:' + user
+    mapToRegistry(byUser, npm.config, function (er, uri, auth) {
+      if (er) return cb(er)
+
+      npm.registry.get(uri, { auth: auth }, mutate_)
+    })
+  } else {
+    mutate_(null, null)
+  }
+
+  function mutate_ (er, u) {
+    if (!er && user && (!u || u.error)) {
+      er = new Error(
+        "Couldn't get user data for " + user + ': ' + JSON.stringify(u)
+      )
+    }
+
+    if (er) {
+      log.error('owner mutate', 'Error getting user data for %s', user)
+      return cb(er)
+    }
+
+    if (u) u = { name: u.name, email: u.email }
+    mapToRegistry(pkg, npm.config, function (er, uri, auth) {
+      if (er) return cb(er)
+
+      npm.registry.get(uri, { auth: auth }, function (er, data) {
+        if (er) {
+          log.error('owner mutate', 'Error getting package data for %s', pkg)
+          return cb(er)
+        }
+
+        // save the number of maintainers before mutation so that we can figure
+        // out if maintainers were added or removed
+        var beforeMutation = data.maintainers.length
+
+        var m = mutation(u, data.maintainers)
+        if (!m) return cb() // handled
+        if (m instanceof Error) return cb(m) // error
+
+        data = {
+          _id: data._id,
+          _rev: data._rev,
+          maintainers: m
+        }
+        var dataPath = pkg.replace('/', '%2f') + '/-rev/' + data._rev
+        mapToRegistry(dataPath, npm.config, function (er, uri, auth) {
+          if (er) return cb(er)
+
+          var params = {
+            method: 'PUT',
+            body: data,
+            auth: auth
+          }
+          npm.registry.request(uri, params, function (er, data) {
+            if (!er && data.error) {
+              er = new Error('Failed to update package metadata: ' + JSON.stringify(data))
+            }
+
+            if (er) {
+              log.error('owner mutate', 'Failed to update package metadata')
+            } else if (m.length > beforeMutation) {
+              output('+ %s (%s)', user, pkg)
+            } else if (m.length < beforeMutation) {
+              output('- %s (%s)', user, pkg)
+            }
+
+            cb(er, data)
+          })
+        })
+      })
+    })
+  }
+}
+
+function unknown (action, cb) {
+  cb('Usage: \n' + owner.usage)
+}