embeditor-rails 1.1.1 → 2.0.0.beta

data/lib/node_modules/npm/node_modules/npm-registry-client/lib/adduser.js

@@ -0,0 +1,138 @@
+module.exports = adduser
+
+var crypto = require('crypto')
+
+function sha (s) {
+  return crypto.createHash("sha1").update(s).digest("hex")
+}
+
+function adduser (username, password, email, cb) {
+
+  password = ("" + (password || "")).trim()
+  if (!password) return cb(new Error("No password supplied."))
+
+  email = ("" + (email || "")).trim()
+  if (!email) return cb(new Error("No email address supplied."))
+  if (!email.match(/^[^@]+@[^\.]+\.[^\.]+/)) {
+    return cb(new Error("Please use a real email address."))
+  }
+
+  if (password.indexOf(":") !== -1) return cb(new Error(
+    "Sorry, ':' chars are not allowed in passwords.\n"+
+    "See <https://issues.apache.org/jira/browse/COUCHDB-969> for why."))
+
+  var salt = crypto.randomBytes(30).toString('hex')
+    , userobj =
+      { name : username
+      , salt : salt
+      , password_sha : sha(password + salt)
+      , email : email
+      , _id : 'org.couchdb.user:'+username
+      , type : "user"
+      , roles : []
+      , date: new Date().toISOString()
+      }
+
+  // pluck off any other username/password/token.  it needs to be the
+  // same as the user we're becoming now.  replace them on error.
+  var pre = { username: this.conf.get('username')
+            , password: this.conf.get('_password')
+            , auth: this.conf.get('_auth')
+            , token: this.conf.get('_token') }
+
+  this.conf.del('_token')
+  this.conf.del('username')
+  this.conf.del('_auth')
+  this.conf.del('_password')
+  if (this.couchLogin) {
+    this.couchLogin.token = null
+  }
+
+  cb = done.call(this, cb, pre)
+
+  var logObj = Object.keys(userobj).map(function (k) {
+    if (k === 'salt' || k === 'password_sha') return [k, 'XXXXX']
+    return [k, userobj[k]]
+  }).reduce(function (s, kv) {
+    s[kv[0]] = kv[1]
+    return s
+  }, {})
+
+  this.log.verbose("adduser", "before first PUT", logObj)
+
+  this.request('PUT'
+    , '/-/user/org.couchdb.user:'+encodeURIComponent(username)
+    , userobj
+    , function (error, data, json, response) {
+        // if it worked, then we just created a new user, and all is well.
+        // but if we're updating a current record, then it'll 409 first
+        if (error && !this.conf.get('_auth')) {
+          // must be trying to re-auth on a new machine.
+          // use this info as auth
+          var b = new Buffer(username + ":" + password)
+          this.conf.set('_auth', b.toString("base64"))
+          this.conf.set('username', username)
+          this.conf.set('_password', password)
+        }
+
+        if (!error || !response || response.statusCode !== 409) {
+          return cb(error, data, json, response)
+        }
+
+        this.log.verbose("adduser", "update existing user")
+        return this.request('GET'
+          , '/-/user/org.couchdb.user:'+encodeURIComponent(username) +
+            '?write=true'
+          , function (er, data, json, response) {
+              if (er || data.error) {
+                return cb(er, data, json, response)
+              }
+              Object.keys(data).forEach(function (k) {
+                if (!userobj[k] || k === 'roles') {
+                  userobj[k] = data[k]
+                }
+              })
+              this.log.verbose("adduser", "userobj", logObj)
+              this.request('PUT'
+                , '/-/user/org.couchdb.user:'+encodeURIComponent(username)
+                  + "/-rev/" + userobj._rev
+                , userobj
+                , cb )
+            }.bind(this))
+      }.bind(this))
+}
+
+function done (cb, pre) {
+  return function (error, data, json, response) {
+    if (!error && (!response || response.statusCode === 201)) {
+      return cb(error, data, json, response)
+    }
+
+    // there was some kind of error, re-instate previous auth/token/etc.
+    this.conf.set('_token', pre.token)
+    if (this.couchLogin) {
+      this.couchLogin.token = pre.token
+      if (this.couchLogin.tokenSet) {
+        this.couchLogin.tokenSet(pre.token)
+      }
+    }
+    this.conf.set('username', pre.username)
+    this.conf.set('_password', pre.password)
+    this.conf.set('_auth', pre.auth)
+
+    this.log.verbose("adduser", "back", [error, data, json])
+    if (!error) {
+      error = new Error( (response && response.statusCode || "") + " "+
+      "Could not create user\n"+JSON.stringify(data))
+    }
+    if (response
+        && (response.statusCode === 401 || response.statusCode === 403)) {
+      this.log.warn("adduser", "Incorrect username or password\n"
+              +"You can reset your account by visiting:\n"
+              +"\n"
+              +"    https://npmjs.org/forgot\n")
+    }
+
+    return cb(error)
+  }.bind(this)
+}

data/lib/node_modules/npm/node_modules/npm-registry-client/lib/bugs.js

@@ -0,0 +1,9 @@
+
+module.exports = bugs
+
+function bugs (name, cb) {
+  this.get(name + "/latest", 3600, function (er, d) {
+    if (er) return cb(er)
+    cb(null, d.bugs)
+  })
+}

data/lib/node_modules/npm/node_modules/npm-registry-client/lib/deprecate.js

@@ -0,0 +1,28 @@
+
+module.exports = deprecate
+
+var semver = require("semver")
+
+function deprecate (name, ver, message, cb) {
+  if (!this.conf.get('username')) {
+    return cb(new Error("Must be logged in to deprecate a package"))
+  }
+
+  if (semver.validRange(ver) === null) {
+    return cb(new Error("invalid version range: "+ver))
+  }
+
+  var users = {}
+
+  this.get(name + '?write=true', function (er, data) {
+    if (er) return cb(er)
+    // filter all the versions that match
+    Object.keys(data.versions).filter(function (v) {
+      return semver.satisfies(v, ver)
+    }).forEach(function (v) {
+      data.versions[v].deprecated = message
+    })
+    // now update the doc on the registry
+    this.request('PUT', data._id, data, cb)
+  }.bind(this))
+}

data/lib/node_modules/npm/node_modules/npm-registry-client/lib/get.js

@@ -0,0 +1,184 @@
+
+module.exports = get
+
+var fs = require("graceful-fs")
+  , path = require("path")
+  , mkdir = require("mkdirp")
+  , chownr = require("chownr")
+
+function get (uri, timeout, nofollow, staleOk, cb) {
+  if (typeof cb !== "function") cb = staleOk, staleOk = false
+  if (typeof cb !== "function") cb = nofollow, nofollow = false
+  if (typeof cb !== "function") cb = timeout, timeout = -1
+  if (typeof cb !== "function") cb = version, version = null
+
+  timeout = Math.min(timeout, this.conf.get('cache-max') || 0)
+  timeout = Math.max(timeout, this.conf.get('cache-min') || -Infinity)
+
+  if (!this.conf.get('registry')) timeout = Infinity
+
+  if ( process.env.COMP_CWORD !== undefined
+    && process.env.COMP_LINE !== undefined
+    && process.env.COMP_POINT !== undefined
+    ) timeout = Math.max(timeout, 60000)
+
+  // /-/all is special.
+  // It uses timestamp-based caching and partial updates,
+  // because it is a monster.
+  if (uri === "/-/all") {
+    return requestAll.call(this, cb)
+  }
+
+  var cacheUri = uri
+  // on windows ":" is not an allowed character in a foldername
+  cacheUri = cacheUri.replace(/:/g, '_').replace(/\?write=true$/, '')
+  var cache = path.join(this.conf.get('cache'), cacheUri, ".cache.json")
+
+  // If the GET is part of a write operation (PUT or DELETE), then
+  // skip past the cache entirely, but still save the results.
+  if (uri.match(/\?write=true$/))
+    return get_.call(this, uri, timeout, cache, null, null, nofollow, staleOk, cb)
+
+
+  fs.stat(cache, function (er, stat) {
+    if (!er) fs.readFile(cache, function (er, data) {
+      try { data = JSON.parse(data) }
+      catch (ex) { data = null }
+      get_.call(this, uri, timeout, cache, stat, data, nofollow, staleOk, cb)
+    }.bind(this))
+    else get_.call(this, uri, timeout, cache, null, null, nofollow, staleOk, cb)
+  }.bind(this))
+}
+
+function requestAll (cb) {
+  var cache = path.join(this.conf.get('cache'), "/-/all", ".cache.json")
+
+  mkdir(path.join(this.conf.get('cache'), "-", "all"), function (er) {
+    fs.readFile(cache, function (er, data) {
+      if (er) return requestAll_.call(this, 0, {}, cb)
+      try {
+        data = JSON.parse(data)
+      } catch (ex) {
+        fs.writeFile(cache, "{}", function (er) {
+          if (er) return cb(new Error("Broken cache."))
+          return requestAll_.call(this, 0, {}, cb)
+        }.bind(this))
+      }
+      var t = +data._updated || 0
+      requestAll_.call(this, t, data, cb)
+    }.bind(this))
+  }.bind(this))
+}
+
+function requestAll_ (c, data, cb) {
+  // use the cache and update in the background if it's not too old
+  if (Date.now() - c < 60000) {
+    cb(null, data)
+    cb = function () {}
+  }
+
+  var uri = "/-/all/since?stale=update_after&startkey=" + c
+
+  if (c === 0) {
+    this.log.warn("", "Building the local index for the first time, please be patient")
+    uri = "/-/all"
+  }
+
+  var cache = path.join(this.conf.get('cache'), "-/all", ".cache.json")
+  this.request('GET', uri, function (er, updates, _, res) {
+    if (er) return cb(er, data)
+    var headers = res.headers
+      , updated = updates._updated || Date.parse(headers.date)
+    Object.keys(updates).forEach(function (p) {
+      data[p] = updates[p]
+    })
+    data._updated = updated
+    fs.writeFile( cache, JSON.stringify(data)
+                , function (er) {
+      delete data._updated
+      return cb(er, data)
+    })
+  })
+}
+
+function get_ (uri, timeout, cache, stat, data, nofollow, staleOk, cb) {
+  var etag
+  if (data && data._etag) etag = data._etag
+  if (timeout && timeout > 0 && stat && data) {
+    if ((Date.now() - stat.mtime.getTime())/1000 < timeout) {
+      this.log.verbose("registry.get", uri, "not expired, no request")
+      delete data._etag
+      return cb(null, data, JSON.stringify(data), {statusCode:304})
+    }
+    if (staleOk) {
+      this.log.verbose("registry.get", uri, "staleOk, background update")
+      delete data._etag
+      process.nextTick(cb.bind( null, null, data, JSON.stringify(data)
+                              , {statusCode: 304} ))
+      cb = function () {}
+    }
+  }
+
+  this.request('GET', uri, null, etag, nofollow, function (er, remoteData, raw, response) {
+    // if we get an error talking to the registry, but we have it
+    // from the cache, then just pretend we got it.
+    if (er && cache && data && !data.error) {
+      er = null
+      response = {statusCode: 304}
+    }
+
+    if (response) {
+      this.log.silly("registry.get", "cb", [response.statusCode, response.headers])
+      if (response.statusCode === 304 && etag) {
+        remoteData = data
+        this.log.verbose("etag", uri+" from cache")
+      }
+    }
+
+    data = remoteData
+    if (!data) {
+      er = er || new Error("failed to fetch from registry: " + uri)
+    }
+
+    if (er) return cb(er, data, raw, response)
+
+    // just give the write the old college try.  if it fails, whatever.
+    function saved () {
+      delete data._etag
+      cb(er, data, raw, response)
+    }
+
+    saveToCache.call(this, cache, data, saved)
+  }.bind(this))
+}
+
+function saveToCache (cache, data, saved) {
+  if (this._cacheStat) {
+    var cs = this._cacheStat
+    return saveToCache_.call(this, cache, data, cs.uid, cs.gid, saved)
+  }
+  fs.stat(this.conf.get('cache'), function (er, st) {
+    if (er) {
+      return fs.stat(process.env.HOME || "", function (er, st) {
+        // if this fails, oh well.
+        if (er) return saved()
+        this._cacheStat = st
+        return saveToCache.call(this, cache, data, saved)
+      }.bind(this))
+    }
+    this._cacheStat = st || { uid: null, gid: null }
+    return saveToCache.call(this, cache, data, saved)
+  }.bind(this))
+}
+
+function saveToCache_ (cache, data, uid, gid, saved) {
+  mkdir(path.dirname(cache), function (er, made) {
+    if (er) return saved()
+    fs.writeFile(cache, JSON.stringify(data), function (er) {
+      if (er || uid === null || gid === null) {
+        return saved()
+      }
+      chownr(made || cache, uid, gid, saved)
+    })
+  })
+}

data/lib/node_modules/npm/node_modules/npm-registry-client/lib/publish.js

@@ -0,0 +1,156 @@
+
+module.exports = publish
+
+var path = require("path")
+  , url = require("url")
+  , semver = require("semver")
+  , crypto = require("crypto")
+  , fs = require("fs")
+
+function publish (data, tarball, cb) {
+  var email = this.conf.get('email')
+  var auth = this.conf.get('_auth')
+  var username = this.conf.get('username')
+
+  if (!email || !auth || !username) {
+    var er = new Error("auth and email required for publishing")
+    er.code = 'ENEEDAUTH'
+    return cb(er)
+  }
+
+  if (data.name !== encodeURIComponent(data.name))
+    return cb(new Error('invalid name: must be url-safe'))
+
+  var ver = semver.clean(data.version)
+  if (!ver)
+    return cb(new Error('invalid semver: ' + data.version))
+  data.version = ver
+
+  var self = this
+  fs.stat(tarball, function(er, s) {
+    if (er) return cb(er)
+    fs.readFile(tarball, 'base64', function(er, tardata) {
+      if (er) return cb(er)
+      putFirst.call(self, data, tardata, s, username, email, cb)
+    })
+  })
+}
+
+function putFirst (data, tardata, stat, username, email, cb) {
+  // optimistically try to PUT all in one single atomic thing.
+  // If 409, then GET and merge, try again.
+  // If other error, then fail.
+
+  var root =
+    { _id : data.name
+    , name : data.name
+    , description : data.description
+    , "dist-tags" : {}
+    , versions : {}
+    , readme: data.readme || ""
+    , maintainers :
+      [ { name : username
+        , email : email
+        }
+      ]
+    }
+
+  root.versions[ data.version ] = data
+  data.maintainers = JSON.parse(JSON.stringify(root.maintainers))
+  var tag = data.tag || this.conf.get('tag') || "latest"
+  root["dist-tags"][tag] = data.version
+
+  var registry = this.conf.get('registry')
+  var tbName = data.name + "-" + data.version + ".tgz"
+    , tbURI = data.name + "/-/" + tbName
+
+  data._id = data.name+"@"+data.version
+  data.dist = data.dist || {}
+  data.dist.shasum = crypto.createHash("sha1").update(tardata, 'base64').digest("hex")
+  data.dist.tarball = url.resolve(registry, tbURI)
+                         .replace(/^https:\/\//, "http://")
+
+  root._attachments = {}
+  root._attachments[ tbName ] = {
+    content_type: 'application/octet-stream',
+    data: tardata,
+    length: stat.size
+  };
+
+  this.request("PUT", data.name, root, function (er, parsed, json, res) {
+    var r409 = "must supply latest _rev to update existing package"
+    var r409b = "Document update conflict."
+    var conflict = res && res.statusCode === 409
+    if (parsed && (parsed.reason === r409 || parsed.reason === r409b))
+      conflict = true
+
+    // a 409 is typical here.  GET the data and merge in.
+    if (er && !conflict) {
+      this.log.error("publish", "Failed PUT "
+                    +(res && res.statusCode))
+      return cb(er)
+    }
+
+    if (!er && !conflict)
+      return cb(er, parsed, json, res)
+
+    // let's see what versions are already published.
+    var getUrl = data.name + "?write=true"
+    this.request("GET", getUrl, function (er, current) {
+      if (er)
+        return cb(er)
+      putNext.call(this, data.version, root, current, cb)
+    }.bind(this))
+  }.bind(this))
+}
+
+function putNext(newVersion, root, current, cb) {
+  // already have the tardata on the root object
+  // just merge in existing stuff
+  var curVers = Object.keys(current.versions || {}).map(function (v) {
+    return semver.clean(v, true)
+  }).concat(Object.keys(current.time || {}).map(function(v) {
+    if (semver.valid(v, true))
+      return semver.clean(v, true)
+  }).filter(function(v) {
+    return v
+  }))
+
+  if (curVers.indexOf(newVersion) !== -1) {
+    return cb(conflictError(root.name, newVersion))
+  }
+
+  current.versions[newVersion] = root.versions[newVersion]
+  current._attachments = current._attachments || {}
+  for (var i in root) {
+    switch (i) {
+      // objects that copy over the new stuffs
+      case 'dist-tags':
+      case 'versions':
+      case '_attachments':
+        for (var j in root[i])
+          current[i][j] = root[i][j]
+        break
+
+      // ignore these
+      case 'maintainers':
+        break;
+
+      // copy
+      default:
+        current[i] = root[i]
+    }
+  }
+  var maint = JSON.parse(JSON.stringify(root.maintainers))
+  root.versions[newVersion].maintainers = maint
+
+  this.request("PUT", root.name, current, cb)
+}
+
+function conflictError (pkgid, version) {
+  var e = new Error("cannot modify pre-existing version")
+  e.code = "EPUBLISHCONFLICT"
+  e.pkgid = pkgid
+  e.version = version
+  return e
+}