embeditor-rails 1.1.1 → 2.0.0.beta

data/lib/node_modules/npm/lib/npm.js

@@ -0,0 +1,528 @@
+;(function(){
+// windows: running "npm blah" in this folder will invoke WSH, not node.
+if (typeof WScript !== "undefined") {
+  WScript.echo("npm does not work when run\n"
+              +"with the Windows Scripting Host\n\n"
+              +"'cd' to a different directory,\n"
+              +"or type 'npm.cmd <args>',\n"
+              +"or type 'node npm <args>'.")
+  WScript.quit(1)
+  return
+}
+
+
+// monkey-patch support for 0.6 child processes
+require('child-process-close')
+
+var EventEmitter = require("events").EventEmitter
+  , npm = module.exports = new EventEmitter
+  , config = require("./config.js")
+  , npmconf = require("npmconf")
+  , log = require("npmlog")
+  , fs = require("graceful-fs")
+  , path = require("path")
+  , abbrev = require("abbrev")
+  , which = require("which")
+  , semver = require("semver")
+  , findPrefix = require("./utils/find-prefix.js")
+  , getUid = require("uid-number")
+  , mkdirp = require("mkdirp")
+  , slide = require("slide")
+  , chain = slide.chain
+  , RegClient = require("npm-registry-client")
+
+npm.config = {
+  loaded: false,
+  get: function() {
+    throw new Error('npm.load() required')
+  },
+  set: function() {
+    throw new Error('npm.load() required')
+  }
+}
+
+// /usr/local is often a read-only fs, which is not
+// well handled by node or mkdirp.  Just double-check
+// in the case of errors when making the prefix dirs.
+function mkdir (p, cb) {
+  mkdirp(p, function (er, made) {
+    // it could be that we couldn't create it, because it
+    // already exists, and is on a read-only fs.
+    if (er) {
+      return fs.stat(p, function (er2, st) {
+        if (er2 || !st.isDirectory()) return cb(er)
+        return cb(null, made)
+      })
+    }
+    return cb(er, made)
+  })
+}
+
+npm.commands = {}
+
+try {
+  var pv = process.version.replace(/^v/, '')
+  // startup, ok to do this synchronously
+  var j = JSON.parse(fs.readFileSync(
+    path.join(__dirname, "../package.json"))+"")
+  npm.version = j.version
+  npm.nodeVersionRequired = j.engines.node
+  if (!semver.satisfies(pv, j.engines.node)) {
+    log.warn("unsupported version", [""
+            ,"npm requires node version: "+j.engines.node
+            ,"And you have: "+pv
+            ,"which is not satisfactory."
+            ,""
+            ,"Bad things will likely happen.  You have been warned."
+            ,""].join("\n"))
+  }
+} catch (ex) {
+  try {
+    log.info("error reading version", ex)
+  } catch (er) {}
+  npm.version = ex
+}
+
+var commandCache = {}
+  // short names for common things
+  , aliases = { "rm" : "uninstall"
+              , "r" : "uninstall"
+              , "un" : "uninstall"
+              , "unlink" : "uninstall"
+              , "remove" : "uninstall"
+              , "rb" : "rebuild"
+              , "list" : "ls"
+              , "la" : "ls"
+              , "ll" : "ls"
+              , "ln" : "link"
+              , "i" : "install"
+              , "isntall" : "install"
+              , "up" : "update"
+              , "c" : "config"
+              , "info" : "view"
+              , "show" : "view"
+              , "find" : "search"
+              , "s" : "search"
+              , "se" : "search"
+              , "author" : "owner"
+              , "home" : "docs"
+              , "issues": "bugs"
+              , "unstar": "star" // same function
+              , "apihelp" : "help"
+              , "login": "adduser"
+              , "add-user": "adduser"
+              , "tst": "test"
+              , "find-dupes": "dedupe"
+              , "ddp": "dedupe"
+              , "v": "view"
+              }
+
+  , aliasNames = Object.keys(aliases)
+  // these are filenames in .
+  , cmdList = [ "install"
+              , "uninstall"
+              , "cache"
+              , "config"
+              , "set"
+              , "get"
+              , "update"
+              , "outdated"
+              , "prune"
+              , "submodule"
+              , "pack"
+              , "dedupe"
+
+              , "rebuild"
+              , "link"
+
+              , "publish"
+              , "star"
+              , "stars"
+              , "tag"
+              , "adduser"
+              , "unpublish"
+              , "owner"
+              , "deprecate"
+              , "shrinkwrap"
+
+              , "help"
+              , "help-search"
+              , "ls"
+              , "search"
+              , "view"
+              , "init"
+              , "version"
+              , "edit"
+              , "explore"
+              , "docs"
+              , "repo"
+              , "bugs"
+              , "faq"
+              , "root"
+              , "prefix"
+              , "bin"
+              , "whoami"
+
+              , "test"
+              , "stop"
+              , "start"
+              , "restart"
+              , "run-script"
+              , "completion"
+              ]
+  , plumbing = [ "build"
+               , "unbuild"
+               , "xmas"
+               , "substack"
+               , "visnup"
+               ]
+  , fullList = npm.fullList = cmdList.concat(aliasNames).filter(function (c) {
+      return plumbing.indexOf(c) === -1
+    })
+  , abbrevs = abbrev(fullList)
+
+Object.keys(abbrevs).concat(plumbing).forEach(function addCommand (c) {
+  Object.defineProperty(npm.commands, c, { get : function () {
+    if (!loaded) throw new Error(
+      "Call npm.load(config, cb) before using this command.\n"+
+      "See the README.md or cli.js for example usage.")
+    var a = npm.deref(c)
+    if (c === "la" || c === "ll") {
+      npm.config.set("long", true)
+    }
+    npm.command = c
+    if (commandCache[a]) return commandCache[a]
+    var cmd = require(__dirname+"/"+a+".js")
+    commandCache[a] = function () {
+      var args = Array.prototype.slice.call(arguments, 0)
+      if (typeof args[args.length - 1] !== "function") {
+        args.push(defaultCb)
+      }
+      if (args.length === 1) args.unshift([])
+      cmd.apply(npm, args)
+    }
+    Object.keys(cmd).forEach(function (k) {
+      commandCache[a][k] = cmd[k]
+    })
+    return commandCache[a]
+  }, enumerable: fullList.indexOf(c) !== -1 })
+
+  // make css-case commands callable via camelCase as well
+  if (c.match(/\-([a-z])/)) {
+    addCommand(c.replace(/\-([a-z])/g, function (a, b) {
+      return b.toUpperCase()
+    }))
+  }
+})
+
+function defaultCb (er, data) {
+  if (er) console.error(er.stack || er.message)
+  else console.log(data)
+}
+
+npm.deref = function (c) {
+  if (!c) return ""
+  if (c.match(/[A-Z]/)) c = c.replace(/([A-Z])/g, function (m) {
+    return "-" + m.toLowerCase()
+  })
+  if (plumbing.indexOf(c) !== -1) return c
+  var a = abbrevs[c]
+  if (aliases[a]) a = aliases[a]
+  return a
+}
+
+var loaded = false
+  , loading = false
+  , loadErr = null
+  , loadListeners = []
+
+function loadCb (er) {
+  loadListeners.forEach(function (cb) {
+    process.nextTick(cb.bind(npm, er, npm))
+  })
+  loadListeners.length = 0
+}
+
+npm.load = function (cli, cb_) {
+  if (!cb_ && typeof cli === "function") cb_ = cli , cli = {}
+  if (!cb_) cb_ = function () {}
+  if (!cli) cli = {}
+  loadListeners.push(cb_)
+  if (loaded || loadErr) return cb(loadErr)
+  if (loading) return
+  loading = true
+  var onload = true
+
+  function cb (er) {
+    if (loadErr) return
+    if (npm.config.get("force")) {
+      log.warn("using --force", "I sure hope you know what you are doing.")
+    }
+    npm.config.loaded = true
+    loaded = true
+    loadCb(loadErr = er)
+    if (onload = onload && npm.config.get("onload-script")) {
+      require(onload)
+      onload = false
+    }
+  }
+
+  log.pause()
+
+  load(npm, cli, cb)
+}
+
+function load (npm, cli, cb) {
+  which(process.argv[0], function (er, node) {
+    if (!er && node.toUpperCase() !== process.execPath.toUpperCase()) {
+      log.verbose("node symlink", node)
+      process.execPath = node
+      process.installPrefix = path.resolve(node, "..", "..")
+    }
+
+    // look up configs
+    //console.error("about to look up configs")
+
+    var builtin = path.resolve(__dirname, "..", "npmrc")
+    npmconf.load(cli, builtin, function (er, config) {
+      if (er === config) er = null
+
+      npm.config = config
+
+      var color = config.get("color")
+
+      log.level = config.get("loglevel")
+      log.heading = config.get("heading") || "npm"
+      log.stream = config.get("logstream")
+      switch (color) {
+        case "always": log.enableColor(); break
+        case false: log.disableColor(); break
+      }
+      log.resume()
+
+      if (er) return cb(er)
+
+      // see if we need to color normal output
+      switch (color) {
+        case "always":
+          npm.color = true
+          break
+        case false:
+          npm.color = false
+          break
+        default:
+          var tty = require("tty")
+          if (process.stdout.isTTY) npm.color = true
+          else if (!tty.isatty) npm.color = true
+          else if (tty.isatty(1)) npm.color = true
+          else npm.color = false
+          break
+      }
+
+      // at this point the configs are all set.
+      // go ahead and spin up the registry client.
+      var token = config.get("_token")
+      if (typeof token === "string") {
+        try {
+          token = JSON.parse(token)
+          config.set("_token", token, "user")
+          config.save("user")
+        } catch (e) { token = null }
+      }
+
+      npm.registry = new RegClient(npm.config)
+
+      // save the token cookie in the config file
+      if (npm.registry.couchLogin) {
+        npm.registry.couchLogin.tokenSet = function (tok) {
+          npm.config.set("_token", tok, "user")
+          // ignore save error.  best effort.
+          npm.config.save("user")
+        }
+      }
+
+      var umask = npm.config.get("umask")
+      npm.modes = { exec: 0777 & (~umask)
+                  , file: 0666 & (~umask)
+                  , umask: umask }
+
+      chain([ [ loadPrefix, npm, cli ]
+            , [ setUser, config, config.root ]
+            , [ loadUid, npm ]
+            ], cb)
+    })
+  })
+}
+
+function loadPrefix (npm, config, cb) {
+  // try to guess at a good node_modules location.
+  var p
+    , gp
+  if (!Object.prototype.hasOwnProperty.call(config, "prefix")) {
+    p = process.cwd()
+  } else {
+    p = npm.config.get("prefix")
+  }
+  gp = npm.config.get("prefix")
+
+  findPrefix(p, function (er, p) {
+    Object.defineProperty(npm, "localPrefix",
+      { get : function () { return p }
+      , set : function (r) { return p = r }
+      , enumerable : true
+      })
+    // the prefix MUST exist, or else nothing works.
+    if (!npm.config.get("global")) {
+      mkdir(p, next)
+    } else {
+      next(er)
+    }
+  })
+
+  gp = path.resolve(gp)
+  Object.defineProperty(npm, "globalPrefix",
+    { get : function () { return gp }
+    , set : function (r) { return gp = r }
+    , enumerable : true
+    })
+  // the prefix MUST exist, or else nothing works.
+  mkdir(gp, next)
+
+
+  var i = 2
+    , errState = null
+  function next (er) {
+    if (errState) return
+    if (er) return cb(errState = er)
+    if (--i === 0) return cb()
+  }
+}
+
+
+function loadUid (npm, cb) {
+  // if we're not in unsafe-perm mode, then figure out who
+  // to run stuff as.  Do this first, to support `npm update npm -g`
+  if (!npm.config.get("unsafe-perm")) {
+    getUid(npm.config.get("user"), npm.config.get("group"), cb)
+  } else {
+    process.nextTick(cb)
+  }
+}
+
+function setUser (cl, dc, cb) {
+  // If global, leave it as-is.
+  // If not global, then set the user to the owner of the prefix folder.
+  // Just set the default, so it can be overridden.
+  if (cl.get("global")) return cb()
+  if (process.env.SUDO_UID) {
+    dc.user = +(process.env.SUDO_UID)
+    return cb()
+  }
+
+  var prefix = path.resolve(cl.get("prefix"))
+  mkdir(prefix, function (er) {
+    if (er) {
+      log.error("could not create prefix dir", prefix)
+      return cb(er)
+    }
+    fs.stat(prefix, function (er, st) {
+      dc.user = st && st.uid
+      return cb(er)
+    })
+  })
+}
+
+
+Object.defineProperty(npm, "prefix",
+  { get : function () {
+      return npm.config.get("global") ? npm.globalPrefix : npm.localPrefix
+    }
+  , set : function (r) {
+      var k = npm.config.get("global") ? "globalPrefix" : "localPrefix"
+      return npm[k] = r
+    }
+  , enumerable : true
+  })
+
+Object.defineProperty(npm, "bin",
+  { get : function () {
+      if (npm.config.get("global")) return npm.globalBin
+      return path.resolve(npm.root, ".bin")
+    }
+  , enumerable : true
+  })
+
+Object.defineProperty(npm, "globalBin",
+  { get : function () {
+      var b = npm.globalPrefix
+      if (process.platform !== "win32") b = path.resolve(b, "bin")
+      return b
+    }
+  })
+
+Object.defineProperty(npm, "dir",
+  { get : function () {
+      if (npm.config.get("global")) return npm.globalDir
+      return path.resolve(npm.prefix, "node_modules")
+    }
+  , enumerable : true
+  })
+
+Object.defineProperty(npm, "globalDir",
+  { get : function () {
+      return (process.platform !== "win32")
+           ? path.resolve(npm.globalPrefix, "lib", "node_modules")
+           : path.resolve(npm.globalPrefix, "node_modules")
+    }
+  , enumerable : true
+  })
+
+Object.defineProperty(npm, "root",
+  { get : function () { return npm.dir } })
+
+Object.defineProperty(npm, "cache",
+  { get : function () { return npm.config.get("cache") }
+  , set : function (r) { return npm.config.set("cache", r) }
+  , enumerable : true
+  })
+
+var tmpFolder
+var crypto = require("crypto")
+var rand = crypto.randomBytes(6)
+                 .toString("base64")
+                 .replace(/\//g, '_')
+                 .replace(/\+/, '-')
+Object.defineProperty(npm, "tmp",
+  { get : function () {
+      if (!tmpFolder) tmpFolder = "npm-" + process.pid + "-" + rand
+      return path.resolve(npm.config.get("tmp"), tmpFolder)
+    }
+  , enumerable : true
+  })
+
+// the better to repl you with
+Object.getOwnPropertyNames(npm.commands).forEach(function (n) {
+  if (npm.hasOwnProperty(n) || n === "config") return
+
+  Object.defineProperty(npm, n, { get: function () {
+    return function () {
+      var args = Array.prototype.slice.call(arguments, 0)
+        , cb = defaultCb
+
+      if (args.length === 1 && Array.isArray(args[0])) {
+        args = args[0]
+      }
+
+      if (typeof args[args.length - 1] === "function") {
+        cb = args.pop()
+      }
+
+      npm.commands[n](args, cb)
+    }
+  }, enumerable: false, configurable: true })
+})
+
+if (require.main === module) {
+  require("../bin/npm-cli.js")
+}
+})()