embeditor-rails 1.1.1 → 2.0.0.beta

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

@@ -0,0 +1,65 @@
+// npm pack <pkg>
+// Packs the specified package into a .tgz file, which can then
+// be installed.
+
+module.exports = pack
+
+var npm = require("./npm.js")
+  , install = require("./install.js")
+  , cache = require("./cache.js")
+  , fs = require("graceful-fs")
+  , chain = require("slide").chain
+  , path = require("path")
+  , cwd = process.cwd()
+
+pack.usage = "npm pack <pkg>"
+
+// if it can be installed, it can be packed.
+pack.completion = install.completion
+
+function pack (args, silent, cb) {
+  if (typeof cb !== "function") cb = silent, silent = false
+
+  if (args.length === 0) args = ["."]
+
+  chain(args.map(function (arg) { return function (cb) {
+    pack_(arg, cb)
+  }}), function (er, files) {
+    if (er || silent) return cb(er, files)
+    printFiles(files, cb)
+  })
+}
+
+function printFiles (files, cb) {
+  files = files.map(function (file) {
+    return path.relative(cwd, file)
+  })
+  console.log(files.join("\n"))
+  cb()
+}
+
+// add to cache, then cp to the cwd
+function pack_ (pkg, cb) {
+  cache.add(pkg, function (er, data) {
+    if (er) return cb(er)
+    var fname = path.resolve(data._id.replace(/@/g, "-") + ".tgz")
+      , cached = path.resolve( npm.cache
+                             , data.name
+                             , data.version
+                             , "package.tgz" )
+      , from = fs.createReadStream(cached)
+      , to = fs.createWriteStream(fname)
+      , errState = null
+
+    from.on("error", cb_)
+    to.on("error", cb_)
+    to.on("close", cb_)
+    from.pipe(to)
+
+    function cb_ (er) {
+      if (errState) return
+      if (er) return cb(errState = er)
+      cb(null, fname)
+    }
+  })
+}

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

@@ -0,0 +1,11 @@
+module.exports = prefix
+
+var npm = require("./npm.js")
+
+prefix.usage = "npm prefix\nnpm prefix -g\n(just prints the prefix folder)"
+
+function prefix (args, silent, cb) {
+  if (typeof cb !== "function") cb = silent, silent = false
+  if (!silent) console.log(npm.prefix)
+  process.nextTick(cb.bind(this, null, npm.prefix))
+}

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

@@ -0,0 +1,53 @@
+// prune extraneous packages.
+
+module.exports = prune
+
+prune.usage = "npm prune"
+
+var readInstalled = require("read-installed")
+  , npm = require("./npm.js")
+  , path = require("path")
+  , readJson = require("read-package-json")
+  , log = require("npmlog")
+
+prune.completion = require("./utils/completion/installed-deep.js")
+
+function prune (args, cb) {
+  //check if is a valid package.json file
+  var jsonFile = path.resolve(npm.dir, "..", "package.json" )
+  readJson(jsonFile, log.warn, function (er, data) {
+    if (er) return cb(er)
+    next()
+  })
+
+  function next() {
+    var opt = { depth: npm.config.get("depth"), dev: npm.config.get("production") }
+    readInstalled(npm.prefix, opt, function (er, data) {
+      if (er) return cb(er)
+      prune_(args, data, cb)
+    })
+  }
+}
+
+function prune_ (args, data, cb) {
+  npm.commands.unbuild(prunables(args, data, []), cb)
+}
+
+function prunables (args, data, seen) {
+  var deps = data.dependencies || {}
+  return Object.keys(deps).map(function (d) {
+    if (typeof deps[d] !== "object"
+        || seen.indexOf(deps[d]) !== -1) return null
+    seen.push(deps[d])
+    if (deps[d].extraneous
+        && (args.length === 0 || args.indexOf(d) !== -1)) {
+      var extra = deps[d]
+      delete deps[d]
+      return extra.path
+    }
+    return prunables(args, deps[d], seen)
+  }).filter(function (d) { return d !== null })
+  .reduce(function FLAT (l, r) {
+    return l.concat(Array.isArray(r) ? r.reduce(FLAT,[]) : r)
+  }, [])
+}

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

@@ -0,0 +1,118 @@
+
+module.exports = publish
+
+var npm = require("./npm.js")
+  , log = require("npmlog")
+  , tar = require("./utils/tar.js")
+  , path = require("path")
+  , readJson = require("read-package-json")
+  , fs = require("graceful-fs")
+  , lifecycle = require("./utils/lifecycle.js")
+  , chain = require("slide").chain
+  , Conf = require("npmconf").Conf
+  , RegClient = require("npm-registry-client")
+
+publish.usage = "npm publish <tarball>"
+              + "\nnpm publish <folder>"
+              + "\n\nPublishes '.' if no argument supplied"
+
+publish.completion = function (opts, cb) {
+  // publish can complete to a folder with a package.json
+  // or a tarball, or a tarball url.
+  // for now, not yet implemented.
+  return cb()
+}
+
+function publish (args, isRetry, cb) {
+  if (typeof cb !== "function") cb = isRetry, isRetry = false
+  if (args.length === 0) args = ["."]
+  if (args.length !== 1) return cb(publish.usage)
+
+  log.verbose("publish", args)
+  var arg = args[0]
+  // if it's a local folder, then run the prepublish there, first.
+  readJson(path.resolve(arg, "package.json"), function (er, data) {
+    er = needVersion(er, data)
+    if (er && er.code !== "ENOENT" && er.code !== "ENOTDIR") return cb(er)
+    // error is ok.  could be publishing a url or tarball
+    // however, that means that we will not have automatically run
+    // the prepublish script, since that gets run when adding a folder
+    // to the cache.
+    if (er) return cacheAddPublish(arg, false, isRetry, cb)
+    cacheAddPublish(arg, true, isRetry, cb)
+  })
+}
+
+// didPre in this case means that we already ran the prepublish script,
+// and that the "dir" is an actual directory, and not something silly
+// like a tarball or name@version thing.
+// That means that we can run publish/postpublish in the dir, rather than
+// in the cache dir.
+function cacheAddPublish (dir, didPre, isRetry, cb) {
+  npm.commands.cache.add(dir, function (er, data) {
+    if (er) return cb(er)
+    log.silly("publish", data)
+    var cachedir = path.resolve( npm.cache
+                               , data.name
+                               , data.version
+                               , "package" )
+    chain
+      ( [ !didPre && [lifecycle, data, "prepublish", cachedir]
+        , [publish_, dir, data, isRetry, cachedir]
+        , [lifecycle, data, "publish", didPre ? dir : cachedir]
+        , [lifecycle, data, "postpublish", didPre ? dir : cachedir] ]
+      , cb )
+  })
+}
+
+function publish_ (arg, data, isRetry, cachedir, cb) {
+  if (!data) return cb(new Error("no package.json file found"))
+
+  // check for publishConfig hash
+  var registry = npm.registry
+  if (data.publishConfig) {
+    var pubConf = new Conf(npm.config)
+    pubConf.save = npm.config.save.bind(npm.config)
+
+    // don't modify the actual publishConfig object, in case we have
+    // to set a login token or some other data.
+    pubConf.unshift(Object.keys(data.publishConfig).reduce(function (s, k) {
+      s[k] = data.publishConfig[k]
+      return s
+    }, {}))
+    registry = new RegClient(pubConf)
+  }
+
+  data._npmVersion = npm.version
+  data._npmUser = { name: npm.config.get("username")
+                  , email: npm.config.get("email") }
+
+  delete data.modules
+  if (data.private) return cb(new Error
+    ("This package has been marked as private\n"
+    +"Remove the 'private' field from the package.json to publish it."))
+
+  var tarball = cachedir + ".tgz"
+  registry.publish(data, tarball, function (er) {
+    if (er && er.code === "EPUBLISHCONFLICT"
+        && npm.config.get("force") && !isRetry) {
+      log.warn("publish", "Forced publish over "+data._id)
+      return npm.commands.unpublish([data._id], function (er) {
+        // ignore errors.  Use the force.  Reach out with your feelings.
+        // but if it fails again, then report the first error.
+        publish([arg], er || true, cb)
+      })
+    }
+    // report the unpublish error if this was a retry and unpublish failed
+    if (er && isRetry && isRetry !== true) return cb(isRetry)
+    if (er) return cb(er)
+    console.log("+ " + data._id)
+    cb()
+  })
+}
+
+function needVersion(er, data) {
+  return er ? er
+       : (data && !data.version) ? new Error("No version provided")
+       : null
+}

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

@@ -0,0 +1,75 @@
+
+module.exports = rebuild
+
+var readInstalled = require("read-installed")
+  , semver = require("semver")
+  , log = require("npmlog")
+  , path = require("path")
+  , npm = require("./npm.js")
+  , asyncMap = require("slide").asyncMap
+  , fs = require("graceful-fs")
+
+rebuild.usage = "npm rebuild [<name>[@<version>] [name[@<version>] ...]]"
+
+rebuild.completion = require("./utils/completion/installed-deep.js")
+
+function rebuild (args, cb) {
+  var opt = { depth: npm.config.get("depth") }
+  readInstalled(npm.prefix, opt, function (er, data) {
+    log.info("readInstalled", typeof data)
+    if (er) return cb(er)
+    var set = filter(data, args)
+      , folders = Object.keys(set).filter(function (f) {
+          return f !== npm.prefix
+        })
+    if (!folders.length) return cb()
+    log.silly("rebuild set", folders)
+    cleanBuild(folders, set, cb)
+  })
+}
+
+function cleanBuild (folders, set, cb) {
+  npm.commands.build(folders, function (er) {
+    if (er) return cb(er)
+    console.log(folders.map(function (f) {
+      return set[f] + " " + f
+    }).join("\n"))
+    cb()
+  })
+}
+
+function filter (data, args, set, seen) {
+  if (!set) set = {}
+  if (!seen) seen = {}
+  if (set.hasOwnProperty(data.path)) return set
+  if (seen.hasOwnProperty(data.path)) return set
+  seen[data.path] = true
+  var pass
+  if (!args.length) pass = true // rebuild everything
+  else if (data.name && data._id) {
+    for (var i = 0, l = args.length; i < l; i ++) {
+      var arg = args[i]
+        , nv = arg.split("@")
+        , n = nv.shift()
+        , v = nv.join("@")
+      if (n !== data.name) continue
+      if (!semver.satisfies(data.version, v, true)) continue
+      pass = true
+      break
+    }
+  }
+  if (pass && data._id) {
+    log.verbose("rebuild", "path, id", [data.path, data._id])
+    set[data.path] = data._id
+  }
+  // need to also dive through kids, always.
+  // since this isn't an install these won't get auto-built unless
+  // they're not dependencies.
+  Object.keys(data.dependencies || {}).forEach(function (d) {
+    // return
+    var dep = data.dependencies[d]
+    if (typeof dep === "string") return
+    filter(dep, args, set, seen)
+  })
+  return set
+}

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

@@ -0,0 +1,54 @@
+
+module.exports = repo
+
+repo.usage = "npm repo <pkgname>"
+
+repo.completion = function (opts, cb) {
+  if (opts.conf.argv.remain.length > 2) return cb()
+  registry.get("/-/short", 60000, function (er, list) {
+    return cb(null, list || [])
+  })
+}
+
+var npm = require("./npm.js")
+  , registry = npm.registry
+  , log = require("npmlog")
+  , opener = require("opener")
+  , github = require('github-url-from-git')
+  , githubUserRepo = require("github-url-from-username-repo")
+  , path = require("path")
+  , readJson = require("read-package-json")
+  , fs = require("fs")
+
+function repo (args, cb) {
+  var n = args.length && args[0].split("@").shift() || '.'
+  fs.stat(n, function (er, s) {
+    if (er && er.code === "ENOENT") return callRegistry(n, cb)
+    else if (er) return cb(er)
+    if (!s.isDirectory()) return callRegistry(n, cb)
+    readJson(path.resolve(n, "package.json"), function (er, d) {
+      if (er) return cb(er)
+      getUrlAndOpen(d, cb)
+    })
+  })
+}
+
+function getUrlAndOpen (d, cb) {
+  var r = d.repository;
+  if (!r) return cb(new Error('no repository'));
+  // XXX remove this when npm@v1.3.10 from node 0.10 is deprecated
+  // from https://github.com/npm/npm-www/issues/418
+  if (githubUserRepo(r.url))
+    r.url = githubUserRepo(r.url)
+  var url = github(r.url)
+  if (!url)
+    return cb(new Error('no repository: could not get url'))
+  opener(url, { command: npm.config.get("browser") }, cb)
+}
+
+function callRegistry (n, cb) {
+  registry.get(n + "/latest", 3600, function (er, d) {
+    if (er) return cb(er)
+    getUrlAndOpen(d, cb)
+  })
+}

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

@@ -0,0 +1 @@
+module.exports = require("./utils/lifecycle.js").cmd("restart")

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

@@ -0,0 +1,11 @@
+module.exports = root
+
+var npm = require("./npm.js")
+
+root.usage = "npm root\nnpm root -g\n(just prints the root folder)"
+
+function root (args, silent, cb) {
+  if (typeof cb !== "function") cb = silent, silent = false
+  if (!silent) console.log(npm.dir)
+  process.nextTick(cb.bind(this, null, npm.dir))
+}

data/lib/node_modules/npm/lib/run-script.js

@@ -0,0 +1,102 @@
+
+module.exports = runScript
+
+var lifecycle = require("./utils/lifecycle.js")
+  , npm = require("./npm.js")
+  , path = require("path")
+  , readJson = require("read-package-json")
+  , log = require("npmlog")
+  , chain = require("slide").chain
+  , fs = require("graceful-fs")
+  , asyncMap = require("slide").asyncMap
+
+runScript.usage = "npm run-script [<pkg>] <command>"
+
+runScript.completion = function (opts, cb) {
+
+  // see if there's already a package specified.
+  var argv = opts.conf.argv.remain
+    , installedShallow = require("./utils/completion/installed-shallow.js")
+
+  if (argv.length >= 4) return cb()
+
+  if (argv.length === 3) {
+    // either specified a script locally, in which case, done,
+    // or a package, in which case, complete against its scripts
+    var json = path.join(npm.prefix, "package.json")
+    return readJson(json, function (er, d) {
+      if (er && er.code !== "ENOENT" && er.code !== "ENOTDIR") return cb(er)
+      if (er) d = {}
+      var scripts = Object.keys(d.scripts || {})
+      console.error("local scripts", scripts)
+      if (scripts.indexOf(argv[2]) !== -1) return cb()
+      // ok, try to find out which package it was, then
+      var pref = npm.config.get("global") ? npm.config.get("prefix")
+               : npm.prefix
+      var pkgDir = path.resolve( pref, "node_modules"
+                               , argv[2], "package.json" )
+      readJson(pkgDir, function (er, d) {
+        if (er && er.code !== "ENOENT" && er.code !== "ENOTDIR") return cb(er)
+        if (er) d = {}
+        var scripts = Object.keys(d.scripts || {})
+        return cb(null, scripts)
+      })
+    })
+  }
+
+  // complete against the installed-shallow, and the pwd's scripts.
+  // but only packages that have scripts
+  var installed
+    , scripts
+  installedShallow(opts, function (d) {
+    return d.scripts
+  }, function (er, inst) {
+    installed = inst
+    next()
+  })
+
+  if (npm.config.get("global")) scripts = [], next()
+  else readJson(path.join(npm.prefix, "package.json"), function (er, d) {
+    if (er && er.code !== "ENOENT" && er.code !== "ENOTDIR") return cb(er)
+    d = d || {}
+    scripts = Object.keys(d.scripts || {})
+    next()
+  })
+
+  function next () {
+    if (!installed || !scripts) return
+    return cb(null, scripts.concat(installed))
+  }
+}
+
+function runScript (args, cb) {
+  if (!args.length) return cb(runScript.usage)
+  var pkgdir = args.length === 1 ? process.cwd()
+             : path.resolve(npm.dir, args[0])
+    , cmd = args.pop()
+
+  readJson(path.resolve(pkgdir, "package.json"), function (er, d) {
+    if (er) return cb(er)
+    run(d, pkgdir, cmd, cb)
+  })
+}
+
+function run (pkg, wd, cmd, cb) {
+  var cmds = []
+  if (!pkg.scripts) pkg.scripts = {}
+  if (cmd === "restart") {
+    cmds = ["prestop","stop","poststop"
+           ,"restart"
+           ,"prestart","start","poststart"]
+  } else {
+    cmds = [cmd]
+  }
+  if (!cmd.match(/^(pre|post)/)) {
+    cmds = ["pre"+cmd].concat(cmds).concat("post"+cmd)
+  }
+  log.verbose("run-script", cmds)
+  chain(cmds.map(function (c) {
+    // when running scripts explicitly, assume that they're trusted.
+    return [lifecycle, pkg, c, wd, true]
+  }), cb)
+}