Use internal macros for error handling

Author: yoshuawuyts

src/auth/authentication_scheme.rs

@@ -1,7 +1,7 @@
 use std::fmt::{self, Display};
 use std::str::FromStr;
 
-use crate::format_err;
+use crate::bail2 as bail;
 
 /// HTTP Mutual Authentication Algorithms
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
@@ -64,11 +64,7 @@ impl FromStr for AuthenticationScheme {
             "scram-sha-1" => Ok(Self::ScramSha1),
             "scram-sha-256" => Ok(Self::ScramSha256),
             "vapid" => Ok(Self::Vapid),
-            s => {
-                let mut err = format_err!("`{}` is not a recognized authentication scheme", s);
-                err.set_status(400);
-                Err(err)
-            }
+            s => bail!(400, "`{}` is not a recognized authentication scheme", s),
         }
     }
 }

src/auth/authorization.rs

@@ -1,5 +1,5 @@
 use crate::auth::AuthenticationScheme;
-use crate::bail;
+use crate::bail2 as bail;
 use crate::headers::{HeaderName, HeaderValue, Headers, AUTHORIZATION};
 
 /// Credentials to authenticate a user agent with a server.
@@ -60,8 +60,8 @@ impl Authorization {
         let scheme = iter.next();
         let credential = iter.next();
         let (scheme, credentials) = match (scheme, credential) {
-            (None, _) => bail!("Could not find scheme"),
-            (Some(_), None) => bail!("Could not find credentials"),
+            (None, _) => bail!(400, "Could not find scheme"),
+            (Some(_), None) => bail!(400, "Could not find credentials"),
             (Some(scheme), Some(credentials)) => (scheme.parse()?, credentials.to_owned()),
         };
 

src/auth/basic_auth.rs

@@ -1,7 +1,7 @@
 use crate::auth::{AuthenticationScheme, Authorization};
-use crate::format_err;
 use crate::headers::{HeaderName, HeaderValue, Headers, AUTHORIZATION};
 use crate::Status;
+use crate::{bail2 as bail, ensure2 as ensure};
 
 /// HTTP Basic authorization.
 ///
@@ -57,11 +57,12 @@ impl BasicAuth {
         };
 
         let scheme = auth.scheme();
-        if !matches!(scheme, AuthenticationScheme::Basic) {
-            let mut err = format_err!("Expected basic auth scheme found `{}`", scheme);
-            err.set_status(400);
-            return Err(err);
-        }
+        ensure!(
+            matches!(scheme, AuthenticationScheme::Basic),
+            400,
+            "Expected basic auth scheme found `{}`",
+            scheme
+        );
 
         let bytes = base64::decode(auth.credentials()).status(400)?;
         let credentials = String::from_utf8(bytes).status(400)?;
@@ -72,16 +73,8 @@ impl BasicAuth {
 
         let (username, password) = match (username, password) {
             (Some(username), Some(password)) => (username.to_string(), password.to_string()),
-            (Some(_), None) => {
-                let mut err = format_err!("Expected basic auth to a password");
-                err.set_status(400);
-                return Err(err);
-            }
-            (None, _) => {
-                let mut err = format_err!("Expected basic auth to contain a username");
-                err.set_status(400);
-                return Err(err);
-            }
+            (Some(_), None) => bail!(400, "Expected basic auth to a password"),
+            (None, _) => bail!(400, "Expected basic auth to contain a username"),
         };
 
         Ok(Some(Self { username, password }))

src/macros.rs

@@ -122,7 +122,7 @@ macro_rules! ensure2 {
     };
     ($cond:expr, $status:literal, $msg:expr, $($arg:tt)*) => {
         if !$cond {
-            return $crate::private::Err($crate::format_err2!($status, $fmt, $($arg)*));
+            return $crate::private::Err($crate::format_err2!($status, $msg, $($arg)*));
         }
     };
 }
@@ -175,7 +175,7 @@ macro_rules! format_err2 {
         err
     }};
     ($status:literal, $msg:expr, $($arg:tt)*) => {{
-        let mut err = $crate::private::new_adhoc(format!($msg, $($arg)*))
+        let mut err = $crate::private::new_adhoc(format!($msg, $($arg)*));
         err.set_status($status);
         err
     }};