embeditor-rails 1.1.1 → 2.0.0.beta

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

@@ -0,0 +1,253 @@
+
+module.exports = completion
+
+completion.usage = "npm completion >> ~/.bashrc\n"
+                 + "npm completion >> ~/.zshrc\n"
+                 + "source <(npm completion)"
+
+var npm = require("./npm.js")
+  , npmconf = require("npmconf")
+  , configDefs = npmconf.defs
+  , configTypes = configDefs.types
+  , shorthands = configDefs.shorthands
+  , nopt = require("nopt")
+  , configNames = Object.keys(configTypes).filter(function (e) {
+      return e.charAt(0) !== "_"
+    })
+  , shorthandNames = Object.keys(shorthands)
+  , allConfs = configNames.concat(shorthandNames)
+  , once = require("once")
+
+
+completion.completion = function (opts, cb) {
+  if (opts.w > 3) return cb()
+
+  var fs = require("graceful-fs")
+    , path = require("path")
+    , bashExists = null
+    , zshExists = null
+    , bashProfExists = null
+  fs.stat(path.resolve(process.env.HOME, ".bashrc"), function (er, b) {
+    bashExists = !er
+    next()
+  })
+  fs.stat(path.resolve(process.env.HOME, ".zshrc"), function (er, b) {
+    zshExists = !er
+    next()
+  })
+  function next () {
+    if (zshExists === null || bashExists === null) return
+    var out = []
+    if (zshExists) out.push("~/.zshrc")
+    if (bashExists) out.push("~/.bashrc")
+    if (opts.w === 2) out = out.map(function (m) {
+      return [">>", m]
+    })
+    cb(null, out)
+  }
+}
+
+function completion (args, cb) {
+  if (process.platform === "win32") {
+    var e = new Error("npm completion not supported on windows")
+    e.code = "ENOTSUP"
+    e.errno = require("constants").ENOTSUP
+    return cb(e)
+  }
+
+  // if the COMP_* isn't in the env, then just dump the script.
+  if (process.env.COMP_CWORD === undefined
+    ||process.env.COMP_LINE === undefined
+    ||process.env.COMP_POINT === undefined
+    ) return dumpScript(cb)
+
+  console.error(process.env.COMP_CWORD)
+  console.error(process.env.COMP_LINE)
+  console.error(process.env.COMP_POINT)
+
+  //console.log("abracadabrasauce\nabracad cat monger")
+  //if (Math.random() * 3 < 1) console.log("man\\ bear\\ pig")
+  //else if (Math.random() * 3 < 1)
+  //  console.log("porkchop\\ sandwiches\nporkman")
+  //else console.log("encephylophagy")
+
+  // get the partial line and partial word,
+  // if the point isn't at the end.
+  // ie, tabbing at: npm foo b|ar
+  var w = +process.env.COMP_CWORD
+    , words = args.map(unescape)
+    , word = words[w]
+    , line = process.env.COMP_LINE
+    , point = +process.env.COMP_POINT
+    , lineLength = line.length
+    , partialLine = line.substr(0, point)
+    , partialWords = words.slice(0, w)
+
+  // figure out where in that last word the point is.
+  var partialWord = args[w]
+    , i = partialWord.length
+  while (partialWord.substr(0, i) !== partialLine.substr(-1*i) && i > 0) {
+    i --
+  }
+  partialWord = unescape(partialWord.substr(0, i))
+  partialWords.push(partialWord)
+
+  var opts = { words : words
+             , w : w
+             , word : word
+             , line : line
+             , lineLength : line.length
+             , point : point
+             , partialLine : partialLine
+             , partialWords : partialWords
+             , partialWord : partialWord
+             , raw: args
+             }
+
+  cb = wrapCb(cb, opts)
+
+  console.error(opts)
+
+  if (partialWords.slice(0, -1).indexOf("--") === -1) {
+    if (word.charAt(0) === "-") return configCompl(opts, cb)
+    if (words[w - 1]
+        && words[w - 1].charAt(0) === "-"
+        && !isFlag(words[w - 1])) {
+      // awaiting a value for a non-bool config.
+      // don't even try to do this for now
+      console.error("configValueCompl")
+      return configValueCompl(opts, cb)
+    }
+  }
+
+  // try to find the npm command.
+  // it's the first thing after all the configs.
+  // take a little shortcut and use npm's arg parsing logic.
+  // don't have to worry about the last arg being implicitly
+  // boolean'ed, since the last block will catch that.
+  var parsed = opts.conf =
+    nopt(configTypes, shorthands, partialWords.slice(0, -1), 0)
+  // check if there's a command already.
+  console.error(parsed)
+  var cmd = parsed.argv.remain[1]
+  if (!cmd) return cmdCompl(opts, cb)
+
+  Object.keys(parsed).forEach(function (k) {
+    npm.config.set(k, parsed[k])
+  })
+
+  // at this point, if words[1] is some kind of npm command,
+  // then complete on it.
+  // otherwise, do nothing
+  cmd = npm.commands[cmd]
+  if (cmd && cmd.completion) return cmd.completion(opts, cb)
+
+  // nothing to do.
+  cb()
+}
+
+function dumpScript (cb) {
+  var fs = require("graceful-fs")
+    , path = require("path")
+    , p = path.resolve(__dirname, "utils/completion.sh")
+
+  // The Darwin patch below results in callbacks first for the write and then
+  // for the error handler, so make sure we only call our callback once.
+  cb = once(cb)
+
+  fs.readFile(p, "utf8", function (er, d) {
+    if (er) return cb(er)
+    d = d.replace(/^\#\!.*?\n/, "")
+
+    process.stdout.write(d, function (n) { cb() })
+    process.stdout.on("error", function (er) {
+      // Darwin is a real dick sometimes.
+      //
+      // This is necessary because the "source" or "." program in
+      // bash on OS X closes its file argument before reading
+      // from it, meaning that you get exactly 1 write, which will
+      // work most of the time, and will always raise an EPIPE.
+      //
+      // Really, one should not be tossing away EPIPE errors, or any
+      // errors, so casually.  But, without this, `. <(npm completion)`
+      // can never ever work on OS X.
+      if (er.errno === "EPIPE") er = null
+      cb(er)
+    })
+
+  })
+}
+
+function unescape (w) {
+  if (w.charAt(0) === "\"") return w.replace(/^"|"$/g, "")
+  else return w.replace(/\\ /g, " ")
+}
+
+function escape (w) {
+  if (!w.match(/\s+/)) return w
+  return "\"" + w + "\""
+}
+
+// The command should respond with an array.  Loop over that,
+// wrapping quotes around any that have spaces, and writing
+// them to stdout.  Use console.log, not the outfd config.
+// If any of the items are arrays, then join them with a space.
+// Ie, returning ["a", "b c", ["d", "e"]] would allow it to expand
+// to: "a", "b c", or "d" "e"
+function wrapCb (cb, opts) { return function (er, compls) {
+  if (!Array.isArray(compls)) compls = compls ? [compls] : []
+  compls = compls.map(function (c) {
+    if (Array.isArray(c)) c = c.map(escape).join(" ")
+    else c = escape(c)
+    return c
+  })
+  if (opts.partialWord) compls = compls.filter(function (c) {
+    return c.indexOf(opts.partialWord) === 0
+  })
+  console.error([er && er.stack, compls, opts.partialWord])
+  if (er || compls.length === 0) return cb(er)
+
+  console.log(compls.join("\n"))
+  cb()
+}}
+
+// the current word has a dash.  Return the config names,
+// with the same number of dashes as the current word has.
+function configCompl (opts, cb) {
+  var word = opts.word
+    , split = word.match(/^(-+)((?:no-)*)(.*)$/)
+    , dashes = split[1]
+    , no = split[2]
+    , conf = split[3]
+    , confs = allConfs
+    , flags = configNames.filter(isFlag)
+  console.error(flags)
+
+  return cb(null, allConfs.map(function (c) {
+    return dashes + c
+  }).concat(flags.map(function (f) {
+    return dashes + (no || "no-") + f
+  })))
+}
+
+// expand with the valid values of various config values.
+// not yet implemented.
+function configValueCompl (opts, cb) {
+  console.error('configValue', opts)
+  return cb(null, [])
+}
+
+// check if the thing is a flag or not.
+function isFlag (word) {
+  // shorthands never take args.
+  var split = word.match(/^(-*)((?:no-)+)?(.*)$/)
+    , dashes = split[1]
+    , no = split[2]
+    , conf = split[3]
+  return no || configTypes[conf] === Boolean || shorthands[conf]
+}
+
+// complete against the npm commands
+function cmdCompl (opts, cb) {
+  return cb(null, npm.fullList)
+}

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

@@ -0,0 +1,285 @@
+
+module.exports = config
+
+config.usage = "npm config set <key> <value>"
+             + "\nnpm config get [<key>]"
+             + "\nnpm config delete <key>"
+             + "\nnpm config list"
+             + "\nnpm config edit"
+             + "\nnpm set <key> <value>"
+             + "\nnpm get [<key>]"
+
+var log = require("npmlog")
+  , npm = require("./npm.js")
+  , spawn = require("child_process").spawn
+  , fs = require("graceful-fs")
+  , npmconf = require("npmconf")
+  , types = npmconf.defs.types
+  , ini = require("ini")
+  , editor = require("editor")
+  , os = require("os")
+
+config.completion = function (opts, cb) {
+  var argv = opts.conf.argv.remain
+  if (argv[1] !== "config") argv.unshift("config")
+  if (argv.length === 2) {
+    var cmds = ["get", "set", "delete", "ls", "rm", "edit"]
+    if (opts.partialWord !== "l") cmds.push("list")
+    return cb(null, cmds)
+  }
+
+  var action = argv[2]
+  switch (action) {
+    case "set":
+      // todo: complete with valid values, if possible.
+      if (argv.length > 3) return cb(null, [])
+      // fallthrough
+    case "get":
+    case "delete":
+    case "rm":
+      return cb(null, Object.keys(types))
+    case "edit":
+    case "list": case "ls":
+      return cb(null, [])
+    default: return cb(null, [])
+  }
+}
+
+// npm config set key value
+// npm config get key
+// npm config list
+function config (args, cb) {
+  var action = args.shift()
+  switch (action) {
+    case "set": return set(args[0], args[1], cb)
+    case "get": return get(args[0], cb)
+    case "delete": case "rm": case "del": return del(args[0], cb)
+    case "list": case "ls": return list(cb)
+    case "edit": return edit(cb)
+    default: return unknown(action, cb)
+  }
+}
+
+function edit (cb) {
+  var e = npm.config.get("editor")
+    , which = npm.config.get("global") ? "global" : "user"
+    , f = npm.config.get(which + "config")
+  if (!e) return cb(new Error("No EDITOR config or environ set."))
+  npm.config.save(which, function (er) {
+    if (er) return cb(er)
+    fs.readFile(f, "utf8", function (er, data) {
+      if (er) data = ""
+      data = [ ";;;;"
+             , "; npm "+(npm.config.get("global") ?
+                         "globalconfig" : "userconfig")+" file"
+             , "; this is a simple ini-formatted file"
+             , "; lines that start with semi-colons are comments."
+             , "; read `npm help config` for help on the various options"
+             , ";;;;"
+             , ""
+             , data
+             ].concat( [ ";;;;"
+                       , "; all options with default values"
+                       , ";;;;"
+                       ]
+                     )
+              .concat(Object.keys(npmconf.defaults).reduce(function (arr, key) {
+                var obj = {};
+                obj[key] = npmconf.defaults[key]
+                if (key === "logstream") return arr
+                return arr.concat(
+                  ini.stringify(obj)
+                    .replace(/\n$/m, '')
+                    .replace(/^/g, '; ')
+                    .replace(/\n/g, '\n; ')
+                    .split('\n'))
+              }, []))
+              .concat([""])
+              .join(os.EOL)
+      fs.writeFile
+        ( f
+        , data
+        , "utf8"
+        , function (er) {
+            if (er) return cb(er)
+            editor(f, { editor: e }, cb)
+          }
+        )
+    })
+  })
+}
+
+function del (key, cb) {
+  if (!key) return cb(new Error("no key provided"))
+  var where = npm.config.get("global") ? "global" : "user"
+  npm.config.del(key, where)
+  npm.config.save(where, cb)
+}
+
+function set (key, val, cb) {
+  if (key === undefined) {
+    return unknown("", cb)
+  }
+  if (val === undefined) {
+    if (key.indexOf("=") !== -1) {
+      var k = key.split("=")
+      key = k.shift()
+      val = k.join("=")
+    } else {
+      val = ""
+    }
+  }
+  key = key.trim()
+  val = val.trim()
+  log.info("config", "set %j %j", key, val)
+  var where = npm.config.get("global") ? "global" : "user"
+  npm.config.set(key, val, where)
+  npm.config.save(where, cb)
+}
+
+function get (key, cb) {
+  if (!key) return list(cb)
+  if (key.charAt(0) === "_") {
+    return cb(new Error("---sekretz---"))
+  }
+  console.log(npm.config.get(key))
+  cb()
+}
+
+function sort (a, b) {
+  return a > b ? 1 : -1
+}
+
+function reverse (a, b) {
+  return a > b ? -1 : 1
+}
+
+function public (k) {
+  return !(k.charAt(0) === "_" || types[k] !== types[k])
+}
+
+function getKeys (data) {
+  return Object.keys(data).filter(public).sort(sort)
+}
+
+function list (cb) {
+  var msg = ""
+    , long = npm.config.get("long")
+
+  var cli = npm.config.sources.cli.data
+    , cliKeys = getKeys(cli)
+  if (cliKeys.length) {
+    msg += "; cli configs\n"
+    cliKeys.forEach(function (k) {
+      if (cli[k] && typeof cli[k] === "object") return
+      if (k === "argv") return
+      msg += k + " = " + JSON.stringify(cli[k]) + "\n"
+    })
+    msg += "\n"
+  }
+
+  // env configs
+  var env = npm.config.sources.env.data
+    , envKeys = getKeys(env)
+  if (envKeys.length) {
+    msg += "; environment configs\n"
+    envKeys.forEach(function (k) {
+      if (env[k] !== npm.config.get(k)) {
+        if (!long) return
+        msg += "; " + k + " = " + JSON.stringify(env[k])
+            + " (overridden)\n"
+      } else msg += k + " = " + JSON.stringify(env[k]) + "\n"
+    })
+    msg += "\n"
+  }
+
+  // user config file
+  var uconf = npm.config.sources.user.data
+    , uconfKeys = getKeys(uconf)
+  if (uconfKeys.length) {
+    msg += "; userconfig " + npm.config.get("userconfig") + "\n"
+    uconfKeys.forEach(function (k) {
+      var val = (k.charAt(0) === "_")
+              ? "---sekretz---"
+              : JSON.stringify(uconf[k])
+      if (uconf[k] !== npm.config.get(k)) {
+        if (!long) return
+        msg += "; " + k + " = " + val
+            + " (overridden)\n"
+      } else msg += k + " = " + val + "\n"
+    })
+    msg += "\n"
+  }
+
+  // global config file
+  var gconf = npm.config.sources.global.data
+    , gconfKeys = getKeys(gconf)
+  if (gconfKeys.length) {
+    msg += "; globalconfig " + npm.config.get("globalconfig") + "\n"
+    gconfKeys.forEach(function (k) {
+      var val = (k.charAt(0) === "_")
+              ? "---sekretz---"
+              : JSON.stringify(gconf[k])
+      if (gconf[k] !== npm.config.get(k)) {
+        if (!long) return
+        msg += "; " + k + " = " + val
+            + " (overridden)\n"
+      } else msg += k + " = " + val + "\n"
+    })
+    msg += "\n"
+  }
+
+  // builtin config file
+  var builtin = npm.config.sources.builtin || {}
+  if (builtin && builtin.data) {
+    var bconf = builtin.data
+      , bpath = builtin.path
+      , bconfKeys = getKeys(bconf)
+    if (bconfKeys.length) {
+      var path = require("path")
+      msg += "; builtin config " + bpath + "\n"
+      bconfKeys.forEach(function (k) {
+        var val = (k.charAt(0) === "_")
+                ? "---sekretz---"
+                : JSON.stringify(bconf[k])
+        if (bconf[k] !== npm.config.get(k)) {
+          if (!long) return
+          msg += "; " + k + " = " + val
+              + " (overridden)\n"
+        } else msg += k + " = " + val + "\n"
+      })
+      msg += "\n"
+    }
+  }
+
+  // only show defaults if --long
+  if (!long) {
+    msg += "; node bin location = " + process.execPath + "\n"
+         + "; cwd = " + process.cwd() + "\n"
+         + "; HOME = " + process.env.HOME + "\n"
+         + "; 'npm config ls -l' to show all defaults.\n"
+
+    console.log(msg)
+    return cb()
+  }
+
+  var defaults = npmconf.defaults
+    , defKeys = getKeys(defaults)
+  msg += "; default values\n"
+  defKeys.forEach(function (k) {
+    if (defaults[k] && typeof defaults[k] === "object") return
+    var val = JSON.stringify(defaults[k])
+    if (defaults[k] !== npm.config.get(k)) {
+      msg += "; " + k + " = " + val
+          + " (overridden)\n"
+    } else msg += k + " = " + val + "\n"
+  })
+  msg += "\n"
+
+  console.log(msg)
+  return cb()
+}
+
+function unknown (action, cb) {
+  cb("Usage:\n" + config.usage)
+}