Split krate into MVC modules

There is still more work to do to extract model logic from some of the
controller endpoints, however I'm focusing on getting things moved
around in bulk first, and then focus on extracting logic when practical.

Author: jtgeibel

src/controllers/helpers/mod.rs

@@ -1,3 +1,15 @@
+use conduit::Response;
+use util::{json_response, CargoResult};
+
 pub mod pagination;
 
 pub use self::pagination::Paginate;
+
+pub fn ok_true() -> CargoResult<Response> {
+    #[derive(Serialize)]
+    struct R {
+        ok: bool,
+    }
+
+    Ok(json_response(&R { ok: true }))
+}

src/krate/downloads.rs renamed to src/controllers/krate/downloads.rs

@@ -4,19 +4,13 @@
 //! download counts are located in `krate::downloads`.
 
 use std::cmp;
-
-use conduit::{Request, Response};
-use conduit_router::RequestParams;
-use diesel::prelude::*;
-
-use db::RequestTransaction;
-use util::{CargoResult, RequestUtils};
+use controllers::prelude::*;
 
 use views::EncodableVersionDownload;
 use models::{Crate, Version, VersionDownload};
-use schema::*;
+use schema::version_downloads;
 
-use super::to_char;
+use models::krate::to_char;
 
 /// Handles the `GET /crates/:crate_id/downloads` route.
 pub fn downloads(req: &mut Request) -> CargoResult<Response> {

src/krate/follow.rs renamed to src/controllers/krate/follow.rs

@@ -1,15 +1,9 @@
 //! Endpoints for managing a per user list of followed crates
 
-use conduit::{Request, Response};
-use conduit_router::RequestParams;
 use diesel::associations::Identifiable;
-use diesel::prelude::*;
 use diesel;
 
-use db::RequestTransaction;
-use user::RequestUser;
-use util::{CargoResult, RequestUtils};
-
+use controllers::prelude::*;
 use models::{Crate, Follow};
 use schema::*;
 
@@ -32,23 +26,17 @@ pub fn follow(req: &mut Request) -> CargoResult<Response> {
         .values(&follow)
         .on_conflict_do_nothing()
         .execute(&*conn)?;
-    #[derive(Serialize)]
-    struct R {
-        ok: bool,
-    }
-    Ok(req.json(&R { ok: true }))
+
+    ok_true()
 }
 
 /// Handles the `DELETE /crates/:crate_id/follow` route.
 pub fn unfollow(req: &mut Request) -> CargoResult<Response> {
     let follow = follow_target(req)?;
     let conn = req.db_conn()?;
     diesel::delete(&follow).execute(&*conn)?;
-    #[derive(Serialize)]
-    struct R {
-        ok: bool,
-    }
-    Ok(req.json(&R { ok: true }))
+
+    ok_true()
 }
 
 /// Handles the `GET /crates/:crate_id/following` route.
@@ -58,6 +46,7 @@ pub fn following(req: &mut Request) -> CargoResult<Response> {
     let follow = follow_target(req)?;
     let conn = req.db_conn()?;
     let following = diesel::select(exists(follows::table.find(follow.id()))).get_result(&*conn)?;
+
     #[derive(Serialize)]
     struct R {
         following: bool,

src/krate/metadata.rs renamed to src/controllers/krate/metadata.rs

@@ -4,20 +4,15 @@
 //! index or cached metadata which was extracted (client side) from the
 //! `Cargo.toml` file.
 
-use conduit::{Request, Response};
-use conduit_router::RequestParams;
-use diesel::prelude::*;
-
 use app::RequestApp;
-use db::RequestTransaction;
-use util::{human, CargoResult, RequestUtils};
 
+use controllers::prelude::*;
 use views::{EncodableCategory, EncodableCrate, EncodableDependency, EncodableKeyword,
             EncodableVersion};
 use models::{Category, Crate, CrateCategory, CrateDownload, CrateKeyword, Keyword, Version};
 use schema::*;
 
-use super::ALL_COLUMNS;
+use models::krate::ALL_COLUMNS;
 
 /// Handles the `GET /summary` route.
 pub fn summary(req: &mut Request) -> CargoResult<Response> {
@@ -142,7 +137,8 @@ pub fn show(req: &mut Request) -> CargoResult<Response> {
 
     #[derive(Serialize)]
     struct R {
-        #[serde(rename = "crate")] krate: EncodableCrate,
+        #[serde(rename = "crate")]
+        krate: EncodableCrate,
         versions: Vec<EncodableVersion>,
         keywords: Vec<EncodableKeyword>,
         categories: Vec<EncodableCategory>,

src/controllers/krate/mod.rs

@@ -0,0 +1,6 @@
+pub mod search;
+pub mod publish;
+pub mod owners;
+pub mod follow;
+pub mod downloads;
+pub mod metadata;

src/krate/owners.rs renamed to src/controllers/krate/owners.rs

@@ -1,16 +1,10 @@
 //! All routes related to managing owners of a crate
 
-use conduit::{Request, Response};
-use conduit_router::RequestParams;
-use diesel::prelude::*;
 use serde_json;
 
-use app::RequestApp;
-use db::RequestTransaction;
 use owner::rights;
-use user::RequestUser;
-use util::{human, CargoResult, RequestUtils};
 
+use controllers::prelude::*;
 use views::EncodableOwner;
 use models::{Crate, Owner, Rights, Team, User};
 

src/krate/publish.rs renamed to src/controllers/krate/publish.rs

@@ -4,23 +4,18 @@ use std::cmp;
 use std::collections::HashMap;
 use std::sync::Arc;
 
-use conduit::{Request, Response};
-use diesel::prelude::*;
 use hex::ToHex;
 use serde_json;
 
-use app::RequestApp;
-use db::RequestTransaction;
 use dependency;
 use git;
 use owner::rights;
 use render;
-use user::RequestUser;
 use util::{read_fill, read_le_u32};
-use util::{human, internal, CargoResult, ChainError, RequestUtils};
+use util::{internal, ChainError};
 
-use views::EncodableCrate;
-use views::EncodableCrateUpload;
+use controllers::prelude::*;
+use views::{EncodableCrate, EncodableCrateUpload};
 use models::{Badge, Category, Keyword, NewCrate, NewVersion, Rights, User};
 
 /// Handles the `PUT /crates/new` route.
@@ -177,7 +172,8 @@ pub fn publish(req: &mut Request) -> CargoResult<Response> {
 
         #[derive(Serialize)]
         struct R<'a> {
-            #[serde(rename = "crate")] krate: EncodableCrate,
+            #[serde(rename = "crate")]
+            krate: EncodableCrate,
             warnings: Warnings<'a>,
         }
         Ok(req.json(&R {

src/krate/search.rs renamed to src/controllers/krate/search.rs

@@ -1,19 +1,14 @@
 //! Endpoint for searching and discovery functionality
 
-use conduit::{Request, Response};
-use diesel::prelude::*;
 use diesel_full_text_search::*;
 
-use db::RequestTransaction;
 use controllers::helpers::Paginate;
-use user::RequestUser;
-use util::{CargoResult, RequestUtils};
-
+use controllers::prelude::*;
 use views::EncodableCrate;
 use models::{Badge, Crate, OwnerKind, Version};
 use schema::*;
 
-use super::{canon_crate_name, ALL_COLUMNS};
+use models::krate::{canon_crate_name, ALL_COLUMNS};
 
 /// Handles the `GET /crates` route.
 /// Returns a list of crates. Called in a variety of scenarios in the

src/controllers/mod.rs

@@ -2,14 +2,18 @@
 
 mod prelude {
     pub use diesel::prelude::*;
+    pub use super::helpers::ok_true;
 
+    pub use app::RequestApp;
     pub use conduit::{Request, Response};
     pub use conduit_router::RequestParams;
     pub use db::RequestTransaction;
-    pub use util::{CargoResult, RequestUtils};
+    pub use user::RequestUser;
+    pub use util::{human, CargoResult, RequestUtils};
 }
 
 pub mod helpers;
 
 pub mod category;
 pub mod keyword;
+pub mod krate;

src/crate_owner_invitation.rs

@@ -62,7 +62,8 @@ pub struct EncodableCrateOwnerInvitation {
     pub invited_by_username: String,
     pub crate_name: String,
     pub crate_id: i32,
-    #[serde(with = "::util::rfc3339")] pub created_at: NaiveDateTime,
+    #[serde(with = "::util::rfc3339")]
+    pub created_at: NaiveDateTime,
 }
 
 /// Handles the `GET /me/crate_owner_invitations` route.

src/dependency.rs

@@ -28,8 +28,10 @@ pub struct Dependency {
 
 #[derive(Debug, QueryableByName)]
 pub struct ReverseDependency {
-    #[diesel(embed)] dependency: Dependency,
-    #[sql_type = "::diesel::sql_types::Integer"] crate_downloads: i32,
+    #[diesel(embed)]
+    dependency: Dependency,
+    #[sql_type = "::diesel::sql_types::Integer"]
+    crate_downloads: i32,
     #[sql_type = "::diesel::sql_types::Text"]
     #[column_name = "crate_name"]
     name: String,

src/lib.rs

@@ -74,7 +74,6 @@ pub mod download;
 pub mod git;
 pub mod github;
 pub mod http;
-pub mod krate;
 pub mod owner;
 pub mod render;
 pub mod schema;
@@ -91,7 +90,6 @@ pub mod models;
 pub mod views;
 
 mod local_upload;
-mod with_count;
 
 /// Used for setting different values depending on whether the app is being run in production,
 /// in development, or for testing.
@@ -130,13 +128,22 @@ pub fn middleware(app: Arc<App>) -> MiddlewareBuilder {
     let mut api_router = RouteBuilder::new();
 
     // Route used by both `cargo search` and the frontend
-    api_router.get("/crates", C(krate::search::search));
+    api_router.get("/crates", C(controllers::krate::search::search));
 
     // Routes used by `cargo`
-    api_router.put("/crates/new", C(krate::publish::publish));
-    api_router.get("/crates/:crate_id/owners", C(krate::owners::owners));
-    api_router.put("/crates/:crate_id/owners", C(krate::owners::add_owners));
-    api_router.delete("/crates/:crate_id/owners", C(krate::owners::remove_owners));
+    api_router.put("/crates/new", C(controllers::krate::publish::publish));
+    api_router.get(
+        "/crates/:crate_id/owners",
+        C(controllers::krate::owners::owners),
+    );
+    api_router.put(
+        "/crates/:crate_id/owners",
+        C(controllers::krate::owners::add_owners),
+    );
+    api_router.delete(
+        "/crates/:crate_id/owners",
+        C(controllers::krate::owners::remove_owners),
+    );
     api_router.delete("/crates/:crate_id/:version/yank", C(version::yank::yank));
     api_router.put(
         "/crates/:crate_id/:version/unyank",
@@ -152,11 +159,11 @@ pub fn middleware(app: Arc<App>) -> MiddlewareBuilder {
     api_router.get("/versions/:version_id", C(version::deprecated::show));
 
     // Routes used by the frontend
-    api_router.get("/crates/:crate_id", C(krate::metadata::show));
+    api_router.get("/crates/:crate_id", C(controllers::krate::metadata::show));
     api_router.get("/crates/:crate_id/:version", C(version::deprecated::show));
     api_router.get(
         "/crates/:crate_id/:version/readme",
-        C(krate::metadata::readme),
+        C(controllers::krate::metadata::readme),
     );
     api_router.get(
         "/crates/:crate_id/:version/dependencies",
@@ -172,17 +179,35 @@ pub fn middleware(app: Arc<App>) -> MiddlewareBuilder {
     );
     api_router.get(
         "/crates/:crate_id/downloads",
-        C(krate::downloads::downloads),
+        C(controllers::krate::downloads::downloads),
+    );
+    api_router.get(
+        "/crates/:crate_id/versions",
+        C(controllers::krate::metadata::versions),
+    );
+    api_router.put(
+        "/crates/:crate_id/follow",
+        C(controllers::krate::follow::follow),
+    );
+    api_router.delete(
+        "/crates/:crate_id/follow",
+        C(controllers::krate::follow::unfollow),
+    );
+    api_router.get(
+        "/crates/:crate_id/following",
+        C(controllers::krate::follow::following),
+    );
+    api_router.get(
+        "/crates/:crate_id/owner_team",
+        C(controllers::krate::owners::owner_team),
+    );
+    api_router.get(
+        "/crates/:crate_id/owner_user",
+        C(controllers::krate::owners::owner_user),
     );
-    api_router.get("/crates/:crate_id/versions", C(krate::metadata::versions));
-    api_router.put("/crates/:crate_id/follow", C(krate::follow::follow));
-    api_router.delete("/crates/:crate_id/follow", C(krate::follow::unfollow));
-    api_router.get("/crates/:crate_id/following", C(krate::follow::following));
-    api_router.get("/crates/:crate_id/owner_team", C(krate::owners::owner_team));
-    api_router.get("/crates/:crate_id/owner_user", C(krate::owners::owner_user));
     api_router.get(
         "/crates/:crate_id/reverse_dependencies",
-        C(krate::metadata::reverse_dependencies),
+        C(controllers::krate::metadata::reverse_dependencies),
     );
     api_router.get("/keywords", C(controllers::keyword::index));
     api_router.get("/keywords/:keyword_id", C(controllers::keyword::show));
@@ -206,7 +231,7 @@ pub fn middleware(app: Arc<App>) -> MiddlewareBuilder {
         "/me/crate_owner_invitations/:crate_id",
         C(crate_owner_invitation::handle_invite),
     );
-    api_router.get("/summary", C(krate::metadata::summary));
+    api_router.get("/summary", C(controllers::krate::metadata::summary));
     api_router.put("/confirm/:email_token", C(user::confirm_user_email));
     api_router.put("/users/:user_id/resend", C(user::regenerate_token_and_send));
     api_router.get("/site_metadata", C(site_metadata::show_deployed_sha));

src/models/follow.rs

@@ -0,0 +1,11 @@
+use models::User;
+use schema::follows;
+
+#[derive(Insertable, Queryable, Identifiable, Associations, Clone, Copy, Debug)]
+#[belongs_to(User)]
+#[primary_key(user_id, crate_id)]
+#[table_name = "follows"]
+pub struct Follow {
+    pub user_id: i32,
+    pub crate_id: i32,
+}

src/models/helpers/mod.rs

@@ -0,0 +1 @@
+pub mod with_count;

src/with_count.rs renamed to src/models/helpers/with_count.rs

@@ -1,7 +1,9 @@
-#[derive(QueryableByName)]
+#[derive(QueryableByName, Debug)]
 pub struct WithCount<T> {
-    #[sql_type = "::diesel::sql_types::BigInt"] total: i64,
-    #[diesel(embed)] record: T,
+    #[sql_type = "::diesel::sql_types::BigInt"]
+    total: i64,
+    #[diesel(embed)]
+    record: T,
 }
 
 pub trait WithCountExtension<T> {