feat(crates-io): use std::result::Result everywhere

Author: weihanglo

crates/crates-io/lib.rs

@@ -7,7 +7,7 @@ use std::io::prelude::*;
 use std::io::{Cursor, SeekFrom};
 use std::time::Instant;
 
-use anyhow::{bail, format_err, Context, Result};
+use anyhow::{format_err, Context};
 use curl::easy::{Easy, List};
 use http_auth::ChallengeParser;
 use percent_encoding::{percent_encode, NON_ALPHANUMERIC};
@@ -200,7 +200,25 @@ impl fmt::Display for Error {
 
 impl From<curl::Error> for Error {
     fn from(error: curl::Error) -> Self {
-        Error::Curl(error)
+        Self::Curl(error)
+    }
+}
+
+impl From<anyhow::Error> for Error {
+    fn from(error: anyhow::Error) -> Self {
+        Self::Other(error)
+    }
+}
+
+impl From<serde_json::Error> for Error {
+    fn from(error: serde_json::Error) -> Self {
+        Self::Other(error.into())
+    }
+}
+
+impl From<url::ParseError> for Error {
+    fn from(error: url::ParseError) -> Self {
+        Self::Other(error.into())
     }
 }
 
@@ -236,10 +254,12 @@ impl Registry {
         self.token = token;
     }
 
-    fn token(&self) -> Result<&str> {
+    fn token(&self) -> Result<&str, Error> {
         let token = match self.token.as_ref() {
             Some(s) => s,
-            None => bail!("no upload token found, please run `cargo login`"),
+            None => {
+                return Err(format_err!("no upload token found, please run `cargo login`").into())
+            }
         };
         check_token(token)?;
         Ok(token)
@@ -253,26 +273,26 @@ impl Registry {
         is_url_crates_io(&self.host)
     }
 
-    pub fn add_owners(&mut self, krate: &str, owners: &[&str]) -> Result<String> {
+    pub fn add_owners(&mut self, krate: &str, owners: &[&str]) -> Result<String, Error> {
         let body = serde_json::to_string(&OwnersReq { users: owners })?;
         let body = self.put(&format!("/crates/{}/owners", krate), body.as_bytes())?;
         assert!(serde_json::from_str::<OwnerResponse>(&body)?.ok);
         Ok(serde_json::from_str::<OwnerResponse>(&body)?.msg)
     }
 
-    pub fn remove_owners(&mut self, krate: &str, owners: &[&str]) -> Result<()> {
+    pub fn remove_owners(&mut self, krate: &str, owners: &[&str]) -> Result<(), Error> {
         let body = serde_json::to_string(&OwnersReq { users: owners })?;
         let body = self.delete(&format!("/crates/{}/owners", krate), Some(body.as_bytes()))?;
         assert!(serde_json::from_str::<OwnerResponse>(&body)?.ok);
         Ok(())
     }
 
-    pub fn list_owners(&mut self, krate: &str) -> Result<Vec<User>> {
+    pub fn list_owners(&mut self, krate: &str) -> Result<Vec<User>, Error> {
         let body = self.get(&format!("/crates/{}/owners", krate))?;
         Ok(serde_json::from_str::<Users>(&body)?.users)
     }
 
-    pub fn publish(&mut self, krate: &NewCrate, mut tarball: &File) -> Result<Warnings> {
+    pub fn publish(&mut self, krate: &NewCrate, mut tarball: &File) -> Result<Warnings, Error> {
         let json = serde_json::to_string(krate)?;
         // Prepare the body. The format of the upload request is:
         //
@@ -366,7 +386,7 @@ impl Registry {
         })
     }
 
-    pub fn search(&mut self, query: &str, limit: u32) -> Result<(Vec<Crate>, u32)> {
+    pub fn search(&mut self, query: &str, limit: u32) -> Result<(Vec<Crate>, u32), Error> {
         let formatted_query = percent_encode(query.as_bytes(), NON_ALPHANUMERIC);
         let body = self.req(
             &format!("/crates?q={}&per_page={}", formatted_query, limit),
@@ -378,34 +398,34 @@ impl Registry {
         Ok((crates.crates, crates.meta.total))
     }
 
-    pub fn yank(&mut self, krate: &str, version: &str) -> Result<()> {
+    pub fn yank(&mut self, krate: &str, version: &str) -> Result<(), Error> {
         let body = self.delete(&format!("/crates/{}/{}/yank", krate, version), None)?;
         assert!(serde_json::from_str::<R>(&body)?.ok);
         Ok(())
     }
 
-    pub fn unyank(&mut self, krate: &str, version: &str) -> Result<()> {
+    pub fn unyank(&mut self, krate: &str, version: &str) -> Result<(), Error> {
         let body = self.put(&format!("/crates/{}/{}/unyank", krate, version), &[])?;
         assert!(serde_json::from_str::<R>(&body)?.ok);
         Ok(())
     }
 
-    fn put(&mut self, path: &str, b: &[u8]) -> Result<String> {
+    fn put(&mut self, path: &str, b: &[u8]) -> Result<String, Error> {
         self.handle.put(true)?;
         self.req(path, Some(b), Auth::Authorized)
     }
 
-    fn get(&mut self, path: &str) -> Result<String> {
+    fn get(&mut self, path: &str) -> Result<String, Error> {
         self.handle.get(true)?;
         self.req(path, None, Auth::Authorized)
     }
 
-    fn delete(&mut self, path: &str, b: Option<&[u8]>) -> Result<String> {
+    fn delete(&mut self, path: &str, b: Option<&[u8]>) -> Result<String, Error> {
         self.handle.custom_request("DELETE")?;
         self.req(path, b, Auth::Authorized)
     }
 
-    fn req(&mut self, path: &str, body: Option<&[u8]>, authorized: Auth) -> Result<String> {
+    fn req(&mut self, path: &str, body: Option<&[u8]>, authorized: Auth) -> Result<String, Error> {
         self.handle.url(&format!("{}/api/v1{}", self.host, path))?;
         let mut headers = List::new();
         headers.append("Accept: application/json")?;
@@ -426,10 +446,7 @@ impl Registry {
         }
     }
 
-    fn handle(
-        &mut self,
-        read: &mut dyn FnMut(&mut [u8]) -> usize,
-    ) -> std::result::Result<String, Error> {
+    fn handle(&mut self, read: &mut dyn FnMut(&mut [u8]) -> usize) -> Result<String, Error> {
         let mut headers = Vec::new();
         let mut body = Vec::new();
         {
@@ -604,9 +621,9 @@ pub fn is_url_crates_io(url: &str) -> bool {
 /// This check is necessary to prevent sending tokens which create an invalid HTTP request.
 /// It would be easier to check just for alphanumeric tokens, but we can't be sure that all
 /// registries only create tokens in that format so that is as less restricted as possible.
-pub fn check_token(token: &str) -> Result<()> {
+pub fn check_token(token: &str) -> Result<(), Error> {
     if token.is_empty() {
-        bail!("please provide a non-empty token");
+        return Err(format_err!("please provide a non-empty token").into());
     }
     if token.bytes().all(|b| {
         // This is essentially the US-ASCII limitation of
@@ -617,10 +634,11 @@ pub fn check_token(token: &str) -> Result<()> {
     }) {
         Ok(())
     } else {
-        Err(anyhow::anyhow!(
+        Err(format_err!(
             "token contains invalid characters.\nOnly printable ISO-8859-1 characters \
              are allowed as it is sent in a HTTPS header."
-        ))
+        )
+        .into())
     }
 }