Normalise keywords to lowercase.

Currently keywords are case-sensitive, but this is often unhelpful, as
they are heuristic classification tools, not hard
guarantees. E.g. ["fft"](https://crates.io/keywords/fft) contains
different crates to ["FFT"](https://crates.io/keywords/FFT).

This patch normalises keywords to lowercase as they go into the
database.

Closes #100.

Author: huonw

src/bin/migrate.rs

@@ -418,6 +418,11 @@ fn migrations() -> Vec<Migration> {
                              crate_owners_unique_user_per_crate", &[]));
             Ok(())
         }),
+        Migration::new(20150320174400, |tx| {
+            try!(tx.execute("ALTER TABLE keyword SET keyword = lower(keyword)",
+                            &[]));
+            Ok(())
+        }, |_| Ok(())),
     ];
     // NOTE: Generate a new id via `date +"%Y%m%d%H%M%S"`
 

src/keyword.rs

@@ -36,7 +36,7 @@ impl Keyword {
     pub fn find_by_keyword(conn: &Connection, name: &str)
                            -> CargoResult<Option<Keyword>> {
         let stmt = try!(conn.prepare("SELECT * FROM keywords \
-                                      WHERE keyword = $1"));
+                                      WHERE keyword = lower($1)"));
         let rows = try!(stmt.query(&[&name as &ToSql]));
         Ok(rows.iter().next().map(|r| Model::from_row(&r)))
     }
@@ -45,13 +45,13 @@ impl Keyword {
                           -> CargoResult<Keyword> {
         // TODO: racy (the select then insert is not atomic)
         let stmt = try!(conn.prepare("SELECT * FROM keywords
-                                      WHERE keyword = $1"));
+                                      WHERE keyword = lower($1)"));
         for row in try!(stmt.query(&[&name as &ToSql])) {
             return Ok(Model::from_row(&row))
         }
 
         let stmt = try!(conn.prepare("INSERT INTO keywords \
-                                      (keyword, created_at, crates_cnt)
+                                      (lower(keyword), created_at, crates_cnt)
                                       VALUES ($1, $2, 0) \
                                       RETURNING *"));
         let now = ::now();
@@ -185,4 +185,3 @@ pub fn show(req: &mut Request) -> CargoResult<Response> {
     struct R { keyword: EncodableKeyword }
     Ok(req.json(&R { keyword: kw.encodable() }))
 }
-

src/krate.rs

@@ -460,7 +460,7 @@ pub fn index(req: &mut Request) -> CargoResult<Response> {
                                 ON crates.id = crates_keywords.crate_id
                         INNER JOIN keywords
                                 ON crates_keywords.keyword_id = keywords.id
-                        WHERE keywords.keyword = $1";
+                        WHERE keywords.keyword = lower($1)";
             (format!("SELECT crates.* {} {} LIMIT $2 OFFSET $3", base, sort_sql),
              format!("SELECT COUNT(crates.*) {}", base))
         })

src/tests/keyword.rs

@@ -43,6 +43,19 @@ fn show() {
     assert_eq!(json.keyword.keyword, "foo".to_string());
 }
 
+#[test]
+fn show_case_insensitive() {
+    let (_b, app, middle) = ::app();
+    let mut req = ::req(app, Method::Get, "/api/v1/keywords/fOO");
+    let response = t_resp!(middle.call(&mut req));
+    assert_eq!(response.status.0, 404);
+
+    ::mock_keyword(&mut req, "Foo");
+    let mut response = ok_resp!(middle.call(&mut req));
+    let json: GoodKeyword = ::json(&mut response);
+    assert_eq!(json.keyword.keyword, "foo".to_string());
+}
+
 fn tx(req: &Request) -> &Connection { req.tx().unwrap() }
 
 #[test]