Split owner and team into separate models

Author: jtgeibel

src/github.rs

@@ -93,3 +93,12 @@ pub fn token(token: String) -> Token {
         token_type: String::new(),
     }
 }
+
+pub fn team_url(login: &str) -> String {
+    let mut login_pieces = login.split(':');
+    login_pieces.next();
+    format!(
+        "https://github.com/{}",
+        login_pieces.next().expect("org failed"),
+    )
+}

src/lib.rs

@@ -73,7 +73,6 @@ pub mod download;
 pub mod git;
 pub mod github;
 pub mod http;
-pub mod owner;
 pub mod render;
 pub mod schema;
 pub mod token;

src/models/mod.rs

@@ -6,8 +6,9 @@ pub use download::VersionDownload;
 pub use self::follow::Follow;
 pub use self::keyword::{CrateKeyword, Keyword};
 pub use self::krate::{Crate, CrateDownload, NewCrate};
-pub use owner::{CrateOwner, NewTeam, Owner, OwnerKind, Team};
+pub use self::owner::{CrateOwner, Owner, OwnerKind};
 pub use self::rights::Rights;
+pub use self::team::{NewTeam, Team};
 pub use user::{Email, NewUser, User};
 pub use token::ApiToken;
 pub use version::{NewVersion, Version};
@@ -19,4 +20,6 @@ mod category;
 mod follow;
 mod keyword;
 pub mod krate;
-mod rights;
+mod owner;
+mod rights;
+mod team;

src/models/owner.rs

@@ -0,0 +1,126 @@
+use diesel::prelude::*;
+
+use app::App;
+use github;
+use util::{human, CargoResult};
+
+use models::{Crate, Team, User};
+use schema::{crate_owners, users};
+use views::EncodableOwner;
+
+#[derive(Insertable, Associations, Identifiable, Debug, Clone, Copy)]
+#[belongs_to(Crate)]
+#[belongs_to(User, foreign_key = "owner_id")]
+#[belongs_to(Team, foreign_key = "owner_id")]
+#[table_name = "crate_owners"]
+#[primary_key(crate_id, owner_id, owner_kind)]
+pub struct CrateOwner {
+    pub crate_id: i32,
+    pub owner_id: i32,
+    pub created_by: i32,
+    pub owner_kind: i32,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(u32)]
+pub enum OwnerKind {
+    User = 0,
+    Team = 1,
+}
+
+/// Unifies the notion of a User or a Team.
+#[derive(Debug)]
+pub enum Owner {
+    User(User),
+    Team(Team),
+}
+
+impl Owner {
+    /// Finds the owner by name. Always recreates teams to get the most
+    /// up-to-date GitHub ID. Fails out if the user isn't found in the
+    /// database, the team isn't found on GitHub, or if the user isn't a member
+    /// of the team on GitHub.
+    /// May be a user's GH login or a full team name. This is case
+    /// sensitive.
+    pub fn find_or_create_by_login(
+        app: &App,
+        conn: &PgConnection,
+        req_user: &User,
+        name: &str,
+    ) -> CargoResult<Owner> {
+        if name.contains(':') {
+            Ok(Owner::Team(Team::create_or_update(
+                app,
+                conn,
+                name,
+                req_user,
+            )?))
+        } else {
+            users::table
+                .filter(users::gh_login.eq(name))
+                .first(conn)
+                .map(Owner::User)
+                .map_err(|_| human(&format_args!("could not find user with login `{}`", name)))
+        }
+    }
+
+    pub fn kind(&self) -> i32 {
+        match *self {
+            Owner::User(_) => OwnerKind::User as i32,
+            Owner::Team(_) => OwnerKind::Team as i32,
+        }
+    }
+
+    pub fn login(&self) -> &str {
+        match *self {
+            Owner::User(ref user) => &user.gh_login,
+            Owner::Team(ref team) => &team.login,
+        }
+    }
+
+    pub fn id(&self) -> i32 {
+        match *self {
+            Owner::User(ref user) => user.id,
+            Owner::Team(ref team) => team.id,
+        }
+    }
+
+    pub fn encodable(self) -> EncodableOwner {
+        match self {
+            Owner::User(User {
+                id,
+                name,
+                gh_login,
+                gh_avatar,
+                ..
+            }) => {
+                let url = format!("https://github.com/{}", gh_login);
+                EncodableOwner {
+                    id: id,
+                    login: gh_login,
+                    avatar: gh_avatar,
+                    url: Some(url),
+                    name: name,
+                    kind: String::from("user"),
+                }
+            }
+            Owner::Team(Team {
+                id,
+                name,
+                login,
+                avatar,
+                ..
+            }) => {
+                let url = github::team_url(&login);
+                EncodableOwner {
+                    id: id,
+                    login: login,
+                    url: Some(url),
+                    avatar: avatar,
+                    name: name,
+                    kind: String::from("team"),
+                }
+            }
+        }
+    }
+}

src/owner.rs renamed to src/models/team.rs

@@ -4,35 +4,9 @@ use app::App;
 use github;
 use util::{human, CargoResult};
 
-use models::{Crate, User};
-use schema::{crate_owners, teams, users};
-
-#[derive(Insertable, Associations, Identifiable, Debug, Clone, Copy)]
-#[belongs_to(Crate)]
-#[belongs_to(User, foreign_key = "owner_id")]
-#[belongs_to(Team, foreign_key = "owner_id")]
-#[table_name = "crate_owners"]
-#[primary_key(crate_id, owner_id, owner_kind)]
-pub struct CrateOwner {
-    pub crate_id: i32,
-    pub owner_id: i32,
-    pub created_by: i32,
-    pub owner_kind: i32,
-}
-
-#[derive(Debug, Clone, Copy)]
-#[repr(u32)]
-pub enum OwnerKind {
-    User = 0,
-    Team = 1,
-}
-
-/// Unifies the notion of a User or a Team.
-#[derive(Debug)]
-pub enum Owner {
-    User(User),
-    Team(Team),
-}
+use models::{Crate, CrateOwner, Owner, OwnerKind, User};
+use schema::{crate_owners, teams};
+use views::EncodableTeam;
 
 /// For now, just a Github Team. Can be upgraded to other teams
 /// later if desirable.
@@ -53,25 +27,6 @@ pub struct Team {
     pub avatar: Option<String>,
 }
 
-#[derive(Serialize, Debug)]
-pub struct EncodableTeam {
-    pub id: i32,
-    pub login: String,
-    pub name: Option<String>,
-    pub avatar: Option<String>,
-    pub url: Option<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct EncodableOwner {
-    pub id: i32,
-    pub login: String,
-    pub kind: String,
-    pub url: Option<String>,
-    pub name: Option<String>,
-    pub avatar: Option<String>,
-}
-
 #[derive(Insertable, AsChangeset, Debug)]
 #[table_name = "teams"]
 pub struct NewTeam<'a> {
@@ -240,7 +195,7 @@ impl Team {
             avatar,
             ..
         } = self;
-        let url = Team::github_url(&login);
+        let url = github::team_url(&login);
 
         EncodableTeam {
             id: id,
@@ -250,16 +205,6 @@ impl Team {
             url: Some(url),
         }
     }
-
-    fn github_url(login: &str) -> String {
-        let mut login_pieces = login.split(':');
-        login_pieces.next();
-
-        format!(
-            "https://github.com/{}",
-            login_pieces.next().expect("org failed"),
-        )
-    }
 }
 
 fn team_with_gh_id_contains_user(app: &App, github_id: i32, user: &User) -> CargoResult<bool> {
@@ -286,93 +231,3 @@ fn team_with_gh_id_contains_user(app: &App, github_id: i32, user: &User) -> Carg
     // some feedback, but it's not obvious how that should work.
     Ok(membership.state == "active")
 }
-
-impl Owner {
-    /// Finds the owner by name. Always recreates teams to get the most
-    /// up-to-date GitHub ID. Fails out if the user isn't found in the
-    /// database, the team isn't found on GitHub, or if the user isn't a member
-    /// of the team on GitHub.
-    /// May be a user's GH login or a full team name. This is case
-    /// sensitive.
-    pub fn find_or_create_by_login(
-        app: &App,
-        conn: &PgConnection,
-        req_user: &User,
-        name: &str,
-    ) -> CargoResult<Owner> {
-        if name.contains(':') {
-            Ok(Owner::Team(Team::create_or_update(
-                app,
-                conn,
-                name,
-                req_user,
-            )?))
-        } else {
-            users::table
-                .filter(users::gh_login.eq(name))
-                .first(conn)
-                .map(Owner::User)
-                .map_err(|_| human(&format_args!("could not find user with login `{}`", name)))
-        }
-    }
-
-    pub fn kind(&self) -> i32 {
-        match *self {
-            Owner::User(_) => OwnerKind::User as i32,
-            Owner::Team(_) => OwnerKind::Team as i32,
-        }
-    }
-
-    pub fn login(&self) -> &str {
-        match *self {
-            Owner::User(ref user) => &user.gh_login,
-            Owner::Team(ref team) => &team.login,
-        }
-    }
-
-    pub fn id(&self) -> i32 {
-        match *self {
-            Owner::User(ref user) => user.id,
-            Owner::Team(ref team) => team.id,
-        }
-    }
-
-    pub fn encodable(self) -> EncodableOwner {
-        match self {
-            Owner::User(User {
-                id,
-                name,
-                gh_login,
-                gh_avatar,
-                ..
-            }) => {
-                let url = format!("https://github.com/{}", gh_login);
-                EncodableOwner {
-                    id: id,
-                    login: gh_login,
-                    avatar: gh_avatar,
-                    url: Some(url),
-                    name: name,
-                    kind: String::from("user"),
-                }
-            }
-            Owner::Team(Team {
-                id,
-                name,
-                login,
-                avatar,
-                ..
-            }) => {
-                let url = Team::github_url(&login);
-                EncodableOwner {
-                    id: id,
-                    login: login,
-                    url: Some(url),
-                    avatar: avatar,
-                    name: name,
-                    kind: String::from("team"),
-                }
-            }
-        }
-    }
-}

src/views/mod.rs

@@ -79,7 +79,25 @@ pub struct EncodableCrateLinks {
     pub reverse_dependencies: String,
 }
 
-pub use owner::{EncodableOwner, EncodableTeam};
+#[derive(Serialize, Deserialize, Debug)]
+pub struct EncodableOwner {
+    pub id: i32,
+    pub login: String,
+    pub kind: String,
+    pub url: Option<String>,
+    pub name: Option<String>,
+    pub avatar: Option<String>,
+}
+
+#[derive(Serialize, Debug)]
+pub struct EncodableTeam {
+    pub id: i32,
+    pub login: String,
+    pub name: Option<String>,
+    pub avatar: Option<String>,
+    pub url: Option<String>,
+}
+
 pub use token::EncodableApiTokenWithToken;
 pub use user::{EncodablePrivateUser, EncodablePublicUser};
 pub use version::{EncodableVersion, EncodableVersionLinks};