Port /crates/new and /crates/show to use Diesel

This is probably the single largest endpoint in the entire app. It had a
bit more churn than I'd like, since we're now explicitly wrapping the
whole thing in a database transaction. I've also ported over the
`/crates/show` endpoint as there were several tests that needed both to
be ported over.

There were a large number of tests that needed even more endpoints
ported over in order to be valid. These tests are important, but I want
to keep this commit at least somewhat manageble so I've set them to
ignore for now.

Author: sgrif

src/badge.rs

@@ -3,7 +3,7 @@ use krate::Crate;
 use schema::badges;
 use util::CargoResult;
 
-use diesel::pg::Pg;
+use diesel::pg::{Pg, PgConnection};
 use diesel::prelude::*;
 use pg::GenericConnection;
 use pg::rows::Row;
@@ -67,7 +67,48 @@ impl Badge {
         }
     }
 
-    pub fn update_crate(conn: &GenericConnection,
+    pub fn update_crate<'a>(conn: &PgConnection,
+                            krate: &Crate,
+                            badges: Option<&'a HashMap<String, HashMap<String, String>>>)
+                            -> CargoResult<Vec<&'a str>> {
+        use diesel::{insert, delete};
+
+        #[derive(Insertable)]
+        #[table_name="badges"]
+        struct NewBadge<'a> {
+            crate_id: i32,
+            badge_type: &'a str,
+            attributes: serde_json::Value,
+        }
+
+        let mut invalid_badges = vec![];
+        let mut new_badges = vec![];
+
+        if let Some(badges) = badges {
+            for (k, v) in badges {
+                let attributes_json = serde_json::to_value(v).unwrap();
+
+                let json = json!({"badge_type": k, "attributes": attributes_json});
+                if serde_json::from_value::<Badge>(json).is_ok() {
+                    new_badges.push(NewBadge {
+                        crate_id: krate.id,
+                        badge_type: &**k,
+                        attributes: attributes_json,
+                    });
+                } else {
+                    invalid_badges.push(&**k);
+                }
+            }
+        }
+
+        conn.transaction(|| {
+            delete(badges::table.filter(badges::crate_id.eq(krate.id))).execute(conn)?;
+            insert(&new_badges).into(badges::table).execute(conn)?;
+            Ok(invalid_badges)
+        })
+    }
+
+    pub fn update_crate_old(conn: &GenericConnection,
                         krate: &Crate,
                         badges: HashMap<String, HashMap<String, String>>)
                         -> CargoResult<Vec<String>> {

src/bin/transfer-crates.rs

@@ -42,14 +42,14 @@ fn transfer(tx: &postgres::transaction::Transaction) {
     let from = User::find_by_login(tx, &from).unwrap();
     let to = User::find_by_login(tx, &to).unwrap();
 
-    if from.avatar != to.avatar {
+    if from.gh_avatar != to.gh_avatar {
         println!("====================================================");
         println!("WARNING");
         println!("");
         println!("this may not be the same github user, different avatar urls");
         println!("");
-        println!("from: {:?}", from.avatar);
-        println!("to:   {:?}", to.avatar);
+        println!("from: {:?}", from.gh_avatar);
+        println!("to:   {:?}", to.gh_avatar);
 
         get_confirm("continue?");
     }
@@ -68,7 +68,7 @@ fn transfer(tx: &postgres::transaction::Transaction) {
         let id: i32 = row.get("id");
         let krate = Crate::find(tx, row.get("crate_id")).unwrap();
         println!("transferring {}", krate.name);
-        let owners = krate.owners(tx).unwrap();
+        let owners = krate.owners_old(tx).unwrap();
         if owners.len() != 1 {
             println!("warning: not exactly one owner for {}", krate.name);
         }

src/category.rs

@@ -30,7 +30,7 @@ pub struct Category {
 #[belongs_to(Crate)]
 #[table_name="crates_categories"]
 #[primary_key(crate_id, category_id)]
-struct CrateCategory {
+pub struct CrateCategory {
     crate_id: i32,
     category_id: i32,
 }

src/dependency.rs

@@ -1,10 +1,14 @@
+use diesel::prelude::*;
+use diesel::pg::{Pg, PgConnection};
 use pg::GenericConnection;
 use pg::rows::Row;
 use semver;
 
 use Model;
 use git;
-use util::{CargoResult};
+use krate::{Crate, canon_crate_name};
+use schema::*;
+use util::{CargoResult, human};
 
 pub struct Dependency {
     pub id: i32,
@@ -47,6 +51,19 @@ pub enum Kind {
     // if you add a kind here, be sure to update `from_row` below.
 }
 
+#[derive(Insertable)]
+#[table_name="dependencies"]
+struct NewDependency<'a> {
+    version_id: i32,
+    crate_id: i32,
+    req: String,
+    optional: bool,
+    default_features: bool,
+    features: Vec<&'a str>,
+    target: Option<&'a str>,
+    kind: i32,
+}
+
 impl Dependency {
     // FIXME: Encapsulate this in a `NewDependency` struct
     #[cfg_attr(feature = "clippy", allow(too_many_arguments))]
@@ -102,6 +119,73 @@ impl ReverseDependency {
     }
 }
 
+pub fn add_dependencies(
+    conn: &PgConnection,
+    deps: &[::upload::CrateDependency],
+    version_id: i32,
+) -> CargoResult<Vec<Dependency>> {
+    use diesel::insert;
+    use diesel::expression::dsl::any;
+
+    let crate_names = deps.iter().map(|d| &*d.name).collect::<Vec<_>>();
+    let crates = Crate::all()
+        .filter(canon_crate_name(crates::name).eq(any(crate_names)))
+        .load::<Crate>(conn)?;
+
+    let new_dependencies = deps.iter().map(|dep| {
+        let krate = crates.iter().find(|c| dep.name == c.name)
+            .map(Ok)
+            .unwrap_or_else(|| {
+                Err(human(&format_args!("no known crate named `{}`", &*dep.name)))
+            })?;
+        if dep.version_req == semver::VersionReq::parse("*").unwrap() {
+            return Err(human("wildcard (`*`) dependency constraints are not allowed \
+                              on crates.io. See http://doc.crates.io/faq.html#can-\
+                              libraries-use--as-a-version-for-their-dependencies for more \
+                              information"));
+        }
+        let features = dep.features.iter().map(|s| &**s).collect();
+        Ok(NewDependency {
+            version_id: version_id,
+            crate_id: krate.id,
+            req: dep.version_req.to_string(),
+            kind: dep.kind.unwrap_or(Kind::Normal) as i32,
+            optional: dep.optional,
+            default_features: dep.default_features,
+            features: features,
+            target: dep.target.as_ref().map(|s| &**s),
+        })
+    }).collect::<Result<Vec<_>, _>>()?;
+
+    insert(&new_dependencies).into(dependencies::table)
+        .get_results(conn)
+        .map_err(Into::into)
+}
+
+impl Queryable<dependencies::SqlType, Pg> for Dependency {
+    type Row = (i32, i32, i32, String, bool, bool, Vec<String>, Option<String>,
+                i32);
+
+    fn build(row: Self::Row) -> Self {
+        Dependency {
+            id: row.0,
+            version_id: row.1,
+            crate_id: row.2,
+            req: semver::VersionReq::parse(&row.3).unwrap(),
+            optional: row.4,
+            default_features: row.5,
+            features: row.6,
+            target: row.7,
+            kind: match row.8 {
+                0 => Kind::Normal,
+                1 => Kind::Build,
+                2 => Kind::Dev,
+                n => panic!("unknown kind: {}", n),
+            }
+        }
+    }
+}
+
 impl Model for Dependency {
     fn from_row(row: &Row) -> Dependency {
         let req: String = row.get("req");

src/keyword.rs

@@ -29,7 +29,7 @@ pub struct Keyword {
 #[belongs_to(Crate)]
 #[table_name="crates_keywords"]
 #[primary_key(crate_id, keyword_id)]
-struct CrateKeyword {
+pub struct CrateKeyword {
     crate_id: i32,
     keyword_id: i32,
 }
@@ -66,8 +66,11 @@ impl Keyword {
             .map(|s| (s.to_lowercase(), NewKeyword { keyword: *s }))
             .unzip();
 
-        diesel::insert(&new_keywords.on_conflict_do_nothing()).into(keywords::table)
-            .execute(conn)?;
+        // https://github.com/diesel-rs/diesel/issues/797
+        if !new_keywords.is_empty() {
+            diesel::insert(&new_keywords.on_conflict_do_nothing()).into(keywords::table)
+                .execute(conn)?;
+        }
         keywords::table.filter(lower(keywords::keyword).eq(any(lowercase_names)))
             .load(conn)
     }