cargo clippy

7 files changed, 62 insertions, 77 deletions

diff --git a/adenosine/src/identifiers.rs b/adenosine/src/identifiers.rs
index 7e93d71..33c2dbe 100644
--- a/adenosine/src/identifiers.rs
+++ b/adenosine/src/identifiers.rs
@@ -40,8 +40,8 @@ impl FromStr for DidOrHost {
 impl fmt::Display for DidOrHost {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Host(v) => write!(f, "{}", v),
-            Self::Did(m, v) => write!(f, "did:{}:{}", m, v),
+            Self::Host(v) => write!(f, "{v}"),
+            Self::Did(m, v) => write!(f, "did:{m}:{v}"),
         }
     }
 }
@@ -101,13 +101,13 @@ impl fmt::Display for AtUri {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "at://{}", self.repository)?;
         if let Some(ref c) = self.collection {
-            write!(f, "/{}", c)?;
+            write!(f, "/{c}")?;
         };
         if let Some(ref r) = self.record {
-            write!(f, "/{}", r)?;
+            write!(f, "/{r}")?;
         };
         if let Some(ref v) = self.fragment {
-            write!(f, "#{}", v)?;
+            write!(f, "#{v}")?;
         };
         Ok(())
     }
@@ -402,13 +402,13 @@ fn test_ticker() {
     let mut prev = ticker.next_tid();
     let mut next = ticker.next_tid();
     for _ in [0..100] {
-        println!("{} >? {}", next, prev);
+        println!("{next} >? {prev}");
         assert!(next > prev);
         prev = next;
         next = ticker.next_tid();
     }
-    println!("{}", prev);
-    assert_eq!(prev, Tid::from_str(&prev.to_string()).unwrap());
+    println!("{prev}");
+    assert_eq!(prev, Tid::from_str(&prev).unwrap());
     assert_eq!(next[13..16], prev[13..16]);
 
     let mut other_ticker = Ticker::new();
diff --git a/adenosine/src/lib.rs b/adenosine/src/lib.rs
index 49701a1..06e3174 100644
--- a/adenosine/src/lib.rs
+++ b/adenosine/src/lib.rs
@@ -32,7 +32,7 @@ pub fn created_at_now() -> String {
 fn test_created_at_now() {
     // eg: 2022-11-22T09:20:44.123Z
     let ts = created_at_now();
-    println!("{}", ts);
+    println!("{ts}");
     assert_eq!(&ts[4..5], "-");
     assert_eq!(&ts[7..8], "-");
     assert_eq!(&ts[10..11], "T");
diff --git a/adenosine/src/mst.rs b/adenosine/src/mst.rs
index 1d75da1..0d66d5a 100644
--- a/adenosine/src/mst.rs
+++ b/adenosine/src/mst.rs
@@ -110,7 +110,7 @@ pub fn dump_mst_keys(db_path: &PathBuf) -> Result<()> {
     // print all the aliases
     for (alias, commit_cid) in all_aliases.iter() {
         let did = String::from_utf8_lossy(alias);
-        println!("{} -> {}", did, commit_cid);
+        println!("{did} -> {commit_cid}");
     }
 
     let (did, commit_cid) = all_aliases[0].clone();
@@ -146,7 +146,7 @@ pub fn dump_mst_keys(db_path: &PathBuf) -> Result<()> {
     debug!("MST root node: {:?}", mst_node);
     debug!("============");
 
-    println!("{}", did);
+    println!("{did}");
     print_mst_keys(&mut db, &root.data)?;
     Ok(())
 }
@@ -389,7 +389,7 @@ fn test_mst_node_cbor() {
         }],
     };
     let block = Block::<DefaultParams>::encode(DagCborCodec, Code::Sha2_256, &node).unwrap();
-    println!("{:?}", block);
+    println!("{block:?}");
     //assert_eq!(1, 2);
     let cid = *block.cid();
     assert_eq!(
diff --git a/adenosine/src/plc.rs b/adenosine/src/plc.rs
index c7d7d10..cdedfb9 100644
--- a/adenosine/src/plc.rs
+++ b/adenosine/src/plc.rs
@@ -294,7 +294,7 @@ fn test_debug_did_plc() {
     let _did_plc = "did:plc:cg2dfxdh5voabmdjzw2abw3s";
 
     let digest_bytes: Vec<u8> = data_encoding::HEXLOWER
-        .decode(&sha256::digest(op_bytes).as_bytes())
+        .decode(sha256::digest(op_bytes).as_bytes())
         .expect("SHA-256 digest is always hex string");
     let digest_b32 = data_encoding::BASE32_NOPAD
         .encode(&digest_bytes)
@@ -350,7 +350,7 @@ fn test_self_verify() {
         &keypair,
         None,
     );
-    println!("{:?}", op);
+    println!("{op:?}");
     op.verify_self().unwrap();
 }
 
@@ -363,6 +363,6 @@ fn test_known_key() {
         &keypair,
         None,
     );
-    println!("{:?}", op);
+    println!("{op:?}");
     op.verify_self().unwrap();
 }
diff --git a/adenosine/src/repo.rs b/adenosine/src/repo.rs
index 2383e52..280fe6d 100644
--- a/adenosine/src/repo.rs
+++ b/adenosine/src/repo.rs
@@ -196,7 +196,7 @@ impl RepoStore {
         } else {
             return Ok(None);
         };
-        let record_key = format!("/{}/{}", collection, tid);
+        let record_key = format!("/{collection}/{tid}");
         self.get_mst_record_by_key(&commit.mst_cid, &record_key)
     }
 
@@ -244,14 +244,14 @@ impl RepoStore {
             match m {
                 Mutation::Create(collection, tid, val) => {
                     let cid = self.put_ipld(val)?;
-                    cid_map.insert(format!("/{}/{}", collection, tid), cid);
+                    cid_map.insert(format!("/{collection}/{tid}"), cid);
                 }
                 Mutation::Update(collection, tid, val) => {
                     let cid = self.put_ipld(val)?;
-                    cid_map.insert(format!("/{}/{}", collection, tid), cid);
+                    cid_map.insert(format!("/{collection}/{tid}"), cid);
                 }
                 Mutation::Delete(collection, tid) => {
-                    cid_map.remove(&format!("/{}/{}", collection, tid));
+                    cid_map.remove(&format!("/{collection}/{tid}"));
                 }
             }
         }
@@ -378,16 +378,10 @@ fn test_repo_mst() {
         .unwrap()
         .is_none());
 
-    map.insert("/blobs/1".to_string(), blob_cid.clone());
-    map.insert("/blobs/2".to_string(), blob_cid.clone());
-    map.insert(
-        "/test.records/44444444444444".to_string(),
-        record_cid.clone(),
-    );
-    map.insert(
-        "/test.records/22222222222222".to_string(),
-        record_cid.clone(),
-    );
+    map.insert("/blobs/1".to_string(), blob_cid);
+    map.insert("/blobs/2".to_string(), blob_cid);
+    map.insert("/test.records/44444444444444".to_string(), record_cid);
+    map.insert("/test.records/22222222222222".to_string(), record_cid);
     let simple_map_cid = repo.mst_from_map(&map).unwrap();
     assert_eq!(map, repo.mst_to_map(&simple_map_cid).unwrap());
 
@@ -423,15 +417,9 @@ fn test_repo_mst() {
         )
         .unwrap()
         .is_none());
-    assert_eq!(
-        Some(simple_commit_cid.clone()),
-        repo.lookup_commit(&did).unwrap()
-    );
+    assert_eq!(Some(simple_commit_cid), repo.lookup_commit(&did).unwrap());
 
-    map.insert(
-        "/test.records/33333333333333".to_string(),
-        record_cid.clone(),
-    );
+    map.insert("/test.records/33333333333333".to_string(), record_cid);
     let simple3_map_cid = repo.mst_from_map(&map).unwrap();
     let simple3_root_cid = repo
         .write_root(meta_cid, Some(simple_commit_cid), simple3_map_cid)
@@ -459,8 +447,5 @@ fn test_repo_mst() {
     assert_eq!(commit.did, did);
     assert_eq!(commit.prev, Some(simple_commit_cid));
     assert_eq!(commit.mst_cid, simple3_map_cid);
-    assert_eq!(
-        Some(simple3_commit_cid.clone()),
-        repo.lookup_commit(&did).unwrap()
-    );
+    assert_eq!(Some(simple3_commit_cid), repo.lookup_commit(&did).unwrap());
 }
diff --git a/adenosine/src/xrpc.rs b/adenosine/src/xrpc.rs
index 382c7fb..97caa4d 100644
--- a/adenosine/src/xrpc.rs
+++ b/adenosine/src/xrpc.rs
@@ -36,7 +36,7 @@ impl XrpcClient {
     pub fn new(host: String, auth_token: Option<String>) -> Result<Self> {
         let mut headers = header::HeaderMap::new();
         if let Some(token) = &auth_token {
-            let mut auth_value = header::HeaderValue::from_str(&format!("Bearer {}", token))?;
+            let mut auth_value = header::HeaderValue::from_str(&format!("Bearer {token}"))?;
             auth_value.set_sensitive(true);
             headers.insert(header::AUTHORIZATION, auth_value);
         };
@@ -61,7 +61,7 @@ impl XrpcClient {
         let params: HashMap<String, String> = params.unwrap_or_default();
         let res = self
             .http_client
-            .get(format!("{}/xrpc/{}", self.host, nsid))
+            .get(format!("{}/xrpc/{nsid}", self.host))
             .query(&params)
             .send()?;
         // TODO: refactor this error handling stuff into single method
diff --git a/adenosine/tests/test_mst_interop.rs b/adenosine/tests/test_mst_interop.rs
index ee45019..cfc8727 100644
--- a/adenosine/tests/test_mst_interop.rs
+++ b/adenosine/tests/test_mst_interop.rs
@@ -16,25 +16,25 @@ fn test_known_maps() {
     );
 
     let mut trivial_map: BTreeMap<String, Cid> = Default::default();
-    trivial_map.insert("asdf".to_string(), cid1.clone());
+    trivial_map.insert("asdf".to_string(), cid1);
     assert_eq!(
         repo.mst_from_map(&trivial_map).unwrap().to_string(),
         "bafyreidaftbr35xhh4lzmv5jcoeufqjh75ohzmz6u56v7n2ippbtxdgqqe"
     );
 
     let mut singlelayer2_map: BTreeMap<String, Cid> = Default::default();
-    singlelayer2_map.insert("com.example.record/9ba1c7247ede".to_string(), cid1.clone());
+    singlelayer2_map.insert("com.example.record/9ba1c7247ede".to_string(), cid1);
     assert_eq!(
         repo.mst_from_map(&singlelayer2_map).unwrap().to_string(),
         "bafyreid4g5smj6ukhrjasebt6myj7wmtm2eijouteoyueoqgoh6vm5jkae"
     );
 
     let mut simple_map: BTreeMap<String, Cid> = Default::default();
-    simple_map.insert("asdf".to_string(), cid1.clone());
-    simple_map.insert("88bfafc7".to_string(), cid1.clone());
-    simple_map.insert("2a92d355".to_string(), cid1.clone());
-    simple_map.insert("app.bsky.feed.post/454397e440ec".to_string(), cid1.clone());
-    simple_map.insert("app.bsky.feed.post/9adeb165882c".to_string(), cid1.clone());
+    simple_map.insert("asdf".to_string(), cid1);
+    simple_map.insert("88bfafc7".to_string(), cid1);
+    simple_map.insert("2a92d355".to_string(), cid1);
+    simple_map.insert("app.bsky.feed.post/454397e440ec".to_string(), cid1);
+    simple_map.insert("app.bsky.feed.post/9adeb165882c".to_string(), cid1);
     assert_eq!(
         repo.mst_from_map(&simple_map).unwrap().to_string(),
         "bafyreiecb33zh7r2sc3k2wthm6exwzfktof63kmajeildktqc25xj6qzx4"
@@ -50,11 +50,11 @@ fn test_tricky_map() {
         Cid::from_str("bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454").unwrap();
 
     let mut tricky_map: BTreeMap<String, Cid> = Default::default();
-    tricky_map.insert("".to_string(), cid1.clone());
-    tricky_map.insert("jalapeño".to_string(), cid1.clone());
-    tricky_map.insert("coöperative".to_string(), cid1.clone());
-    tricky_map.insert("coüperative".to_string(), cid1.clone());
-    tricky_map.insert("abc\x00".to_string(), cid1.clone());
+    tricky_map.insert("".to_string(), cid1);
+    tricky_map.insert("jalapeño".to_string(), cid1);
+    tricky_map.insert("coöperative".to_string(), cid1);
+    tricky_map.insert("coüperative".to_string(), cid1);
+    tricky_map.insert("abc\x00".to_string(), cid1);
     assert_eq!(
         repo.mst_from_map(&tricky_map).unwrap().to_string(),
         "bafyreiecb33zh7r2sc3k2wthm6exwzfktof63kmajeildktqc25xj6qzx4"
@@ -74,12 +74,12 @@ fn test_trims_top() {
 
     // NOTE: this test doesn't do much in this case of rust implementation
     let mut trim_map: BTreeMap<String, Cid> = Default::default();
-    trim_map.insert("com.example.record/40c73105b48f".to_string(), cid1.clone()); // level 0
-    trim_map.insert("com.example.record/e99bf3ced34b".to_string(), cid1.clone()); // level 0
-    trim_map.insert("com.example.record/893e6c08b450".to_string(), cid1.clone()); // level 0
-    trim_map.insert("com.example.record/9cd8b6c0cc02".to_string(), cid1.clone()); // level 0
-    trim_map.insert("com.example.record/cbe72d33d12a".to_string(), cid1.clone()); // level 0
-    trim_map.insert("com.example.record/a15e33ba0f6c".to_string(), cid1.clone()); // level 1
+    trim_map.insert("com.example.record/40c73105b48f".to_string(), cid1); // level 0
+    trim_map.insert("com.example.record/e99bf3ced34b".to_string(), cid1); // level 0
+    trim_map.insert("com.example.record/893e6c08b450".to_string(), cid1); // level 0
+    trim_map.insert("com.example.record/9cd8b6c0cc02".to_string(), cid1); // level 0
+    trim_map.insert("com.example.record/cbe72d33d12a".to_string(), cid1); // level 0
+    trim_map.insert("com.example.record/a15e33ba0f6c".to_string(), cid1); // level 1
     let trim_before_cid = repo.mst_from_map(&trim_map).unwrap();
     print_mst_keys(&mut repo.db, &trim_before_cid).unwrap();
     assert_eq!(trim_before_cid.to_string(), l1root);
@@ -103,21 +103,21 @@ fn test_insertion() {
 
     // TODO: actual mutation instead of rebuild from scratch
     let mut insertion_map: BTreeMap<String, Cid> = Default::default();
-    insertion_map.insert("com.example.record/403e2aeebfdb".to_string(), cid1.clone()); // A; level 0
-    insertion_map.insert("com.example.record/40c73105b48f".to_string(), cid1.clone()); // B; level 0
-    insertion_map.insert("com.example.record/645787eb4316".to_string(), cid1.clone()); // C; level 0
-    insertion_map.insert("com.example.record/7ca4e61d6fbc".to_string(), cid1.clone()); // D; level 1
-    insertion_map.insert("com.example.record/893e6c08b450".to_string(), cid1.clone()); // E; level 0
-    insertion_map.insert("com.example.record/9cd8b6c0cc02".to_string(), cid1.clone()); // G; level 0
-    insertion_map.insert("com.example.record/cbe72d33d12a".to_string(), cid1.clone()); // H; level 0
-    insertion_map.insert("com.example.record/dbea731be795".to_string(), cid1.clone()); // I; level 1
-    insertion_map.insert("com.example.record/e2ef555433f2".to_string(), cid1.clone()); // J; level 0
-    insertion_map.insert("com.example.record/e99bf3ced34b".to_string(), cid1.clone()); // K; level 0
-    insertion_map.insert("com.example.record/f728ba61e4b6".to_string(), cid1.clone()); // L; level 0
+    insertion_map.insert("com.example.record/403e2aeebfdb".to_string(), cid1); // A; level 0
+    insertion_map.insert("com.example.record/40c73105b48f".to_string(), cid1); // B; level 0
+    insertion_map.insert("com.example.record/645787eb4316".to_string(), cid1); // C; level 0
+    insertion_map.insert("com.example.record/7ca4e61d6fbc".to_string(), cid1); // D; level 1
+    insertion_map.insert("com.example.record/893e6c08b450".to_string(), cid1); // E; level 0
+    insertion_map.insert("com.example.record/9cd8b6c0cc02".to_string(), cid1); // G; level 0
+    insertion_map.insert("com.example.record/cbe72d33d12a".to_string(), cid1); // H; level 0
+    insertion_map.insert("com.example.record/dbea731be795".to_string(), cid1); // I; level 1
+    insertion_map.insert("com.example.record/e2ef555433f2".to_string(), cid1); // J; level 0
+    insertion_map.insert("com.example.record/e99bf3ced34b".to_string(), cid1); // K; level 0
+    insertion_map.insert("com.example.record/f728ba61e4b6".to_string(), cid1); // L; level 0
     let insertion_before_cid = repo.mst_from_map(&insertion_map).unwrap();
     assert_eq!(insertion_before_cid.to_string(), l1root);
 
-    insertion_map.insert("com.example.record/9ba1c7247ede".to_string(), cid1.clone());
+    insertion_map.insert("com.example.record/9ba1c7247ede".to_string(), cid1);
     let insertion_after_cid = repo.mst_from_map(&insertion_map).unwrap();
     assert_eq!(insertion_after_cid.to_string(), l2root);
 }
@@ -136,17 +136,17 @@ fn test_higher_layers() {
 
     // TODO: actual mutation instead of rebuild from scratch
     let mut higher_map: BTreeMap<String, Cid> = Default::default();
-    higher_map.insert("com.example.record/403e2aeebfdb".to_string(), cid1.clone()); // A; level 0
-    higher_map.insert("com.example.record/cbe72d33d12a".to_string(), cid1.clone()); // C; level 0
+    higher_map.insert("com.example.record/403e2aeebfdb".to_string(), cid1); // A; level 0
+    higher_map.insert("com.example.record/cbe72d33d12a".to_string(), cid1); // C; level 0
     let higher_before_cid = repo.mst_from_map(&higher_map).unwrap();
     assert_eq!(higher_before_cid.to_string(), l0root);
 
-    higher_map.insert("com.example.record/9ba1c7247ede".to_string(), cid1.clone()); // B; level 2
+    higher_map.insert("com.example.record/9ba1c7247ede".to_string(), cid1); // B; level 2
     let higher_after_cid = repo.mst_from_map(&higher_map).unwrap();
     print_mst_keys(&mut repo.db, &higher_after_cid).unwrap();
     assert_eq!(higher_after_cid.to_string(), l2root);
 
-    higher_map.insert("com.example.record/fae7a851fbeb".to_string(), cid1.clone()); // D; level 1
+    higher_map.insert("com.example.record/fae7a851fbeb".to_string(), cid1); // D; level 1
     let higher_after_cid = repo.mst_from_map(&higher_map).unwrap();
     assert_eq!(higher_after_cid.to_string(), l2root2);
 }