Remove more unnused functions

Author: jtgeibel

src/category.rs

@@ -4,7 +4,6 @@ use conduit::{Request, Response};
 use conduit_router::RequestParams;
 use diesel::*;
 use diesel::pg::PgConnection;
-use pg::GenericConnection;
 use pg::rows::Row;
 
 use db::RequestTransaction;
@@ -147,39 +146,6 @@ impl Category {
         ))).load(conn)
     }
 
-    pub fn toplevel_old(
-        conn: &GenericConnection,
-        sort: &str,
-        limit: i64,
-        offset: i64,
-    ) -> CargoResult<Vec<Category>> {
-
-        let sort_sql = match sort {
-            "crates" => "ORDER BY crates_cnt DESC",
-            _ => "ORDER BY category ASC",
-        };
-
-        // Collect all the top-level categories and sum up the crates_cnt of
-        // the crates in all subcategories
-        let stmt = conn.prepare(&format!(
-            "SELECT c.id, c.category, c.slug, c.description, c.created_at,
-                sum(c2.crates_cnt)::int as crates_cnt
-             FROM categories as c
-             INNER JOIN categories c2 ON split_part(c2.slug, '::', 1) = c.slug
-             WHERE split_part(c.slug, '::', 1) = c.slug
-             GROUP BY c.id
-             {} LIMIT $1 OFFSET $2",
-            sort_sql
-        ))?;
-
-        let categories: Vec<_> = stmt.query(&[&limit, &offset])?
-            .iter()
-            .map(|row| Model::from_row(&row))
-            .collect();
-
-        Ok(categories)
-    }
-
     pub fn subcategories(&self, conn: &PgConnection) -> QueryResult<Vec<Category>> {
         use diesel::expression::dsl::*;
         use diesel::types::Text;

src/krate.rs

@@ -678,44 +678,6 @@ impl Crate {
         Ok(())
     }
 
-    pub fn add_version(
-        &mut self,
-        conn: &GenericConnection,
-        ver: &semver::Version,
-        features: &HashMap<String, Vec<String>>,
-        authors: &[String],
-    ) -> CargoResult<Version> {
-        if Version::find_by_num(conn, self.id, ver)?.is_some() {
-            return Err(human(
-                &format_args!("crate version `{}` is already uploaded", ver),
-            ));
-        }
-        Version::insert(conn, self.id, ver, features, authors)
-    }
-
-    pub fn keywords(&self, conn: &GenericConnection) -> CargoResult<Vec<Keyword>> {
-        let stmt = conn.prepare(
-            "SELECT keywords.* FROM keywords
-                                      LEFT JOIN crates_keywords
-                                      ON keywords.id = crates_keywords.keyword_id
-                                      WHERE crates_keywords.crate_id = $1",
-        )?;
-        let rows = stmt.query(&[&self.id])?;
-        Ok(rows.iter().map(|r| Model::from_row(&r)).collect())
-    }
-
-    pub fn categories(&self, conn: &GenericConnection) -> CargoResult<Vec<Category>> {
-        let stmt = conn.prepare(
-            "SELECT categories.* FROM categories \
-             LEFT JOIN crates_categories \
-             ON categories.id = \
-             crates_categories.category_id \
-             WHERE crates_categories.crate_id = $1",
-        )?;
-        let rows = stmt.query(&[&self.id])?;
-        Ok(rows.iter().map(|r| Model::from_row(&r)).collect())
-    }
-
     pub fn badges(&self, conn: &PgConnection) -> QueryResult<Vec<Badge>> {
         badges::table.filter(badges::crate_id.eq(self.id)).load(
             conn,

src/version.rs

@@ -112,10 +112,6 @@ impl Version {
         Ok(ret)
     }
 
-    pub fn valid(version: &str) -> bool {
-        semver::Version::parse(version).is_ok()
-    }
-
     pub fn encodable(self, crate_name: &str) -> EncodableVersion {
         let Version {
             id,
@@ -166,14 +162,6 @@ impl Version {
         Ok(())
     }
 
-    pub fn yank(&self, conn: &GenericConnection, yanked: bool) -> CargoResult<()> {
-        conn.execute(
-            "UPDATE versions SET yanked = $1 WHERE id = $2",
-            &[&yanked, &self.id],
-        )?;
-        Ok(())
-    }
-
     pub fn max<T>(versions: T) -> semver::Version
     where
         T: IntoIterator<Item = semver::Version>,