update erythang

Author: Gankra

src/bin/migrate.rs

@@ -456,8 +456,11 @@ fn migrations() -> Vec<Migration> {
         ),
         Migration::add_table(20150804170128, "teams", "
             id            SERIAL PRIMARY KEY,
-            name          VARCHAR NOT NULL UNIQUE,
-            github_id     INTEGER NOT NULL UNIQUE
+            login         VARCHAR NOT NULL UNIQUE,
+            github_id     INTEGER NOT NULL UNIQUE,
+            name          VARCHAR,
+            url           VARCHAR,
+            avatar        VARCHAR
         "),
         Migration::run(20150804170129,
             "ALTER TABLE crate_owners RENAME user_id TO owner_id",

src/http.rs

@@ -1,8 +1,14 @@
 use curl;
 use oauth2::*;
 use app::App;
+use util::{CargoResult, internal, ChainError, human};
+use rustc_serialize::{json, Decodable};
+use std::str;
 
-/// Does all the nonsense for sending a GET to Github
+
+/// Does all the nonsense for sending a GET to Github. Doesn't handle parsing
+/// because custom error-code handling may be desirable. Use
+/// parse_github_response to handle the "common" processing of responses.
 pub fn github(app: &App, url: &str, auth: &Token)
     -> Result<curl::http::Response, curl::ErrCode> {
     info!("HTTP: {}", url);
@@ -14,6 +20,35 @@ pub fn github(app: &App, url: &str, auth: &Token)
      .exec()
 }
 
+/// Checks for normal responses
+pub fn parse_github_response<T: Decodable>(resp: curl::http::Response)
+                                            -> CargoResult<T> {
+    match resp.get_code() {
+        200 => {} // Ok!
+        403 => {
+            return Err(human("It looks like you don't have permission \
+                              to query a necessary property from Github
+                              to complete this request. \
+                              You may need to re-authenticate on \
+                              crates.io to grant permission to read \
+                              github org memberships. Just go to \
+                              https://crates.io/login"));
+        }
+        _ => {
+            return Err(internal(format!("didn't get a 200 result from
+                                        github: {}", resp)));
+        }
+    }
+
+    let json = try!(str::from_utf8(resp.get_body()).ok().chain_error(||{
+        internal("github didn't send a utf8-response")
+    }));
+
+    json::decode(json).chain_error(|| {
+        internal("github didn't send a valid json response")
+    })
+}
+
 /// Gets a token with the given string as the access token, but all
 /// other info null'd out. Generally, just to be fed to the `github` fn.
 pub fn token(token: String) -> Token {

src/krate.rs

@@ -314,17 +314,17 @@ impl Crate {
     }
 
     pub fn owner_add(&self, app: &App, conn: &Connection, req_user: &User,
-                     name: &str) -> CargoResult<()> {
+                     login: &str) -> CargoResult<()> {
 
-        let owner = match Owner::find_by_name(conn, name) {
+        let owner = match Owner::find_by_login(conn, login) {
             Ok(owner@Owner::User(_)) => { owner }
             Ok(Owner::Team(team)) => if try!(team.contains_user(app, req_user)) {
                 Owner::Team(team)
             } else {
-                return Err(human(format!("only members of {} can add it as an owner", name)));
+                return Err(human(format!("only members of {} can add it as an owner", login)));
             },
-            Err(err) => if name.contains(":") {
-                Owner::Team(try!(Team::create(app, conn, name, req_user)))
+            Err(err) => if login.contains(":") {
+                Owner::Team(try!(Team::create(app, conn, login, req_user)))
             } else {
                 return Err(err);
             },
@@ -339,9 +339,9 @@ impl Crate {
     }
 
     pub fn owner_remove(&self, conn: &Connection, _req_user: &User,
-                        name: &str) -> CargoResult<()> {
-        let owner = try!(Owner::find_by_name(conn, name).map_err(|_| {
-            human(format!("could not find user with login `{}`", name))
+                        login: &str) -> CargoResult<()> {
+        let owner = try!(Owner::find_by_login(conn, login).map_err(|_| {
+            human(format!("could not find owner with login `{}`", login))
         }));
         try!(conn.execute("UPDATE crate_owners
                               SET deleted = TRUE, updated_at = $1
@@ -1022,23 +1022,23 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult<Response> {
         human("invalid json request")
     }));
 
-    let names = try!(request.owners.or(request.users).ok_or_else(|| {
+    let logins = try!(request.owners.or(request.users).ok_or_else(|| {
         human("invalid json request")
     }));
 
-    for name in &names {
+    for login in &logins {
         if add {
-            if owners.iter().any(|owner| owner.name() == *name) {
-                return Err(human(format!("`{}` is already an owner", name)))
+            if owners.iter().any(|owner| owner.login() == *login) {
+                return Err(human(format!("`{}` is already an owner", login)))
             }
-            try!(krate.owner_add(req.app(), tx, &user, &name));
+            try!(krate.owner_add(req.app(), tx, &user, &login));
         } else {
             // Removing the team that gives you rights is prevented because
             // team members only have Rights::Publish
-            if *name == user.gh_login {
+            if *login == user.gh_login {
                 return Err(human("cannot remove yourself as an owner"))
             }
-            try!(krate.owner_remove(tx, &user, &name));
+            try!(krate.owner_remove(tx, &user, &login));
         }
     }