update macros; add v2 variants for internal use

Author: yoshuawuyts

src/auth/mod.rs

@@ -26,7 +26,9 @@
 mod authentication_scheme;
 mod authorization;
 mod basic_auth;
+mod www_authenticate;
 
 pub use authentication_scheme::AuthenticationScheme;
 pub use authorization::Authorization;
 pub use basic_auth::BasicAuth;
+pub use www_authenticate::WwwAuthenticate;

src/macros.rs

@@ -4,11 +4,11 @@ macro_rules! bail {
     ($msg:literal $(,)?) => {
         return $crate::private::Err($crate::format_err!($msg));
     };
-    ($err:expr $(,)?) => {
-        return $crate::private::Err($crate::format_err!($err));
+    ($msg:expr $(,)?) => {
+        return $crate::private::Err($crate::format_err!($msg));
     };
-    ($fmt:expr, $($arg:tt)*) => {
-        return $crate::private::Err($crate::format_err!($fmt, $($arg)*));
+    ($msg:expr, $($arg:tt)*) => {
+        return $crate::private::Err($crate::format_err!($msg, $($arg)*));
     };
 }
 
@@ -26,14 +26,14 @@ macro_rules! ensure {
             return $crate::private::Err($crate::format_err!($msg));
         }
     };
-    ($cond:expr, $err:expr $(,)?) => {
+    ($cond:expr, $msg:expr $(,)?) => {
         if !$cond {
-            return $crate::private::Err($crate::format_err!($err));
+            return $crate::private::Err($crate::format_err!($msg));
         }
     };
-    ($cond:expr, $fmt:expr, $($arg:tt)*) => {
+    ($cond:expr, $msg:expr, $($arg:tt)*) => {
         if !$cond {
-            return $crate::private::Err($crate::format_err!($fmt, $($arg)*));
+            return $crate::private::Err($crate::format_err!($msg, $($arg)*));
         }
     };
 }
@@ -52,14 +52,14 @@ macro_rules! ensure_eq {
             return $crate::private::Err($crate::format_err!($msg));
         }
     };
-    ($left:expr, $right:expr, $err:expr $(,)?) => {
+    ($left:expr, $right:expr, $msg:expr $(,)?) => {
         if $left != $right {
-            return $crate::private::Err($crate::format_err!($err));
+            return $crate::private::Err($crate::format_err!($msg));
         }
     };
-    ($left:expr, $right:expr, $fmt:expr, $($arg:tt)*) => {
+    ($left:expr, $right:expr, $msg:expr, $($arg:tt)*) => {
         if $left != $right {
-            return $crate::private::Err($crate::format_err!($fmt, $($arg)*));
+            return $crate::private::Err($crate::format_err!($msg, $($arg)*));
         }
     };
 }
@@ -84,3 +84,99 @@ macro_rules! format_err {
         $crate::private::new_adhoc(format!($fmt, $($arg)*))
     };
 }
+
+/// Return early with an error and a status code.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! bail2 {
+    ($status:literal, $msg:literal $(,)?) => {{
+        return $crate::private::Err($crate::format_err2!($status, $msg));
+    }};
+    ($status:literal, $msg:expr $(,)?) => {
+        return $crate::private::Err($crate::format_err2!($status, $msg));
+    };
+    ($status:literal, $msg:expr, $($arg:tt)*) => {
+        return $crate::private::Err($crate::format_err2!($status, $msg, $($arg)*));
+    };
+}
+
+/// Return early with an error if a condition is not satisfied.
+///
+/// This macro is equivalent to `if !$cond { return Err(From::from($err)); }`.
+///
+/// Analogously to `assert!`, `ensure!` takes a condition and exits the function
+/// if the condition fails. Unlike `assert!`, `ensure!` returns an `Error`
+/// rather than panicking.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! ensure2 {
+    ($cond:expr, $status:literal, $msg:literal $(,)?) => {
+        if !$cond {
+            return $crate::private::Err($crate::format_err2!($status, $msg));
+        }
+    };
+    ($cond:expr, $status:literal, $msg:expr $(,)?) => {
+        if !$cond {
+            return $crate::private::Err($crate::format_err2!($status, $msg));
+        }
+    };
+    ($cond:expr, $status:literal, $msg:expr, $($arg:tt)*) => {
+        if !$cond {
+            return $crate::private::Err($crate::format_err2!($status, $fmt, $($arg)*));
+        }
+    };
+}
+
+/// Return early with an error if two expressions are not equal to each other.
+///
+/// This macro is equivalent to `if $left != $right { return Err(From::from($err)); }`.
+///
+/// Analogously to `assert_eq!`, `ensure_eq!` takes two expressions and exits the function
+/// if the expressions are not equal. Unlike `assert_eq!`, `ensure_eq!` returns an `Error`
+/// rather than panicking.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! ensure_eq2 {
+    ($left:expr, $right:expr, $status:literal, $msg:literal $(,)?) => {
+        if $left != $right {
+            return $crate::private::Err($crate::format_err2!($status, $msg));
+        }
+    };
+    ($left:expr, $right:expr, $status:literal, $msg:expr $(,)?) => {
+        if $left != $right {
+            return $crate::private::Err($crate::format_err2!($status, $msg));
+        }
+    };
+    ($left:expr, $right:expr, $status:literal, $msg:expr, $($arg:tt)*) => {
+        if $left != $right {
+            return $crate::private::Err($crate::format_err2!($status, $msg, $($arg)*));
+        }
+    };
+}
+
+/// Construct an ad-hoc error from a string.
+///
+/// This evaluates to an `Error`. It can take either just a string, or a format
+/// string with arguments. It also can take any custom type which implements
+/// `Debug` and `Display`.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! format_err2 {
+    ($status:literal, $msg:literal $(,)?) => {{
+        // Handle $:literal as a special case to make cargo-expanded code more
+        // concise in the common case.
+        let mut err = $crate::private::new_adhoc($msg);
+        err.set_status($status);
+        err
+    }};
+    ($status:literal, $msg:expr $(,)?) => {{
+        let mut err = $crate::private::new_adhoc($msg);
+        err.set_status($status);
+        err
+    }};
+    ($status:literal, $msg:expr, $($arg:tt)*) => {{
+        let mut err = $crate::private::new_adhoc(format!($msg, $($arg)*))
+        err.set_status($status);
+        err
+    }};
+}