chore(fmt): cargo fmt with 1.85 and 2024

Author: junkurihara

Cargo.toml

@@ -3,14 +3,14 @@ members = ["httpsig", "httpsig-hyper"]
 resolver = "2"
 
 [workspace.package]
-edition = "2021"
+edition = "2024"
 version = "0.0.24"
 authors = ["Jun Kurihara"]
 homepage = "https://github.com/junkurihara/httpsig-rs"
 repository = "https://github.com/junkurihara/httpsig-rs"
 readme = "README.md"
 license = "MIT"
-rust-version = "1.75.0"
+rust-version = "1.85.0"
 categories = [
   "web-programming",
   "cryptography",

httpsig-hyper/src/hyper_content_digest.rs

@@ -1,10 +1,10 @@
-use super::{ContentDigestType, CONTENT_DIGEST_HEADER};
+use super::{CONTENT_DIGEST_HEADER, ContentDigestType};
 use crate::error::{HyperDigestError, HyperDigestResult};
-use base64::{engine::general_purpose, Engine as _};
+use base64::{Engine as _, engine::general_purpose};
 use bytes::Bytes;
 use http::{Request, Response};
 use http_body::Body;
-use http_body_util::{combinators::BoxBody, BodyExt, Full};
+use http_body_util::{BodyExt, Full, combinators::BoxBody};
 use sha2::Digest;
 use std::future::Future;
 use std::str::FromStr;

httpsig-hyper/src/hyper_http.rs

@@ -2,10 +2,10 @@ use crate::error::{HyperSigError, HyperSigResult};
 use http::{HeaderMap, Request, Response};
 use http_body::Body;
 use httpsig::prelude::{
+  AlgorithmName, HttpSignatureBase, HttpSignatureHeaders, HttpSignatureHeadersMap, HttpSignatureParams, SigningKey, VerifyingKey,
   message_component::{
     DerivedComponentName, HttpMessageComponent, HttpMessageComponentId, HttpMessageComponentName, HttpMessageComponentParam,
   },
-  AlgorithmName, HttpSignatureBase, HttpSignatureHeaders, HttpSignatureHeadersMap, HttpSignatureParams, SigningKey, VerifyingKey,
 };
 use indexmap::{IndexMap, IndexSet};
 use std::{future::Future, str::FromStr};
@@ -894,19 +894,17 @@ fn extract_derived_component<B>(
     DerivedComponentName::RequestTarget => match *req_or_res.method()? {
       http::Method::CONNECT => vec![req_or_res.uri()?.authority().map(|s| s.to_string()).unwrap_or("".to_string())],
       http::Method::OPTIONS => vec!["*".to_string()],
-      _ => vec![req_or_res
-        .uri()?
-        .path_and_query()
-        .map(|s| s.to_string())
-        .unwrap_or("".to_string())],
+      _ => vec![
+        req_or_res
+          .uri()?
+          .path_and_query()
+          .map(|s| s.to_string())
+          .unwrap_or("".to_string()),
+      ],
     },
     DerivedComponentName::Path => vec![{
       let p = req_or_res.uri()?.path();
-      if p.is_empty() {
-        "/".to_string()
-      } else {
-        p.to_string()
-      }
+      if p.is_empty() { "/".to_string() } else { p.to_string() }
     }],
     DerivedComponentName::Query => vec![req_or_res.uri()?.query().map(|v| format!("?{v}")).unwrap_or("?".to_string())],
     DerivedComponentName::QueryParam => {

httpsig/src/crypto/asymmetric.rs

@@ -4,22 +4,22 @@ use crate::{
   trace::*,
 };
 use ecdsa::{
-  elliptic_curve::{sec1::ToEncodedPoint, PublicKey as EcPublicKey, SecretKey as EcSecretKey},
+  elliptic_curve::{PublicKey as EcPublicKey, SecretKey as EcSecretKey, sec1::ToEncodedPoint},
   signature::{DigestSigner, DigestVerifier},
 };
 use ed25519_compact::{PublicKey as Ed25519PublicKey, SecretKey as Ed25519SecretKey};
 use p256::NistP256;
 use p384::NistP384;
-use pkcs8::{der::Decode, Document, PrivateKeyInfo};
+use pkcs8::{Document, PrivateKeyInfo, der::Decode};
 use sha2::{Digest, Sha256, Sha384};
 use spki::SubjectPublicKeyInfoRef;
 
 #[cfg(feature = "rsa-signature")]
 use rsa::{
+  RsaPrivateKey, RsaPublicKey,
   pkcs1::{DecodeRsaPrivateKey, DecodeRsaPublicKey, EncodeRsaPublicKey},
   pkcs1v15, pss,
   signature::{Keypair, RandomizedSigner, SignatureEncoding, Verifier},
-  RsaPrivateKey, RsaPublicKey,
 };
 
 #[allow(non_upper_case_globals, dead_code)]
@@ -406,7 +406,7 @@ impl super::VerifyingKey for PublicKey {
   /// - For Ed25519 keys, use the raw 32-byte public key.
   /// - For RSA keys, use the DER encoding of the RSAPublicKey structure in PKCS#1 format.
   fn key_id(&self) -> String {
-    use base64::{engine::general_purpose, Engine as _};
+    use base64::{Engine as _, engine::general_purpose};
 
     let bytes = match self {
       Self::EcdsaP256Sha256(vk) => vk.to_encoded_point(true).as_bytes().to_vec(),

httpsig/src/crypto/symmetric.rs

@@ -3,7 +3,7 @@ use crate::{
   error::{HttpSigError, HttpSigResult},
   trace::*,
 };
-use base64::{engine::general_purpose, Engine as _};
+use base64::{Engine as _, engine::general_purpose};
 use hmac::{Hmac, Mac};
 use sha2::{Digest, Sha256};
 

httpsig/src/lib.rs

@@ -32,7 +32,7 @@ pub mod prelude {
 #[cfg(test)]
 mod tests {
   use super::prelude::*;
-  use base64::{engine::general_purpose, Engine as _};
+  use base64::{Engine as _, engine::general_purpose};
 
   /* ----------------------------------------------------------------- */
   // params from https://datatracker.ietf.org/doc/html/rfc9421#name-signing-a-request-using-ed2

httpsig/src/message_component/component.rs

@@ -1,7 +1,7 @@
 use super::{
   component_id::HttpMessageComponentId,
   component_name::{DerivedComponentName, HttpMessageComponentName},
-  component_param::{handle_params_key_into, handle_params_sf, HttpMessageComponentParam},
+  component_param::{HttpMessageComponentParam, handle_params_key_into, handle_params_sf},
   component_value::HttpMessageComponentValue,
 };
 use crate::{

httpsig/src/signature_base.rs

@@ -2,10 +2,10 @@ use crate::{
   crypto::SigningKey,
   error::{HttpSigError, HttpSigResult},
   message_component::HttpMessageComponent,
-  prelude::{message_component::HttpMessageComponentId, VerifyingKey},
+  prelude::{VerifyingKey, message_component::HttpMessageComponentId},
   signature_params::HttpSignatureParams,
 };
-use base64::{engine::general_purpose, Engine as _};
+use base64::{Engine as _, engine::general_purpose};
 use indexmap::IndexMap;
 use rustc_hash::FxBuildHasher;
 use sfv::{BareItem, Item, ListEntry, Parser};

httpsig/src/signature_params.rs

@@ -5,7 +5,7 @@ use crate::{
   trace::*,
   util::has_unique_elements,
 };
-use base64::{engine::general_purpose, Engine as _};
+use base64::{Engine as _, engine::general_purpose};
 use rand::RngExt;
 use sfv::{FieldType, ListEntry, Parser};
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -123,11 +123,7 @@ impl HttpSignatureParams {
 impl std::fmt::Display for HttpSignatureParams {
   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     let joined = self.covered_components.iter().fold("".to_string(), |acc, v| {
-      if acc.is_empty() {
-        v.to_string()
-      } else {
-        format!("{acc} {v}")
-      }
+      if acc.is_empty() { v.to_string() } else { format!("{acc} {v}") }
     });
     let mut s: String = format!("({})", joined);
     if self.created.is_some() {