embeditor-rails 1.1.1 → 2.0.0.beta

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

@@ -0,0 +1,173 @@
+// link with no args: symlink the folder to the global location
+// link with package arg: symlink the global to the local
+
+var npm = require("./npm.js")
+  , symlink = require("./utils/link.js")
+  , fs = require("graceful-fs")
+  , log = require("npmlog")
+  , asyncMap = require("slide").asyncMap
+  , chain = require("slide").chain
+  , path = require("path")
+  , rm = require("./utils/gently-rm.js")
+  , build = require("./build.js")
+
+module.exports = link
+
+link.usage = "npm link (in package dir)"
+           + "\nnpm link <pkg> (link global into local)"
+
+link.completion = function (opts, cb) {
+  var dir = npm.globalDir
+  fs.readdir(dir, function (er, files) {
+    cb(er, files.filter(function (f) {
+      return !f.match(/^[\._-]/)
+    }))
+  })
+}
+
+function link (args, cb) {
+  if (process.platform === "win32") {
+    var semver = require("semver")
+    if (!semver.satisfies(process.version, ">=0.7.9")) {
+      var msg = "npm link not supported on windows prior to node 0.7.9"
+        , e = new Error(msg)
+      e.code = "ENOTSUP"
+      e.errno = require("constants").ENOTSUP
+      return cb(e)
+    }
+  }
+
+  if (npm.config.get("global")) {
+    return cb(new Error("link should never be --global.\n"
+                       +"Please re-run this command with --local"))
+  }
+
+  if (args.length === 1 && args[0] === ".") args = []
+  if (args.length) return linkInstall(args, cb)
+  linkPkg(npm.prefix, cb)
+}
+
+function linkInstall (pkgs, cb) {
+  asyncMap(pkgs, function (pkg, cb) {
+    function n (er, data) {
+      if (er) return cb(er, data)
+      // install returns [ [folder, pkgId], ... ]
+      // but we definitely installed just one thing.
+      var d = data.filter(function (d) { return !d[3] })
+      pp = d[0][1]
+      pkg = path.basename(pp)
+      target = path.resolve(npm.dir, pkg)
+      next()
+    }
+
+    var t = path.resolve(npm.globalDir, "..")
+      , pp = path.resolve(npm.globalDir, pkg)
+      , rp = null
+      , target = path.resolve(npm.dir, pkg)
+
+    // if it's a folder or a random not-installed thing, then
+    // link or install it first
+    if (pkg.indexOf("/") !== -1 || pkg.indexOf("\\") !== -1) {
+      return fs.lstat(path.resolve(pkg), function (er, st) {
+        if (er || !st.isDirectory()) {
+          npm.commands.install(t, pkg, n)
+        } else {
+          rp = path.resolve(pkg)
+          linkPkg(rp, n)
+        }
+      })
+    }
+
+    fs.lstat(pp, function (er, st) {
+      if (er) {
+        rp = pp
+        return npm.commands.install(t, pkg, n)
+      } else if (!st.isSymbolicLink()) {
+        rp = pp
+        next()
+      } else {
+        return fs.realpath(pp, function (er, real) {
+          if (er) log.warn("invalid symbolic link", pkg)
+          else rp = real
+          next()
+        })
+      }
+    })
+
+    function next () {
+      chain
+        ( [ [npm.commands, "unbuild", [target]]
+          , [function (cb) {
+              log.verbose("link", "symlinking %s to %s",  pp, target)
+              cb()
+            }]
+          , [symlink, pp, target]
+          // do run lifecycle scripts - full build here.
+          , rp && [build, [target]]
+          , [ resultPrinter, pkg, pp, target, rp ] ]
+        , cb )
+    }
+  }, cb)
+}
+
+function linkPkg (folder, cb_) {
+  var me = folder || npm.prefix
+    , readJson = require("read-package-json")
+
+  log.verbose("linkPkg", folder)
+
+  readJson(path.resolve(me, "package.json"), function (er, d) {
+    function cb (er) {
+      return cb_(er, [[d && d._id, target, null, null]])
+    }
+    if (er) return cb(er)
+    if (!d.name) {
+      er = new Error("Package must have a name field to be linked")
+      return cb(er)
+    }
+    var target = path.resolve(npm.globalDir, d.name)
+    rm(target, function (er) {
+      if (er) return cb(er)
+      symlink(me, target, function (er) {
+        if (er) return cb(er)
+        log.verbose("link", "build target", target)
+        // also install missing dependencies.
+        npm.commands.install(me, [], function (er, installed) {
+          if (er) return cb(er)
+          // build the global stuff.  Don't run *any* scripts, because
+          // install command already will have done that.
+          build([target], true, build._noLC, true, function (er) {
+            if (er) return cb(er)
+            resultPrinter(path.basename(me), me, target, cb)
+          })
+        })
+      })
+    })
+  })
+}
+
+function resultPrinter (pkg, src, dest, rp, cb) {
+  if (typeof cb !== "function") cb = rp, rp = null
+  var where = dest
+  rp = (rp || "").trim()
+  src = (src || "").trim()
+  // XXX If --json is set, then look up the data from the package.json
+  if (npm.config.get("parseable")) {
+    return parseableOutput(dest, rp || src, cb)
+  }
+  if (rp === src) rp = null
+  console.log(where + " -> " + src + (rp ? " -> " + rp: ""))
+  cb()
+}
+
+function parseableOutput (dest, rp, cb) {
+  // XXX this should match ls --parseable and install --parseable
+  // look up the data from package.json, format it the same way.
+  //
+  // link is always effectively "long", since it doesn't help much to
+  // *just* print the target folder.
+  // However, we don't actually ever read the version number, so
+  // the second field is always blank.
+  console.log(dest + "::" + rp)
+  cb()
+}

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

@@ -0,0 +1,357 @@
+
+// show the installed versions of packages
+//
+// --parseable creates output like this:
+// <fullpath>:<name@ver>:<realpath>:<flags>
+// Flags are a :-separated list of zero or more indicators
+
+module.exports = exports = ls
+
+var npm = require("./npm.js")
+  , readInstalled = require("read-installed")
+  , log = require("npmlog")
+  , path = require("path")
+  , archy = require("archy")
+  , semver = require("semver")
+  , url = require("url")
+  , isGitUrl = require("./utils/is-git-url.js")
+
+ls.usage = "npm ls"
+
+ls.completion = require("./utils/completion/installed-deep.js")
+
+function ls (args, silent, cb) {
+  if (typeof cb !== "function") cb = silent, silent = false
+
+  var dir = path.resolve(npm.dir, "..")
+
+  // npm ls 'foo@~1.3' bar 'baz@<2'
+  if (!args) args = []
+  else args = args.map(function (a) {
+    var nv = a.split("@")
+      , name = nv.shift()
+      , ver = semver.validRange(nv.join("@")) || ""
+
+    return [ name, ver ]
+  })
+
+  var depth = npm.config.get("depth")
+  var opt = { depth: depth, log: log.warn }
+  readInstalled(dir, opt, function (er, data) {
+    var bfs = bfsify(data, args)
+      , lite = getLite(bfs)
+
+    if (er || silent) return cb(er, data, lite)
+
+    var long = npm.config.get("long")
+      , json = npm.config.get("json")
+      , out
+    if (json) {
+      var seen = []
+      var d = long ? bfs : lite
+      // the raw data can be circular
+      out = JSON.stringify(d, function (k, o) {
+        if (typeof o === "object") {
+          if (-1 !== seen.indexOf(o)) return "[Circular]"
+          seen.push(o)
+        }
+        return o
+      }, 2)
+    } else if (npm.config.get("parseable")) {
+      out = makeParseable(bfs, long, dir)
+    } else if (data) {
+      out = makeArchy(bfs, long, dir)
+    }
+    console.log(out)
+
+    if (args.length && !data._found) process.exitCode = 1
+
+    // if any errors were found, then complain and exit status 1
+    if (lite.problems && lite.problems.length) {
+      er = lite.problems.join('\n')
+    }
+    cb(er, data, lite)
+  })
+}
+
+// only include
+function filter (data, args) {
+
+}
+
+function alphasort (a, b) {
+  a = a.toLowerCase()
+  b = b.toLowerCase()
+  return a > b ? 1
+       : a < b ? -1 : 0
+}
+
+function getLite (data, noname) {
+  var lite = {}
+    , maxDepth = npm.config.get("depth")
+
+  if (!noname && data.name) lite.name = data.name
+  if (data.version) lite.version = data.version
+  if (data.extraneous) {
+    lite.extraneous = true
+    lite.problems = lite.problems || []
+    lite.problems.push( "extraneous: "
+                      + data.name + "@" + data.version
+                      + " " + (data.path || "") )
+  }
+
+  if (data._from)
+    lite.from = data._from
+
+  if (data._resolved)
+    lite.resolved = data._resolved
+
+  if (data.invalid) {
+    lite.invalid = true
+    lite.problems = lite.problems || []
+    lite.problems.push( "invalid: "
+                      + data.name + "@" + data.version
+                      + " " + (data.path || "") )
+  }
+
+  if (data.peerInvalid) {
+    lite.peerInvalid = true
+    lite.problems = lite.problems || []
+    lite.problems.push( "peer invalid: "
+                      + data.name + "@" + data.version
+                      + " " + (data.path || "") )
+  }
+
+  if (data.dependencies) {
+    var deps = Object.keys(data.dependencies)
+    if (deps.length) lite.dependencies = deps.map(function (d) {
+      var dep = data.dependencies[d]
+      if (typeof dep === "string") {
+        lite.problems = lite.problems || []
+        var p
+        if (data.depth >= maxDepth) {
+          p = "max depth reached: "
+        } else {
+          p = "missing: "
+        }
+        p += d + "@" + dep
+          + ", required by "
+          + data.name + "@" + data.version
+        lite.problems.push(p)
+        return [d, { required: dep, missing: true }]
+      }
+      return [d, getLite(dep, true)]
+    }).reduce(function (deps, d) {
+      if (d[1].problems) {
+        lite.problems = lite.problems || []
+        lite.problems.push.apply(lite.problems, d[1].problems)
+      }
+      deps[d[0]] = d[1]
+      return deps
+    }, {})
+  }
+  return lite
+}
+
+function bfsify (root, args, current, queue, seen) {
+  // walk over the data, and turn it from this:
+  // +-- a
+  // |   `-- b
+  // |       `-- a (truncated)
+  // `--b (truncated)
+  // into this:
+  // +-- a
+  // `-- b
+  // which looks nicer
+  args = args || []
+  current = current || root
+  queue = queue || []
+  seen = seen || [root]
+  var deps = current.dependencies = current.dependencies || {}
+  Object.keys(deps).forEach(function (d) {
+    var dep = deps[d]
+    if (typeof dep !== "object") return
+    if (seen.indexOf(dep) !== -1) {
+      if (npm.config.get("parseable") || !npm.config.get("long")) {
+        delete deps[d]
+        return
+      } else {
+        dep = deps[d] = Object.create(dep)
+        dep.dependencies = {}
+      }
+    }
+    queue.push(dep)
+    seen.push(dep)
+  })
+
+  if (!queue.length) {
+    // if there were args, then only show the paths to found nodes.
+    return filterFound(root, args)
+  }
+  return bfsify(root, args, queue.shift(), queue, seen)
+}
+
+function filterFound (root, args) {
+  if (!args.length) return root
+  var deps = root.dependencies
+  if (deps) Object.keys(deps).forEach(function (d) {
+    var dep = filterFound(deps[d], args)
+
+    // see if this one itself matches
+    var found = false
+    for (var i = 0; !found && i < args.length; i ++) {
+      if (d === args[i][0]) {
+        found = semver.satisfies(dep.version, args[i][1], true)
+      }
+    }
+    // included explicitly
+    if (found) dep._found = true
+    // included because a child was included
+    if (dep._found && !root._found) root._found = 1
+    // not included
+    if (!dep._found) delete deps[d]
+  })
+  if (!root._found) root._found = false
+  return root
+}
+
+function makeArchy (data, long, dir) {
+  var out = makeArchy_(data, long, dir, 0)
+  return archy(out, "", { unicode: npm.config.get("unicode") })
+}
+
+function makeArchy_ (data, long, dir, depth, parent, d) {
+  var color = npm.color
+  if (typeof data === "string") {
+    if (depth < npm.config.get("depth")) {
+      // just missing
+      var p = parent.link || parent.path
+      var unmet = "UNMET DEPENDENCY"
+      if (color) {
+        unmet = "\033[31;40m" + unmet + "\033[0m"
+      }
+      data = unmet + " " + d + " " + data
+    } else {
+      data = d+"@"+ data
+    }
+    return data
+  }
+
+  var out = {}
+  // the top level is a bit special.
+  out.label = data._id || ""
+  if (data._found === true && data._id) {
+    var pre = color ? "\033[33;40m" : ""
+      , post = color ? "\033[m" : ""
+    out.label = pre + out.label.trim() + post + " "
+  }
+  if (data.link) out.label += " -> " + data.link
+
+  if (data.invalid) {
+    if (data.realName !== data.name) out.label += " ("+data.realName+")"
+    out.label += " " + (color ? "\033[31;40m" : "")
+              + "invalid"
+              + (color ? "\033[0m" : "")
+  }
+
+  if (data.peerInvalid) {
+    out.label += " " + (color ? "\033[31;40m" : "")
+              + "peer invalid"
+              + (color ? "\033[0m" : "")
+  }
+
+  if (data.extraneous && data.path !== dir) {
+    out.label += " " + (color ? "\033[32;40m" : "")
+              + "extraneous"
+              + (color ? "\033[0m" : "")
+  }
+
+  // add giturl to name@version
+  if (data._resolved) {
+    var p = url.parse(data._resolved)
+    if (isGitUrl(p))
+      out.label += " (" + data._resolved + ")"
+  }
+
+  if (long) {
+    if (dir === data.path) out.label += "\n" + dir
+    out.label += "\n" + getExtras(data, dir)
+  } else if (dir === data.path) {
+    if (out.label) out.label += " "
+    out.label += dir
+  }
+
+  // now all the children.
+  out.nodes = Object.keys(data.dependencies || {})
+    .sort(alphasort).map(function (d) {
+      return makeArchy_(data.dependencies[d], long, dir, depth + 1, data, d)
+    })
+
+  if (out.nodes.length === 0 && data.path === dir) {
+    out.nodes = ["(empty)"]
+  }
+
+  return out
+}
+
+function getExtras (data, dir) {
+  var extras = []
+
+  if (data.description) extras.push(data.description)
+  if (data.repository) extras.push(data.repository.url)
+  if (data.homepage) extras.push(data.homepage)
+  if (data._from) {
+    var from = data._from
+    if (from.indexOf(data.name + "@") === 0) {
+      from = from.substr(data.name.length + 1)
+    }
+    var u = url.parse(from)
+    if (u.protocol) extras.push(from)
+  }
+  return extras.join("\n")
+}
+
+
+function makeParseable (data, long, dir, depth, parent, d) {
+  depth = depth || 0
+
+  return [ makeParseable_(data, long, dir, depth, parent, d) ]
+  .concat(Object.keys(data.dependencies || {})
+    .sort(alphasort).map(function (d) {
+      return makeParseable(data.dependencies[d], long, dir, depth + 1, data, d)
+    }))
+  .filter(function (x) { return x })
+  .join("\n")
+}
+
+function makeParseable_ (data, long, dir, depth, parent, d) {
+  if (data.hasOwnProperty("_found") && data._found !== true) return ""
+
+  if (typeof data === "string") {
+    if (data.depth < npm.config.get("depth")) {
+      var p = parent.link || parent.path
+      data = npm.config.get("long")
+           ? path.resolve(parent.path, "node_modules", d)
+           + ":"+d+"@"+JSON.stringify(data)+":INVALID:MISSING"
+           : ""
+    } else {
+      data = path.resolve(data.path || "", "node_modules", d || "")
+           + (npm.config.get("long")
+             ? ":" + d + "@" + JSON.stringify(data)
+             + ":" // no realpath resolved
+             + ":MAXDEPTH"
+             : "")
+    }
+
+    return data
+  }
+
+  if (!npm.config.get("long")) return data.path
+
+  return data.path
+       + ":" + (data._id || "")
+       + ":" + (data.realPath !== data.path ? data.realPath : "")
+       + (data.extraneous ? ":EXTRANEOUS" : "")
+       + (data.invalid ? ":INVALID" : "")
+       + (data.peerInvalid ? ":PEERINVALID" : "")
+}