Extract rights into a model used by User

Author: jtgeibel

src/controllers/krate/owners.rs

@@ -2,8 +2,6 @@
 
 use serde_json;
 
-use owner::rights;
-
 use controllers::prelude::*;
 use views::EncodableOwner;
 use models::{Crate, Owner, Rights, Team, User};
@@ -79,7 +77,7 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult<Response> {
     let krate = Crate::by_name(&req.params()["crate_id"]).first::<Crate>(&*conn)?;
     let owners = krate.owners(&conn)?;
 
-    match rights(req.app(), &owners, user)? {
+    match user.rights(req.app(), &owners)? {
         Rights::Full => {}
         // Yes!
         Rights::Publish => {

src/controllers/krate/publish.rs

@@ -9,7 +9,6 @@ use serde_json;
 
 use dependency;
 use git;
-use owner::rights;
 use render;
 use util::{read_fill, read_le_u32};
 use util::{internal, ChainError};
@@ -72,7 +71,7 @@ pub fn publish(req: &mut Request) -> CargoResult<Response> {
         let krate = persist.create_or_update(&conn, license_file, user.id)?;
 
         let owners = krate.owners(&conn)?;
-        if rights(req.app(), &owners, &user)? < Rights::Publish {
+        if user.rights(req.app(), &owners)? < Rights::Publish {
             return Err(human(
                 "this crate exists but you don't seem to be an owner. \
                  If you believe this is a mistake, perhaps you need \

src/models/mod.rs

@@ -6,7 +6,8 @@ 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, Rights, Team};
+pub use owner::{CrateOwner, NewTeam, Owner, OwnerKind, Team};
+pub use self::rights::Rights;
 pub use user::{Email, NewUser, User};
 pub use token::ApiToken;
 pub use version::{NewVersion, Version};
@@ -18,3 +19,4 @@ mod category;
 mod follow;
 mod keyword;
 pub mod krate;
+mod rights;

src/models/rights.rs

@@ -0,0 +1,8 @@
+/// Access rights to the crate (publishing and ownership management)
+/// NOTE: The order of these variants matters!
+#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)]
+pub enum Rights {
+    None,
+    Publish,
+    Full,
+}

src/owner.rs

@@ -5,7 +5,7 @@ use github;
 use util::{human, CargoResult};
 
 use models::{Crate, User};
-use schema::*;
+use schema::{crate_owners, teams, users};
 
 #[derive(Insertable, Associations, Identifiable, Debug, Clone, Copy)]
 #[belongs_to(Crate)]
@@ -72,15 +72,6 @@ pub struct EncodableOwner {
     pub avatar: Option<String>,
 }
 
-/// Access rights to the crate (publishing and ownership management)
-/// NOTE: The order of these variants matters!
-#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)]
-pub enum Rights {
-    None,
-    Publish,
-    Full,
-}
-
 #[derive(Insertable, AsChangeset, Debug)]
 #[table_name = "teams"]
 pub struct NewTeam<'a> {
@@ -385,26 +376,3 @@ impl Owner {
         }
     }
 }
-
-/// Given this set of owners, determines the strongest rights the
-/// given user has.
-///
-/// Shortcircuits on `Full` because you can't beat it. In practice we'll always
-/// see `[user, user, user, ..., team, team, team]`, so we could shortcircuit on
-/// `Publish` as well, but this is a non-obvious invariant so we don't bother.
-/// Sweet free optimization if teams are proving burdensome to check.
-/// More than one team isn't really expected, though.
-pub fn rights(app: &App, owners: &[Owner], user: &User) -> CargoResult<Rights> {
-    let mut best = Rights::None;
-    for owner in owners {
-        match *owner {
-            Owner::User(ref other_user) => if other_user.id == user.id {
-                return Ok(Rights::Full);
-            },
-            Owner::Team(ref team) => if team.contains_user(app, user)? {
-                best = Rights::Publish;
-            },
-        }
-    }
-    Ok(best)
-}

src/user/mod.rs

@@ -8,7 +8,7 @@ use rand::{thread_rng, Rng};
 use std::borrow::Cow;
 use serde_json;
 
-use app::RequestApp;
+use app::{App, RequestApp};
 use db::RequestTransaction;
 use controllers::helpers::Paginate;
 use util::{bad_request, human, CargoResult, RequestUtils};
@@ -20,7 +20,7 @@ pub use self::middleware::{AuthenticationSource, Middleware, RequestUser};
 pub mod middleware;
 
 use views::{EncodableTeam, EncodableVersion};
-use models::{Crate, CrateOwner, Follow, Owner, OwnerKind, Team, Version};
+use models::{Crate, CrateOwner, Follow, Owner, OwnerKind, Rights, Team, Version};
 use schema::*;
 
 /// The model representing a row in the `users` database table.
@@ -190,6 +190,29 @@ impl User {
         Ok(users.collect())
     }
 
+    /// Given this set of owners, determines the strongest rights the
+    /// user has.
+    ///
+    /// Shortcircuits on `Full` because you can't beat it. In practice we'll always
+    /// see `[user, user, user, ..., team, team, team]`, so we could shortcircuit on
+    /// `Publish` as well, but this is a non-obvious invariant so we don't bother.
+    /// Sweet free optimization if teams are proving burdensome to check.
+    /// More than one team isn't really expected, though.
+    pub fn rights(&self, app: &App, owners: &[Owner]) -> CargoResult<Rights> {
+        let mut best = Rights::None;
+        for owner in owners {
+            match *owner {
+                Owner::User(ref other_user) => if other_user.id == self.id {
+                    return Ok(Rights::Full);
+                },
+                Owner::Team(ref team) => if team.contains_user(app, self)? {
+                    best = Rights::Publish;
+                },
+            }
+        }
+        Ok(best)
+    }
+
     /// Converts this `User` model into an `EncodablePrivateUser` for JSON serialization.
     pub fn encodable_private(
         self,

src/version/yank.rs

@@ -7,7 +7,6 @@ use diesel::prelude::*;
 use app::RequestApp;
 use db::RequestTransaction;
 use git;
-use owner::rights;
 use user::RequestUser;
 use util::errors::CargoError;
 use util::{human, CargoResult, RequestUtils};
@@ -41,7 +40,7 @@ fn modify_yank(req: &mut Request, yanked: bool) -> CargoResult<Response> {
     let user = req.user()?;
     let conn = req.db_conn()?;
     let owners = krate.owners(&conn)?;
-    if rights(req.app(), &owners, user)? < Rights::Publish {
+    if user.rights(req.app(), &owners)? < Rights::Publish {
         return Err(human("must already be an owner to yank or unyank"));
     }