run cargo fmt, fix merge issues

Signed-off-by: Wolf Vollprecht <[email protected]>

Author: wolfv

src/cosign/bundle.rs

@@ -88,7 +88,8 @@ impl Bundle {
         rekor_pub_keys: &BTreeMap<String, CosignVerificationKey>,
     ) -> Result<()> {
         let mut encoded = Vec::new();
-        let mut ser = serde_json::Serializer::with_formatter(&mut encoded, CanonicalFormatter::new());
+        let mut ser =
+            serde_json::Serializer::with_formatter(&mut encoded, CanonicalFormatter::new());
         bundle.payload.serialize(&mut ser).map_err(|e| {
             SigstoreError::UnexpectedError(format!("Cannot serialize bundle payload: {e:?}"))
         })?;

src/crypto/merkle/proof_verification.rs

@@ -1,9 +1,9 @@
 use super::rfc6962::Rfc6269HasherTrait;
+use MerkleProofError::*;
 use digest::{Digest, Output};
 use hex::ToHex;
 use std::cmp::Ordering;
 use std::fmt::Debug;
-use MerkleProofError::*;
 
 #[derive(Debug)]
 pub enum MerkleProofError {
@@ -101,17 +101,17 @@ where
                 return Self::verify_match(old_root, new_root).map_err(|_| MismatchedRoot {
                     got: new_root.encode_hex(),
                     expected: old_root.encode_hex(),
-                })
+                });
             }
 
             // the proof cannot be empty if the sizes are equal or the previous size was zero
             (Ordering::Equal, _, false) | (Ordering::Less, true, false) => {
-                return Err(UnexpectedNonEmptyProof)
+                return Err(UnexpectedNonEmptyProof);
             }
             // any proof is accepted if old_size == 0 and the hash is the expected empty hash
             (Ordering::Less, true, true) => {
                 return Self::verify_match(old_root, &Self::empty_root())
-                    .map_err(|_| WrongEmptyTreeHash)
+                    .map_err(|_| WrongEmptyTreeHash);
             }
             (Ordering::Less, false, true) => return Err(UnexpectedEmptyProof),
             (Ordering::Less, false, false) => {}

src/crypto/merkle/rfc6962.rs

@@ -47,8 +47,8 @@ pub(crate) type Rfc6269Default = Sha256;
 /// These tests were taken from the [transparency-dev Merkle implementation](https://github.com/transparency-dev/merkle/blob/036047b5d2f7faf3b1ee643d391e60fe5b1defcf/rfc6962/rfc6962_test.go).
 #[cfg(test)]
 mod test_rfc6962 {
-    use crate::crypto::merkle::rfc6962::Rfc6269HasherTrait;
     use crate::crypto::merkle::Rfc6269Default;
+    use crate::crypto::merkle::rfc6962::Rfc6269HasherTrait;
     use hex_literal::hex;
 
     #[derive(Debug, PartialEq)]

src/crypto/merkle/testdata_tests.rs

@@ -19,7 +19,7 @@
 
 use super::proof_verification::MerkleProofVerifier;
 use super::rfc6962::Rfc6269Default;
-use base64::{engine::general_purpose::STANDARD as base64, Engine as _};
+use base64::{Engine as _, engine::general_purpose::STANDARD as base64};
 use digest::Output;
 use rstest::rstest;
 use serde::Deserialize;
@@ -69,13 +69,11 @@ fn decode_base64_hash(s: &str) -> Result<Output<Rfc6269Default>, String> {
 }
 
 #[rstest]
-fn test_inclusion_proof(
-    #[files("tests/data/merkle/testdata/inclusion/**/*.json")] path: PathBuf,
-) {
-    let content = fs::read_to_string(&path)
-        .unwrap_or_else(|_| panic!("Failed to read file: {:?}", path));
-    let vector: InclusionProofTestVector =
-        serde_json::from_str(&content).unwrap_or_else(|e| panic!("Failed to parse {:?}: {}", path, e));
+fn test_inclusion_proof(#[files("tests/data/merkle/testdata/inclusion/**/*.json")] path: PathBuf) {
+    let content =
+        fs::read_to_string(&path).unwrap_or_else(|_| panic!("Failed to read file: {:?}", path));
+    let vector: InclusionProofTestVector = serde_json::from_str(&content)
+        .unwrap_or_else(|e| panic!("Failed to parse {:?}: {}", path, e));
 
     // Try to decode - if any decoding fails and we expect an error, accept it
     let root_result = decode_base64_hash(&vector.root);
@@ -120,10 +118,10 @@ fn test_inclusion_proof(
 fn test_consistency_proof(
     #[files("tests/data/merkle/testdata/consistency/**/*.json")] path: PathBuf,
 ) {
-    let content = fs::read_to_string(&path)
-        .unwrap_or_else(|_| panic!("Failed to read file: {:?}", path));
-    let vector: ConsistencyProofTestVector =
-        serde_json::from_str(&content).unwrap_or_else(|e| panic!("Failed to parse {:?}: {}", path, e));
+    let content =
+        fs::read_to_string(&path).unwrap_or_else(|_| panic!("Failed to read file: {:?}", path));
+    let vector: ConsistencyProofTestVector = serde_json::from_str(&content)
+        .unwrap_or_else(|e| panic!("Failed to parse {:?}: {}", path, e));
 
     // Try to decode - if any decoding fails and we expect an error, accept it
     let root1_result = decode_base64_hash(&vector.root1);
@@ -134,8 +132,7 @@ fn test_consistency_proof(
         .map(|p| p.iter().map(|h| decode_base64_hash(h)).collect())
         .unwrap_or(Ok(Vec::new()));
 
-    if (root1_result.is_err() || root2_result.is_err() || proof_result.is_err())
-        && vector.want_err
+    if (root1_result.is_err() || root2_result.is_err() || proof_result.is_err()) && vector.want_err
     {
         // Expected error due to invalid input
         return;

src/registry/oci_caching_client.rs

@@ -245,7 +245,7 @@ async fn pull_manifest_cached(
 impl ClientCapabilitiesDeps for OciCachingClient {}
 
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-#[cfg_attr(target_arch = "wasm32", async_trait(? Send))]
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 impl ClientCapabilities for OciCachingClient {
     async fn fetch_manifest_digest(
         &mut self,

src/rekor/models/checkpoint.rs

@@ -3,8 +3,8 @@ use crate::crypto::{CosignVerificationKey, Signature};
 use crate::errors::SigstoreError;
 use crate::errors::SigstoreError::ConsistencyProofError;
 use crate::rekor::models::checkpoint::ParseCheckpointError::*;
-use base64::prelude::BASE64_STANDARD;
 use base64::Engine;
+use base64::prelude::BASE64_STANDARD;
 use digest::Output;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt::Write;
@@ -239,7 +239,8 @@ mod test {
                     9944,
                     [1; 32],
                     vec![],
-                    "Banana Checkpoint v5\n9944\nAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=\n", ),
+                    "Banana Checkpoint v5\n9944\nAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=\n",
+                ),
                 (
                     "Banana Checkpoint v7",
                     9943,
@@ -280,7 +281,8 @@ mod test {
                     9944,
                     [1; 32],
                     vec![],
-                    "Banana Checkpoint v5\n9944\nAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=\n", ),
+                    "Banana Checkpoint v5\n9944\nAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=\n",
+                ),
                 (
                     "valid with multiple trailing data lines",
                     "Banana Checkpoint v7",
@@ -294,7 +296,10 @@ mod test {
                     "Banana Checkpoint v7",
                     9943,
                     [2; 32],
-                    vec![KeyValue("Timestamp".to_string(), "1689748607742585419".to_string())],
+                    vec![KeyValue(
+                        "Timestamp".to_string(),
+                        "1689748607742585419".to_string(),
+                    )],
                     "Banana Checkpoint v7\n9943\nAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI=\nTimestamp: 1689748607742585419\n",
                 ),
                 (
@@ -322,22 +327,24 @@ mod test {
 
         #[test]
         fn test_unmarshal_invalid() {
-            let test_cases = [(
-                "invalid - insufficient lines",
-                "Head\n9944\n",
-            ), (
-                "invalid - empty header",
-                "\n9944\ndGhlIHZpZXcgZnJvbSB0aGUgdHJlZSB0b3BzIGlzIGdyZWF0IQ==\n",
-            ), (
-                "invalid - missing newline on roothash",
-                "Log Checkpoint v0\n123\nYmFuYW5hcw==",
-            ), (
-                "invalid size - not a number",
-                "Log Checkpoint v0\nbananas\ndGhlIHZpZXcgZnJvbSB0aGUgdHJlZSB0b3BzIGlzIGdyZWF0IQ==\n",
-            ), (
-                "invalid size - negative",
-                "Log Checkpoint v0\n-34\ndGhlIHZpZXcgZnJvbSB0aGUgdHJlZSB0b3BzIGlzIGdyZWF0IQ==\n",
-            ),
+            let test_cases = [
+                ("invalid - insufficient lines", "Head\n9944\n"),
+                (
+                    "invalid - empty header",
+                    "\n9944\ndGhlIHZpZXcgZnJvbSB0aGUgdHJlZSB0b3BzIGlzIGdyZWF0IQ==\n",
+                ),
+                (
+                    "invalid - missing newline on roothash",
+                    "Log Checkpoint v0\n123\nYmFuYW5hcw==",
+                ),
+                (
+                    "invalid size - not a number",
+                    "Log Checkpoint v0\nbananas\ndGhlIHZpZXcgZnJvbSB0aGUgdHJlZSB0b3BzIGlzIGdyZWF0IQ==\n",
+                ),
+                (
+                    "invalid size - negative",
+                    "Log Checkpoint v0\n-34\ndGhlIHZpZXcgZnJvbSB0aGUgdHJlZSB0b3BzIGlzIGdyZWF0IQ==\n",
+                ),
                 (
                     "invalid size - too large",
                     "Log Checkpoint v0\n3438945738945739845734895735\ndGhlIHZpZXcgZnJvbSB0aGUgdHJlZSB0b3BzIGlzIGdyZWF0IQ==\n",

src/rekor/models/inclusion_proof.rs

@@ -8,14 +8,14 @@
  * Generated by: https://openapi-generator.tech
  */
 
+use crate::crypto::CosignVerificationKey;
 use crate::crypto::merkle::{
-    hex_to_hash_output, MerkleProofVerifier, Rfc6269Default, Rfc6269HasherTrait,
+    MerkleProofVerifier, Rfc6269Default, Rfc6269HasherTrait, hex_to_hash_output,
 };
-use crate::crypto::CosignVerificationKey;
 use crate::errors::SigstoreError;
 use crate::errors::SigstoreError::{InclusionProofError, UnexpectedError};
-use crate::rekor::models::checkpoint::Checkpoint;
 use crate::rekor::TreeSize;
+use crate::rekor::models::checkpoint::Checkpoint;
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]

src/rekor/models/log_entry.rs

@@ -19,8 +19,8 @@ use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STD_ENGINE
 
 use crate::crypto::CosignVerificationKey;
 use crate::errors::SigstoreError::UnexpectedError;
-use crate::rekor::models::checkpoint::Checkpoint;
 use crate::rekor::models::InclusionProof as InclusionProof2;
+use crate::rekor::models::checkpoint::Checkpoint;
 use olpc_cjson::CanonicalFormatter;
 use serde::{Deserialize, Serialize};
 use serde_json::{Error, Value, json};
@@ -161,9 +161,14 @@ impl LogEntry {
             .and_then(|proof| {
                 // encode as canonical JSON
                 let mut encoded_entry = Vec::new();
-                let mut ser = serde_json::Serializer::with_formatter(&mut encoded_entry, CanonicalFormatter::new());
+                let mut ser = serde_json::Serializer::with_formatter(
+                    &mut encoded_entry,
+                    CanonicalFormatter::new(),
+                );
                 self.body.serialize(&mut ser).map_err(|e| {
-                    SigstoreError::UnexpectedError(format!("Cannot serialize log entry body: {e:?}"))
+                    SigstoreError::UnexpectedError(format!(
+                        "Cannot serialize log entry body: {e:?}"
+                    ))
                 })?;
                 proof.verify(&encoded_entry, rekor_key)
             })

src/rekor/models/log_info.rs

@@ -8,12 +8,12 @@
  * Generated by: https://openapi-generator.tech
  */
 
-use crate::crypto::merkle::hex_to_hash_output;
 use crate::crypto::CosignVerificationKey;
+use crate::crypto::merkle::hex_to_hash_output;
 use crate::errors::SigstoreError;
-use crate::rekor::models::checkpoint::Checkpoint;
-use crate::rekor::models::ConsistencyProof;
 use crate::rekor::TreeSize;
+use crate::rekor::models::ConsistencyProof;
+use crate::rekor::models::checkpoint::Checkpoint;
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]