remove dead function

Author: rfm

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 },
-    }))
-}
+}