embeditor-rails 1.1.1 → 2.0.0.beta

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

@@ -0,0 +1,265 @@
+
+module.exports = exports = search
+
+var npm = require("./npm.js")
+  , registry = npm.registry
+  , columnify = require('columnify')
+
+search.usage = "npm search [some search terms ...]"
+
+search.completion = function (opts, cb) {
+  var compl = {}
+    , partial = opts.partialWord
+    , ipartial = partial.toLowerCase()
+    , plen = partial.length
+
+  // get the batch of data that matches so far.
+  // this is an example of using npm.commands.search programmatically
+  // to fetch data that has been filtered by a set of arguments.
+  search(opts.conf.argv.remain.slice(2), true, function (er, data) {
+    if (er) return cb(er)
+    Object.keys(data).forEach(function (name) {
+      data[name].words.split(" ").forEach(function (w) {
+        if (w.toLowerCase().indexOf(ipartial) === 0) {
+          compl[partial + w.substr(plen)] = true
+        }
+      })
+    })
+    cb(null, Object.keys(compl))
+  })
+}
+
+function search (args, silent, staleness, cb) {
+  if (typeof cb !== "function") cb = staleness, staleness = 600
+  if (typeof cb !== "function") cb = silent, silent = false
+
+  var searchopts = npm.config.get("searchopts")
+    , searchexclude = npm.config.get("searchexclude")
+  if (typeof searchopts !== "string") searchopts = ""
+  searchopts = searchopts.split(/\s+/)
+  if (typeof searchexclude === "string") {
+    searchexclude = searchexclude.split(/\s+/)
+  } else searchexclude = []
+  var opts = searchopts.concat(args).map(function (s) {
+    return s.toLowerCase()
+  }).filter(function (s) { return s })
+  searchexclude = searchexclude.map(function (s) {
+    return s.toLowerCase()
+  })
+  getFilteredData( staleness, opts, searchexclude, function (er, data) {
+    // now data is the list of data that we want to show.
+    // prettify and print it, and then provide the raw
+    // data to the cb.
+    if (er || silent) return cb(er, data)
+    console.log(prettify(data, args))
+    cb(null, data)
+  })
+}
+
+function getFilteredData (staleness, args, notArgs, cb) {
+  registry.get( "/-/all", staleness, false
+              , true, function (er, data) {
+    if (er) return cb(er)
+    return cb(null, filter(data, args, notArgs))
+  })
+}
+
+function filter (data, args, notArgs) {
+  // data={<name>:{package data}}
+  return Object.keys(data).map(function (d) {
+    return data[d]
+  }).filter(function (d) {
+    return typeof d === "object"
+  }).map(stripData).map(getWords).filter(function (data) {
+    return filterWords(data, args, notArgs)
+  }).reduce(function (l, r) {
+    l[r.name] = r
+    return l
+  }, {})
+}
+
+function stripData (data) {
+  return { name: data.name
+         , description: npm.config.get("description") ? data.description : ""
+         , maintainers: (data.maintainers || []).map(function (m) {
+             return "=" + m.name
+           })
+         , url: !Object.keys(data.versions || {}).length ? data.url : null
+         , keywords: data.keywords || []
+         , version: Object.keys(data.versions || {})[0] || []
+         , time: data.time
+                 && data.time.modified
+                 && (new Date(data.time.modified).toISOString()
+                     .split("T").join(" ")
+                     .replace(/:[0-9]{2}\.[0-9]{3}Z$/, ""))
+                     .slice(0, -5) // remove time
+                 || "prehistoric"
+         }
+}
+
+function getWords (data) {
+  data.words = [ data.name ]
+               .concat(data.description)
+               .concat(data.maintainers)
+               .concat(data.url && ("<" + data.url + ">"))
+               .concat(data.keywords)
+               .map(function (f) { return f && f.trim && f.trim() })
+               .filter(function (f) { return f })
+               .join(" ")
+               .toLowerCase()
+  return data
+}
+
+function filterWords (data, args, notArgs) {
+  var words = data.words
+  for (var i = 0, l = args.length; i < l; i ++) {
+    if (!match(words, args[i])) return false
+  }
+  for (var i = 0, l = notArgs.length; i < l; i ++) {
+    if (match(words, notArgs[i])) return false
+  }
+  return true
+}
+
+function match (words, arg) {
+  if (arg.charAt(0) === "/") {
+    arg = arg.replace(/\/$/, "")
+    arg = new RegExp(arg.substr(1, arg.length - 1))
+    return words.match(arg)
+  }
+  return words.indexOf(arg) !== -1
+}
+
+function prettify (data, args) {
+  var searchsort = (npm.config.get("searchsort") || "NAME").toLowerCase()
+    , sortField = searchsort.replace(/^\-+/, "")
+    , searchRev = searchsort.charAt(0) === "-"
+    , truncate = !npm.config.get("long")
+
+  if (Object.keys(data).length === 0) {
+    return "No match found for "+(args.map(JSON.stringify).join(" "))
+  }
+
+  var lines = Object.keys(data).map(function (d) {
+    // strip keyname
+    return data[d]
+  }).map(function(dat) {
+    dat.author = dat.maintainers
+    delete dat.maintainers
+    dat.date = dat.time
+    delete dat.time
+    return dat
+  }).map(function(dat) {
+    // split keywords on whitespace or ,
+    if (typeof dat.keywords === "string") {
+      dat.keywords = dat.keywords.split(/[,\s]+/)
+    }
+    if (Array.isArray(dat.keywords)) {
+      dat.keywords = dat.keywords.join(' ')
+    }
+
+    // split author on whitespace or ,
+    if (typeof dat.author === "string") {
+      dat.author = dat.author.split(/[,\s]+/)
+    }
+    if (Array.isArray(dat.author)) {
+      dat.author = dat.author.join(' ')
+    }
+    return dat
+  })
+
+  lines.sort(function(a, b) {
+    var aa = a[sortField].toLowerCase()
+      , bb = b[sortField].toLowerCase()
+    return aa === bb ? 0
+         : aa < bb ? -1 : 1
+  })
+
+  if (searchRev) lines.reverse()
+
+  var columns = npm.config.get("description")
+               ? ["name", "description", "author", "date", "version", "keywords"]
+               : ["name", "author", "date", "version", "keywords"]
+
+  var output = columnify(lines, {
+        include: columns
+      , truncate: truncate
+      , config: {
+          name: { maxWidth: 40, truncate: false, truncateMarker: '' }
+        , description: { maxWidth: 60 }
+        , author: { maxWidth: 20 }
+        , date: { maxWidth: 11 }
+        , version: { maxWidth: 11 }
+        , keywords: { maxWidth: Infinity }
+      }
+  })
+  output = trimToMaxWidth(output)
+  output = highlightSearchTerms(output, args)
+
+  return output
+}
+
+var colors = [31, 33, 32, 36, 34, 35 ]
+  , cl = colors.length
+
+function addColorMarker (str, arg, i) {
+  var m = i % cl + 1
+    , markStart = String.fromCharCode(m)
+    , markEnd = String.fromCharCode(0)
+
+  if (arg.charAt(0) === "/") {
+    //arg = arg.replace(/\/$/, "")
+    return str.replace( new RegExp(arg.substr(1, arg.length - 1), "gi")
+                      , function (bit) { return markStart + bit + markEnd } )
+
+  }
+
+  // just a normal string, do the split/map thing
+  var pieces = str.toLowerCase().split(arg.toLowerCase())
+    , p = 0
+
+  return pieces.map(function (piece, i) {
+    piece = str.substr(p, piece.length)
+    var mark = markStart
+             + str.substr(p+piece.length, arg.length)
+             + markEnd
+    p += piece.length + arg.length
+    return piece + mark
+  }).join("")
+}
+
+function colorize (line) {
+  for (var i = 0; i < cl; i ++) {
+    var m = i + 1
+    var color = npm.color ? "\033["+colors[i]+"m" : ""
+    line = line.split(String.fromCharCode(m)).join(color)
+  }
+  var uncolor = npm.color ? "\033[0m" : ""
+  return line.split("\u0000").join(uncolor)
+}
+
+function getMaxWidth() {
+  try {
+    var tty = require("tty")
+      , stdout = process.stdout
+      , cols = !tty.isatty(stdout.fd) ? Infinity
+             : process.stdout.getWindowSize()[0]
+      cols = (cols == 0) ? Infinity : cols
+  } catch (ex) { cols = Infinity }
+  return cols
+}
+
+function trimToMaxWidth(str) {
+  var maxWidth = getMaxWidth()
+  return str.split('\n').map(function(line) {
+    return line.slice(0, maxWidth)
+  }).join('\n')
+}
+
+function highlightSearchTerms(str, terms) {
+  terms.forEach(function (arg, i) {
+    str = addColorMarker(str, arg, i)
+  })
+
+  return colorize(str).trim()
+}

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

@@ -0,0 +1,13 @@
+
+module.exports = set
+
+set.usage = "npm set <key> <value> (See `npm config`)"
+
+var npm = require("./npm.js")
+
+set.completion = npm.commands.config.completion
+
+function set (args, cb) {
+  if (!args.length) return cb(set.usage)
+  npm.commands.config(["set"].concat(args), cb)
+}

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

@@ -0,0 +1,86 @@
+// emit JSON describing versions of all packages currently installed (for later
+// use with shrinkwrap install)
+
+module.exports = exports = shrinkwrap
+
+var npm = require("./npm.js")
+  , log = require("npmlog")
+  , fs = require("fs")
+  , path = require("path")
+  , readJson = require("read-package-json")
+
+shrinkwrap.usage = "npm shrinkwrap"
+
+function shrinkwrap (args, silent, cb) {
+  if (typeof cb !== "function") cb = silent, silent = false
+
+  if (args.length) {
+    log.warn("shrinkwrap", "doesn't take positional args")
+  }
+
+  npm.commands.ls([], true, function (er, _, pkginfo) {
+    if (er) return cb(er)
+    shrinkwrap_(pkginfo, silent, npm.config.get("dev"), cb)
+  })
+}
+
+function shrinkwrap_ (pkginfo, silent, dev, cb) {
+  if (pkginfo.problems) {
+    return cb(new Error("Problems were encountered\n"
+                       +"Please correct and try again.\n"
+                       +pkginfo.problems.join("\n")))
+  }
+
+  if (!dev) {
+    // remove dev deps unless the user does --dev
+    readJson(path.resolve(npm.prefix, "package.json"), function (er, data) {
+      if (er)
+        return cb(er)
+      if (data.devDependencies) {
+        Object.keys(data.devDependencies).forEach(function (dep) {
+          if (data.dependencies && data.dependencies[dep]) {
+            // do not exclude the dev dependency if it's also listed as a dependency
+            return
+          }
+
+          log.warn("shrinkwrap", "Excluding devDependency: %s", dep)
+          delete pkginfo.dependencies[dep]
+        })
+      }
+      save(pkginfo, silent, cb)
+    })
+  } else {
+    save(pkginfo, silent, cb)
+  }
+}
+
+
+function save (pkginfo, silent, cb) {
+  // copy the keys over in a well defined order
+  // because javascript objects serialize arbitrarily
+  pkginfo.dependencies = copyOrder(pkginfo.dependencies)
+  try {
+    var swdata = JSON.stringify(pkginfo, null, 2) + "\n"
+  } catch (er) {
+    log.error("shrinkwrap", "Error converting package info to json")
+    return cb(er)
+  }
+
+  var file = path.resolve(npm.prefix, "npm-shrinkwrap.json")
+
+  fs.writeFile(file, swdata, function (er) {
+    if (er) return cb(er)
+    if (silent) return cb(null, pkginfo)
+    console.log("wrote npm-shrinkwrap.json")
+    cb(null, pkginfo)
+  })
+}
+
+function copyOrder(obj) {
+  var result = {}
+  var keys = Object.keys(obj).sort()
+  keys.forEach(function (key) {
+    result[key] = obj[key]
+  })
+  return result
+}

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

@@ -0,0 +1,33 @@
+
+module.exports = star
+
+var npm = require("./npm.js")
+  , registry = npm.registry
+  , log = require("npmlog")
+  , asyncMap = require("slide").asyncMap
+
+star.usage = "npm star <package> [pkg, pkg, ...]\n"
+           + "npm unstar <package> [pkg, pkg, ...]"
+
+star.completion = function (opts, cb) {
+  registry.get("/-/short", 60000, function (er, list) {
+    return cb(null, list || [])
+  })
+}
+
+function star (args, cb) {
+  if (!args.length) return cb(star.usage)
+  var s = npm.config.get("unicode") ? "\u2605 " : "(*)"
+    , u = npm.config.get("unicode") ? "\u2606 " : "( )"
+    , using = !(npm.command.match(/^un/))
+  if (!using) s = u
+  asyncMap(args, function (pkg, cb) {
+    registry.star(pkg, using, function (er, data, raw, req) {
+      if (!er) {
+        console.log(s + " "+pkg)
+        log.verbose("star", data)
+      }
+      cb(er, data, raw, req)
+    })
+  }, cb)
+}

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

@@ -0,0 +1,27 @@
+module.exports = stars
+
+stars.usage = "npm stars [username]"
+
+var npm = require("./npm.js")
+  , registry = npm.registry
+  , log = require("npmlog")
+
+function stars (args, cb) {
+  var name = args.length === 1 ? args[0] : npm.config.get("username")
+  registry.stars(name, showstars)
+
+  function showstars (er, data) {
+    if (er) {
+      return cb(er)
+    }
+
+    if (data.rows.length === 0) {
+      log.warn('stars', 'user has not starred any packages.')
+    } else {
+      data.rows.forEach(function(a) {
+        console.log(a.value)
+      })
+    }
+    cb()
+  }
+}

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

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

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

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

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

@@ -0,0 +1,119 @@
+// npm submodule <pkg>
+// Check the package contents for a git repository url.
+// If there is one, then create a git submodule in the node_modules folder.
+
+module.exports = submodule
+
+var npm = require("./npm.js")
+  , exec = require("child_process").execFile
+  , cache = require("./cache.js")
+  , asyncMap = require("slide").asyncMap
+  , chain = require("slide").chain
+  , which = require("which")
+
+submodule.usage = "npm submodule <pkg>"
+
+submodule.completion = require("./docs.js").completion
+
+function submodule (args, cb) {
+  if (npm.config.get("global")) {
+    return cb(new Error("Cannot use submodule command in global mode."))
+  }
+
+  if (args.length === 0) return cb(submodule.usage)
+
+  asyncMap(args, function (arg, cb) {
+    cache.add(arg, cb)
+  }, function (er, pkgs) {
+    if (er) return cb(er)
+    chain(pkgs.map(function (pkg) { return function (cb) {
+      submodule_(pkg, cb)
+    }}), cb)
+  })
+
+}
+
+function submodule_ (pkg, cb) {
+  if (!pkg.repository
+      || pkg.repository.type !== "git"
+      || !pkg.repository.url) {
+    return cb(new Error(pkg._id + ": No git repository listed"))
+  }
+
+  // prefer https:// github urls
+  pkg.repository.url = pkg.repository.url
+    .replace(/^(git:\/\/)?(git@)?github.com[:\/]/, "https://github.com/")
+
+  // first get the list of submodules, and update if it's already there.
+  getSubmodules(function (er, modules) {
+    if (er) return cb(er)
+    // if there's already a submodule, then just update it.
+    if (modules.indexOf(pkg.name) !== -1) {
+      return updateSubmodule(pkg.name, cb)
+    }
+    addSubmodule(pkg.name, pkg.repository.url, cb)
+  })
+}
+
+function updateSubmodule (name, cb) {
+  var git = npm.config.get("git")
+  var args = [ "submodule", "update", "--init", "node_modules/", name ]
+
+  // check for git
+  which(git, function (err) {
+    if (err) {
+      err.code = "ENOGIT"
+      return cb(err)
+    }
+
+    exec(git, args, cb)
+  })
+}
+
+function addSubmodule (name, url, cb) {
+  var git = npm.config.get("git")
+  var args = [ "submodule", "add", url, "node_modules/", name ]
+
+  // check for git
+  which(git, function (err) {
+    if (err) {
+      err.code = "ENOGIT"
+      return cb(err)
+    }
+
+    exec(git, args, function (er) {
+      if (er) return cb(er)
+      updateSubmodule(name, cb)
+    })
+  })
+}
+
+
+var getSubmodules = function getSubmodules (cb) {
+  var git = npm.config.get("git")
+  var args = [ "submodule", "status" ]
+
+  // check for git
+  which(git, function (err) {
+    if (err) {
+      err.code = "ENOGIT"
+      return cb(err)
+    }
+    exec(git, args, function (er, stdout, stderr) {
+      if (er) return cb(er)
+      res = stdout.trim().split(/\n/).map(function (line) {
+        return line.trim().split(/\s+/)[1]
+      }).filter(function (line) {
+        // only care about submodules in the node_modules folder.
+        return line && line.match(/^node_modules\//)
+      }).map(function (line) {
+        return line.replace(/^node_modules\//g, "")
+      })
+
+      // memoize.
+      getSubmodules = function (cb) { return cb(null, res) }
+
+      cb(null, res)
+    })
+  })
+}