Move directories, fix http, clippy

Cargo.toml

@@ -13,11 +13,11 @@ edition = "2021"
 
 [workspace]
 members = [
-  "http-signature-normalization-actix",
+  "actix",
-  "http-signature-normalization-actix-extractor",
+  "actix-extractor",
-  "http-signature-normalization-http",
+  "http",
-  "http-signature-normalization-reqwest",
+  "reqwest",
-  # "http-signature-normalization-warp",
+  # "warp",
 ]
 
 [dependencies]

actix-extractor/src/lib.rs

@@ -178,9 +178,7 @@ where
             .map_err(Into::into)?;
 
         let digest_parts = if D::REQUIRED {
-            req.headers()
+            req.headers().get("digest").and_then(parse_digest)
-                .get("digest")
-                .and_then(|digest| parse_digest(digest))
         } else {
             None
         };
@@ -214,10 +212,8 @@ where
             return Err(Error::Signature.into());
         }
 
-        if D::REQUIRED {
+        if D::REQUIRED && !digest_verifier.verify(digest_parts.as_deref().unwrap_or(&[])) {
-            if !digest_verifier.verify(digest_parts.as_deref().unwrap_or(&[])) {
+            return Err(Error::Digest.into());
-                return Err(Error::Digest.into());
-            }
         }
 
         let signature = Signature {

http/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "http-signature-normalization-http"
 description = "An HTTP Signatures library that leaves the signing to you"
-version = "0.4.0"
+version = "0.5.0"
 authors = ["asonix <asonix@asonix.dog>"]
 license-file = "../LICENSE"
 readme = "../README.md"

http/src/lib.rs

@@ -57,6 +57,15 @@ pub enum PrepareVerifyError {
     Header(ToStrError),
 }
 
+#[derive(Debug)]
+/// Errors produced when preparing to sign an Http Signature
+pub enum PrepareSignError {
+    /// There was an error in the underlying library
+    Required(http_signature_normalization::RequiredError),
+    /// There was an error producing a String from the HeaderValue
+    Header(ToStrError),
+}
+
 impl Config {
     /// Begin the process of signing a request
     ///
@@ -66,7 +75,7 @@ impl Config {
         method: &Method,
         path_and_query: Option<&PathAndQuery>,
         headers: HeaderMap,
-    ) -> Result<Unsigned, ToStrError> {
+    ) -> Result<Unsigned, PrepareSignError> {
         let headers = headers
             .iter()
             .map(|(k, v)| v.to_str().map(|v| (k.to_string(), v.to_string())))
@@ -74,11 +83,11 @@ impl Config {
 
         let path_and_query = path_and_query
             .map(|p| p.to_string())
-            .unwrap_or(String::from("/"));
+            .unwrap_or_else(|| String::from("/"));
 
         let unsigned = self
             .config
-            .begin_sign(&method.to_string(), &path_and_query, headers);
+            .begin_sign(method.as_ref(), &path_and_query, headers)?;
 
         Ok(Unsigned { unsigned })
     }
@@ -99,11 +108,11 @@ impl Config {
 
         let path_and_query = path_and_query
             .map(|p| p.to_string())
-            .unwrap_or(String::from("/"));
+            .unwrap_or_else(|| String::from("/"));
 
         let unverified = self
             .config
-            .begin_verify(&method.to_string(), &path_and_query, headers)?;
+            .begin_verify(method.as_ref(), &path_and_query, headers)?;
 
         Ok(unverified)
     }
@@ -118,14 +127,16 @@ impl fmt::Display for PrepareVerifyError {
     }
 }
 
-impl Error for PrepareVerifyError {
+impl fmt::Display for PrepareSignError {
-    fn description(&self) -> &str {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            PrepareVerifyError::Sig(ref e) => e.description(),
+            PrepareSignError::Required(ref e) => write!(f, "Required error, {}", e),
-            PrepareVerifyError::Header(ref e) => e.description(),
+            PrepareSignError::Header(ref e) => write!(f, "Header error, {}", e),
         }
     }
+}
 
+impl Error for PrepareVerifyError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
         match *self {
             PrepareVerifyError::Sig(ref e) => Some(e),
@@ -134,6 +145,15 @@ impl Error for PrepareVerifyError {
     }
 }
 
+impl Error for PrepareSignError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match *self {
+            PrepareSignError::Required(ref e) => Some(e),
+            PrepareSignError::Header(ref e) => Some(e),
+        }
+    }
+}
+
 impl From<http_signature_normalization::PrepareVerifyError> for PrepareVerifyError {
     fn from(e: http_signature_normalization::PrepareVerifyError) -> Self {
         PrepareVerifyError::Sig(e)
@@ -145,3 +165,15 @@ impl From<ToStrError> for PrepareVerifyError {
         PrepareVerifyError::Header(e)
     }
 }
+
+impl From<http_signature_normalization::RequiredError> for PrepareSignError {
+    fn from(e: http_signature_normalization::RequiredError) -> Self {
+        PrepareSignError::Required(e)
+    }
+}
+
+impl From<ToStrError> for PrepareSignError {
+    fn from(e: ToStrError) -> Self {
+        PrepareSignError::Header(e)
+    }
+}