Rename human to cargo_err

Author: jtgeibel

src/bin/enqueue-job.rs

@@ -1,4 +1,4 @@
-use cargo_registry::util::{human, AppError, AppResult};
+use cargo_registry::util::{cargo_err, AppError, AppResult};
 use cargo_registry::{db, env, tasks};
 use diesel::PgConnection;
 
@@ -14,7 +14,7 @@ fn main() -> AppResult<()> {
                 .unwrap_or_else(|| String::from("db-dump.tar.gz"));
             tasks::dump_db(database_url, target_name).enqueue(&conn)
         }
-        other => Err(human(&format!("Unrecognized job type `{}`", other))),
+        other => Err(cargo_err(&format!("Unrecognized job type `{}`", other))),
     }
 }
 

src/controllers.rs

@@ -6,7 +6,7 @@ mod prelude {
     pub use conduit_router::RequestParams;
 
     pub use crate::db::RequestTransaction;
-    pub use crate::util::{human, AppResult};
+    pub use crate::util::{cargo_err, AppResult};
 
     pub use crate::middleware::app::RequestApp;
     pub use crate::middleware::current_user::RequestUser;

src/controllers/crate_owner_invitation.rs

@@ -38,7 +38,7 @@ pub fn handle_invite(req: &mut dyn Request) -> AppResult<Response> {
     let conn = &*req.db_conn()?;
 
     let crate_invite: OwnerInvitation =
-        serde_json::from_str(&body).map_err(|_| human("invalid json request"))?;
+        serde_json::from_str(&body).map_err(|_| cargo_err("invalid json request"))?;
 
     let crate_invite = crate_invite.crate_owner_invite;
 

src/controllers/helpers/pagination.rs

@@ -18,7 +18,7 @@ impl Page {
         if let Some(s) = params.get("page") {
             let numeric_page = s.parse()?;
             if numeric_page < 1 {
-                return Err(human(&format_args!(
+                return Err(cargo_err(&format_args!(
                     "page indexing starts from 1, page {} is invalid",
                     numeric_page,
                 )));
@@ -48,7 +48,7 @@ impl PaginationOptions {
             .unwrap_or(Ok(DEFAULT_PER_PAGE))?;
 
         if per_page > MAX_PER_PAGE {
-            return Err(human(&format_args!(
+            return Err(cargo_err(&format_args!(
                 "cannot request more than {} items",
                 MAX_PER_PAGE,
             )));

src/controllers/krate/owners.rs

@@ -82,11 +82,11 @@ fn parse_owners_request(req: &mut dyn Request) -> AppResult<Vec<String>> {
         owners: Option<Vec<String>>,
     }
     let request: Request =
-        serde_json::from_str(&body).map_err(|_| human("invalid json request"))?;
+        serde_json::from_str(&body).map_err(|_| cargo_err("invalid json request"))?;
     request
         .owners
         .or(request.users)
-        .ok_or_else(|| human("invalid json request"))
+        .ok_or_else(|| cargo_err("invalid json request"))
 }
 
 fn modify_owners(req: &mut dyn Request, add: bool) -> AppResult<Response> {
@@ -104,10 +104,10 @@ fn modify_owners(req: &mut dyn Request, add: bool) -> AppResult<Response> {
             Rights::Full => {}
             // Yes!
             Rights::Publish => {
-                return Err(human("team members don't have permission to modify owners"));
+                return Err(cargo_err("team members don't have permission to modify owners"));
             }
             Rights::None => {
-                return Err(human("only owners have permission to modify owners"));
+                return Err(cargo_err("only owners have permission to modify owners"));
             }
         }
 
@@ -117,7 +117,7 @@ fn modify_owners(req: &mut dyn Request, add: bool) -> AppResult<Response> {
                 let login_test =
                     |owner: &Owner| owner.login().to_lowercase() == *login.to_lowercase();
                 if owners.iter().any(login_test) {
-                    return Err(human(&format_args!("`{}` is already an owner", login)));
+                    return Err(cargo_err(&format_args!("`{}` is already an owner", login)));
                 }
                 let msg = krate.owner_add(app, &conn, user, login)?;
                 msgs.push(msg);
@@ -128,7 +128,7 @@ fn modify_owners(req: &mut dyn Request, add: bool) -> AppResult<Response> {
                 krate.owner_remove(app, &conn, user, login)?;
             }
             if User::owning(&krate, &conn)?.is_empty() {
-                return Err(human(
+                return Err(cargo_err(
                     "cannot remove all individual owners of a crate. \
                      Team member don't have permission to modify owners, so \
                      at least one individual owner is required.",

src/controllers/krate/publish.rs

@@ -42,7 +42,7 @@ pub fn publish(req: &mut dyn Request) -> AppResult<Response> {
 
     let verified_email_address = user.verified_email(&conn)?;
     let verified_email_address = verified_email_address.ok_or_else(|| {
-        human(
+        cargo_err(
             "A verified email address is required to publish crates to crates.io. \
              Visit https://crates.io/me to set and verify your email address.",
         )
@@ -88,7 +88,7 @@ pub fn publish(req: &mut dyn Request) -> AppResult<Response> {
 
         let owners = krate.owners(&conn)?;
         if user.rights(req.app(), &owners)? < Rights::Publish {
-            return Err(human(
+            return Err(cargo_err(
                 "this crate exists but you don't seem to be an owner. \
                  If you believe this is a mistake, perhaps you need \
                  to accept an invitation to be an owner before \
@@ -97,7 +97,7 @@ pub fn publish(req: &mut dyn Request) -> AppResult<Response> {
         }
 
         if krate.name != *name {
-            return Err(human(&format_args!(
+            return Err(cargo_err(&format_args!(
                 "crate was previously named `{}`",
                 krate.name
             )));
@@ -111,7 +111,7 @@ pub fn publish(req: &mut dyn Request) -> AppResult<Response> {
 
         let content_length = req
             .content_length()
-            .chain_error(|| human("missing header: Content-Length"))?;
+            .chain_error(|| cargo_err("missing header: Content-Length"))?;
 
         let maximums = Maximums::new(
             krate.max_upload_size,
@@ -120,7 +120,7 @@ pub fn publish(req: &mut dyn Request) -> AppResult<Response> {
         );
 
         if content_length > maximums.max_upload_size {
-            return Err(human(&format_args!(
+            return Err(cargo_err(&format_args!(
                 "max upload size is: {}",
                 maximums.max_upload_size
             )));
@@ -221,13 +221,13 @@ fn parse_new_headers(req: &mut dyn Request) -> AppResult<(EncodableCrateUpload,
 
     let max = req.app().config.max_upload_size;
     if metadata_length > max {
-        return Err(human(&format_args!("max upload size is: {}", max)));
+        return Err(cargo_err(&format_args!("max upload size is: {}", max)));
     }
     let mut json = vec![0; metadata_length as usize];
     read_fill(req.body(), &mut json)?;
-    let json = String::from_utf8(json).map_err(|_| human("json body was not valid utf-8"))?;
+    let json = String::from_utf8(json).map_err(|_| cargo_err("json body was not valid utf-8"))?;
     let new: EncodableCrateUpload = serde_json::from_str(&json)
-        .map_err(|e| human(&format_args!("invalid upload request: {}", e)))?;
+        .map_err(|e| cargo_err(&format_args!("invalid upload request: {}", e)))?;
 
     // Make sure required fields are provided
     fn empty(s: Option<&String>) -> bool {
@@ -245,7 +245,7 @@ fn parse_new_headers(req: &mut dyn Request) -> AppResult<(EncodableCrateUpload,
         missing.push("authors");
     }
     if !missing.is_empty() {
-        return Err(human(&format_args!(
+        return Err(cargo_err(&format_args!(
             "missing or empty metadata fields: {}. Please \
              see https://doc.rust-lang.org/cargo/reference/manifest.html for \
              how to upload metadata",

src/controllers/user/me.rs

@@ -122,7 +122,7 @@ pub fn update_user(req: &mut dyn Request) -> AppResult<Response> {
 
     // need to check if current user matches user to be updated
     if &user.id.to_string() != name {
-        return Err(human("current user does not match requested user"));
+        return Err(cargo_err("current user does not match requested user"));
     }
 
     #[derive(Deserialize)]
@@ -136,17 +136,17 @@ pub fn update_user(req: &mut dyn Request) -> AppResult<Response> {
     }
 
     let user_update: UserUpdate =
-        serde_json::from_str(&body).map_err(|_| human("invalid json request"))?;
+        serde_json::from_str(&body).map_err(|_| cargo_err("invalid json request"))?;
 
     if user_update.user.email.is_none() {
-        return Err(human("empty email rejected"));
+        return Err(cargo_err("empty email rejected"));
     }
 
     let user_email = user_update.user.email.unwrap();
     let user_email = user_email.trim();
 
     if user_email == "" {
-        return Err(human("empty email rejected"));
+        return Err(cargo_err("empty email rejected"));
     }
 
     conn.transaction::<_, Box<dyn AppError>, _>(|| {
@@ -166,7 +166,7 @@ pub fn update_user(req: &mut dyn Request) -> AppResult<Response> {
             .set(&new_email)
             .returning(emails::token)
             .get_result::<String>(&*conn)
-            .map_err(|_| human("Error in creating token"))?;
+            .map_err(|_| cargo_err("Error in creating token"))?;
 
         crate::email::send_user_confirm_email(user_email, &user.gh_login, &token);
 
@@ -213,7 +213,7 @@ pub fn regenerate_token_and_send(req: &mut dyn Request) -> AppResult<Response> {
 
     // need to check if current user matches user to be updated
     if &user.id != name {
-        return Err(human("current user does not match requested user"));
+        return Err(cargo_err("current user does not match requested user"));
     }
 
     conn.transaction(|| {

src/controllers/user/session.rs

@@ -85,7 +85,7 @@ pub fn github_access_token(req: &mut dyn Request) -> AppResult<Response> {
         let session_state = req.session().remove(&"github_oauth_state".to_string());
         let session_state = session_state.as_ref().map(|a| &a[..]);
         if Some(&state[..]) != session_state {
-            return Err(human("invalid state parameter"));
+            return Err(cargo_err("invalid state parameter"));
         }
     }
 
@@ -96,7 +96,7 @@ pub fn github_access_token(req: &mut dyn Request) -> AppResult<Response> {
         .app()
         .github
         .exchange_code(code)
-        .map_err(|s| human(&s))?;
+        .map_err(|s| cargo_err(&s))?;
     let token = token.access_token();
     let ghuser = github::github_api::<GithubUser>(req.app(), "/user", token)?;
     let user = ghuser.save_to_database(&token.secret(), &*req.db_conn()?)?;

src/controllers/version.rs

@@ -12,7 +12,7 @@ fn version_and_crate(req: &mut dyn Request) -> AppResult<(Version, Crate)> {
     let crate_name = &req.params()["crate_id"];
     let semver = &req.params()["version"];
     if semver::Version::parse(semver).is_err() {
-        return Err(human(&format_args!("invalid semver: {}", semver)));
+        return Err(cargo_err(&format_args!("invalid semver: {}", semver)));
     };
     let conn = req.db_conn()?;
     let krate = Crate::by_name(crate_name).first::<Crate>(&*conn)?;
@@ -21,7 +21,7 @@ fn version_and_crate(req: &mut dyn Request) -> AppResult<(Version, Crate)> {
         .filter(versions::num.eq(semver))
         .first(&*conn)
         .map_err(|_| {
-            human(&format_args!(
+            cargo_err(&format_args!(
                 "crate `{}` does not have a version `{}`",
                 crate_name, semver
             ))

src/controllers/version/yank.rs

@@ -33,7 +33,7 @@ fn modify_yank(req: &mut dyn Request, yanked: bool) -> AppResult<Response> {
     let conn = req.db_conn()?;
     let owners = krate.owners(&conn)?;
     if user.rights(req.app(), &owners)? < Rights::Publish {
-        return Err(human("must already be an owner to yank or unyank"));
+        return Err(cargo_err("must already be an owner to yank or unyank"));
     }
 
     git::yank(krate.name, version, yanked)

src/github.rs

@@ -8,7 +8,7 @@ use serde::de::DeserializeOwned;
 use std::str;
 
 use crate::app::App;
-use crate::util::{errors::NotFound, human, internal, AppError, AppResult};
+use crate::util::{errors::NotFound, cargo_err, internal, AppError, AppResult};
 
 /// Does all the nonsense for sending a GET to Github. Doesn't handle parsing
 /// because custom error-code handling may be desirable. Use
@@ -35,7 +35,7 @@ fn handle_error_response(error: &reqwest::Error) -> Box<dyn AppError> {
     use reqwest::StatusCode as Status;
 
     match error.status() {
-        Some(Status::UNAUTHORIZED) | Some(Status::FORBIDDEN) => human(
+        Some(Status::UNAUTHORIZED) | Some(Status::FORBIDDEN) => cargo_err(
             "It looks like you don't have permission \
              to query a necessary property from Github \
              to complete this request. \

src/models/dependency.rs

@@ -1,7 +1,7 @@
 use diesel::prelude::*;
 
 use crate::git;
-use crate::util::{human, AppResult};
+use crate::util::{cargo_err, AppResult};
 
 use crate::models::{Crate, Version};
 use crate::schema::*;
@@ -82,16 +82,16 @@ pub fn add_dependencies(
         .map(|dep| {
             if let Some(registry) = &dep.registry {
                 if !registry.is_empty() {
-                    return Err(human(&format_args!("Dependency `{}` is hosted on another registry. Cross-registry dependencies are not permitted on crates.io.", &*dep.name)));
+                    return Err(cargo_err(&format_args!("Dependency `{}` is hosted on another registry. Cross-registry dependencies are not permitted on crates.io.", &*dep.name)));
                 }
             }
 
             // Match only identical names to ensure the index always references the original crate name
             let krate = Crate::by_exact_name(&dep.name)
                 .first::<Crate>(&*conn)
-                .map_err(|_| human(&format_args!("no known crate named `{}`", &*dep.name)))?;
+                .map_err(|_| cargo_err(&format_args!("no known crate named `{}`", &*dep.name)))?;
             if dep.version_req == semver::VersionReq::parse("*").unwrap() {
-                return Err(human(
+                return Err(cargo_err(
                     "wildcard (`*`) dependency constraints are not allowed \
                      on crates.io. See https://doc.rust-lang.org/cargo/faq.html#can-\
                      libraries-use--as-a-version-for-their-dependencies for more \

src/models/krate.rs

@@ -10,7 +10,7 @@ use crate::app::App;
 use crate::email;
 use crate::models::user;
 use crate::models::user::UserNoEmailType;
-use crate::util::{human, AppResult};
+use crate::util::{cargo_err, AppResult};
 
 use crate::models::{
     Badge, Category, CrateOwner, CrateOwnerInvitation, Keyword, NewCrateOwnerInvitation, Owner,
@@ -141,15 +141,15 @@ impl<'a> NewCrate<'a> {
             // Manually check the string, as `Url::parse` may normalize relative URLs
             // making it difficult to ensure that both slashes are present.
             if !url.starts_with("http://") && !url.starts_with("https://") {
-                return Err(human(&format_args!(
+                return Err(cargo_err(&format_args!(
                     "URL for field `{}` must begin with http:// or https:// (url: {})",
                     field, url
                 )));
             }
 
             // Ensure the entire URL parses as well
             Url::parse(url)
-                .map_err(|_| human(&format_args!("`{}` is not a valid url: `{}`", field, url)))?;
+                .map_err(|_| cargo_err(&format_args!("`{}` is not a valid url: `{}`", field, url)))?;
             Ok(())
         }
 
@@ -169,7 +169,7 @@ impl<'a> NewCrate<'a> {
         ))
         .get_result::<bool>(conn)?;
         if reserved_name {
-            Err(human("cannot upload a crate with a reserved name"))
+            Err(cargo_err("cannot upload a crate with a reserved name"))
         } else {
             Ok(())
         }

src/models/owner.rs

@@ -3,7 +3,7 @@ use diesel::prelude::*;
 
 use crate::app::App;
 use crate::github;
-use crate::util::{human, AppResult};
+use crate::util::{cargo_err, AppResult};
 
 use crate::models::user::{UserNoEmailType, ALL_COLUMNS};
 use crate::models::{Crate, Team, User};
@@ -77,7 +77,7 @@ impl Owner {
                 .first::<UserNoEmailType>(conn)
                 .map(User::from)
                 .map(Owner::User)
-                .map_err(|_| human(&format_args!("could not find user with login `{}`", name)))
+                .map_err(|_| cargo_err(&format_args!("could not find user with login `{}`", name)))
         }
     }