node/deps/npm/lib/completion.js

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)
}