Merge pull request #1 from FreeMasen/pull_1560

Pull 1560

Author: FreeMasen

src/controllers/krate/search.rs

@@ -71,7 +71,7 @@ pub fn search(req: &mut dyn Request) -> CargoResult<Response> {
                 recent_crate_downloads::downloads.nullable(),
             ));
             query = query.order(Crate::with_name(q_string).desc());
-
+            
             if sort == "relevance" {
                 let rank = ts_rank_cd(crates::textsearchable_index_col, q);
                 query = query.then_order_by(rank.desc())
@@ -211,183 +211,4 @@ pub fn search(req: &mut dyn Request) -> CargoResult<Response> {
         crates,
         meta: Meta { total },
     }))
-}
-pub fn loose_search(req: &mut dyn Request) -> CargoResult<Response> {
-    use diesel::sql_types::Bool;
-
-    let conn = req.db_conn()?;
-    let (offset, limit) = req.pagination(10, 100)?;
-    let params = req.query();
-    let sort = params
-        .get("sort")
-        .map(|s| &**s)
-        .unwrap_or("recent-downloads");
-
-    let loose_q = if let Some(q_string) = params.get("q") {
-        format!("%{}%", q_string)
-    } else {
-        String::new()
-    };
-    let mut query = crates::table
-        .left_join(recent_crate_downloads::table)
-        .select((
-            ALL_COLUMNS,
-            false.into_sql::<Bool>(),
-            recent_crate_downloads::downloads.nullable(),
-        )).into_boxed();
-    if let Some(q_string) = params.get("q") {
-        if !q_string.is_empty() {
-            let sort = params.get("sort").map(|s| &**s).unwrap_or("relevance");
-            let q = plainto_tsquery(q_string);
-            query = query.filter(
-                q.matches(crates::textsearchable_index_col)
-                    .or(Crate::like_name(&loose_q)),
-            );
-
-            query = query.select((
-                ALL_COLUMNS,
-                Crate::with_name(q_string),
-                recent_crate_downloads::downloads.nullable(),
-            ));
-            query = query.order(Crate::with_name(q_string).desc());
-
-            if sort == "relevance" {
-                let rank = ts_rank_cd(crates::textsearchable_index_col, q);
-                query = query.then_order_by(rank.desc())
-            }
-        }
-    }
-
-    if let Some(cat) = params.get("category") {
-        query = query.filter(
-            crates::id.eq_any(
-                crates_categories::table
-                    .select(crates_categories::crate_id)
-                    .inner_join(categories::table)
-                    .filter(
-                        categories::slug
-                            .eq(cat)
-                            .or(categories::slug.like(format!("{}::%", cat))),
-                    ),
-            ),
-        );
-    }
-
-    if let Some(kw) = params.get("keyword") {
-        query = query.filter(
-            crates::id.eq_any(
-                crates_keywords::table
-                    .select(crates_keywords::crate_id)
-                    .inner_join(keywords::table)
-                    .filter(::lower(keywords::keyword).eq(::lower(kw))),
-            ),
-        );
-    } else if let Some(letter) = params.get("letter") {
-        let pattern = format!(
-            "{}%",
-            letter
-                .chars()
-                .next()
-                .unwrap()
-                .to_lowercase()
-                .collect::<String>()
-        );
-        query = query.filter(canon_crate_name(crates::name).like(pattern));
-    } else if let Some(user_id) = params.get("user_id").and_then(|s| s.parse::<i32>().ok()) {
-        query = query.filter(
-            crates::id.eq_any(
-                crate_owners::table
-                    .select(crate_owners::crate_id)
-                    .filter(crate_owners::owner_id.eq(user_id))
-                    .filter(crate_owners::deleted.eq(false))
-                    .filter(crate_owners::owner_kind.eq(OwnerKind::User as i32)),
-            ),
-        );
-    } else if let Some(team_id) = params.get("team_id").and_then(|s| s.parse::<i32>().ok()) {
-        query = query.filter(
-            crates::id.eq_any(
-                crate_owners::table
-                    .select(crate_owners::crate_id)
-                    .filter(crate_owners::owner_id.eq(team_id))
-                    .filter(crate_owners::deleted.eq(false))
-                    .filter(crate_owners::owner_kind.eq(OwnerKind::Team as i32)),
-            ),
-        );
-    } else if params.get("following").is_some() {
-        query = query.filter(
-            crates::id.eq_any(
-                follows::table
-                    .select(follows::crate_id)
-                    .filter(follows::user_id.eq(req.user()?.id)),
-            ),
-        );
-    }
-
-    if sort == "downloads" {
-        query = query.then_order_by(crates::downloads.desc())
-    } else if sort == "recent-downloads" {
-        query = query.then_order_by(recent_crate_downloads::downloads.desc().nulls_last())
-    } else if sort == "recent-updates" {
-        query = query.order(crates::updated_at.desc());
-    } else {
-        query = query.then_order_by(crates::name.asc())
-    }
-    println!("{:?}", diesel::debug_query(&query));
-    // The database query returns a tuple within a tuple, with the root
-    // tuple containing 3 items.
-    let data = query
-        .paginate(limit, offset)
-        .load::<((Crate, bool, Option<i64>), i64)>(&*conn)?;
-    let total = data.first().map(|&(_, t)| t).unwrap_or(0);
-    let perfect_matches = data.iter().map(|&((_, b, _), _)| b).collect::<Vec<_>>();
-    let recent_downloads = data
-        .iter()
-        .map(|&((_, _, s), _)| s.unwrap_or(0))
-        .collect::<Vec<_>>();
-    let crates = data.into_iter().map(|((c, _, _), _)| c).collect::<Vec<_>>();
-
-    let versions = crates
-        .versions()
-        .load::<Version>(&*conn)?
-        .grouped_by(&crates)
-        .into_iter()
-        .map(|versions| Version::max(versions.into_iter().map(|v| v.num)));
-
-    let badges = CrateBadge::belonging_to(&crates)
-        .select((badges::crate_id, badges::all_columns))
-        .load::<CrateBadge>(&conn)?
-        .grouped_by(&crates)
-        .into_iter()
-        .map(|badges| badges.into_iter().map(|cb| cb.badge).collect());
-
-    let crates = versions
-        .zip(crates)
-        .zip(perfect_matches)
-        .zip(recent_downloads)
-        .zip(badges)
-        .map(
-            |((((max_version, krate), perfect_match), recent_downloads), badges)| {
-                krate.minimal_encodable(
-                    &max_version,
-                    Some(badges),
-                    perfect_match,
-                    Some(recent_downloads),
-                )
-            },
-        ).collect();
-
-    #[derive(Serialize)]
-    struct R {
-        crates: Vec<EncodableCrate>,
-        meta: Meta,
-    }
-    #[derive(Serialize)]
-    struct Meta {
-        total: i64,
-    }
-
-    Ok(req.json(&R {
-        crates,
-        meta: Meta { total },
-    }))
-}
+}

src/models/krate.rs

@@ -91,7 +91,7 @@ type CanonCrateName<T> = self::canon_crate_name::HelperType<T>;
 type All = diesel::dsl::Select<crates::table, AllColumns>;
 type WithName<'a> = diesel::dsl::Eq<CanonCrateName<crates::name>, CanonCrateName<&'a str>>;
 /// The result of a loose search
-type LikeName<'a> = diesel::dsl::Like<CanonCrateName<crates::name>, CanonCrateName<&'a str>>;
+type LikeName<'a> = diesel::pg::expression::helper_types::ILike<CanonCrateName<crates::name>, CanonCrateName<&'a str>>;
 type ByName<'a> = diesel::dsl::Filter<All, WithName<'a>>;
 type ByExactName<'a> = diesel::dsl::Filter<All, diesel::dsl::Eq<crates::name, &'a str>>;
 
@@ -246,7 +246,7 @@ impl Crate {
     /// WHERE name like $1
     /// ```
     pub fn like_name(name: &str) -> LikeName<'_> {
-        canon_crate_name(crates::name).like(canon_crate_name(name))
+        canon_crate_name(crates::name).ilike(canon_crate_name(name))
     }
     /// SQL filter with the = binary operator
     /// ```sql

src/tests/krate.rs

@@ -414,6 +414,67 @@ fn exact_match_on_queries_with_sort() {
     assert_eq!(json.crates[3].name, "other_sort");
 }
 
+#[test]
+fn loose_search_order() {
+    let (app, anon, user) = TestApp::init().with_user();
+    let user = user.as_model();
+
+    let ordered = app.db(|conn| {
+        // exact match should be first
+        let one = CrateBuilder::new("temp", user.id)
+            .readme("readme")
+            .description("description")
+            .keyword("kw1")
+            .expect_build(conn);
+        // file shouldn't match at all
+        CrateBuilder::new("file", user.id)
+            .readme("readme")
+            .description("description")
+            .keyword("kw1")
+            .expect_build(conn);
+        // temp_udp should match second
+        let two = CrateBuilder::new("temp_utp", user.id)
+            .readme("readme")
+            .description("description")
+            .keyword("kw1")
+            .expect_build(conn);
+        // evalrs should match 3rd because of readme
+        let three = CrateBuilder::new("evalrs", user.id)
+            .readme(r#"$ echo 'println!("Hello World!")' | evalrs
+   Compiling evalrs_temp v0.0.0 (file:///tmp/evalrs_temp.daiPxHtjV2VR)
+    Finished debug [unoptimized + debuginfo] target(s) in 0.51 secs
+     Running `target\debug\evalrs_temp.exe`
+Hello World!"#)
+            .description("description")
+            .keyword("kw1")
+            .expect_build(conn);
+        // tempfile should appear 4th
+        let four = CrateBuilder::new("tempfile", user.id)
+            .readme("readme")
+            .description("description")
+            .keyword("kw1")
+            .expect_build(conn);
+        // mkstemp should appear 5th
+        let five = CrateBuilder::new("mkstemp", user.id)
+            .readme("readme")
+            .description("description")
+            .keyword("kw1")
+            .expect_build(conn);
+        vec![one, two, three, four, five]
+    });
+    let search_temp = anon.search("q=temp");
+    assert_eq!(search_temp.meta.total, 5);
+    assert_eq!(search_temp.crates.len(), 5);
+    for (lhs, rhs) in search_temp.crates.iter().zip(ordered) {
+        assert_eq!(lhs.name, rhs.name);
+    }
+    let search_file = anon.search("q=file");
+    assert_eq!(search_file.meta.total, 2);
+    assert_eq!(search_file.crates.len(), 2);
+    assert_eq!(&search_file.crates[0].name, "file");
+    assert_eq!(&search_file.crates[1].name, "tempfile");
+}
+
 #[test]
 fn show() {
     let (app, anon, user) = TestApp::init().with_user();