fix: clippy

Signed-off-by: tjh <[e-mail]>

crates/atproto/src/aturi.rs

···
 //!
 //! <https://atproto.com/specs/at-uri-scheme>
 //!
+use core::fmt;
+
+#[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
 use crate::{did::Did, handle::Handle, nsid::Nsid};
···
         }
     }
 
-    pub fn collection_str(&self) -> Option<&str> {
-        self.collection.map(|col| col.as_str())
+    pub const fn collection_str(&self) -> Option<&str> {
+        match self.collection {
+            Some(collection) => Some(collection.as_str()),
+            None => None,
+        }
     }
 }
 
···
 pub enum Authority<'a> {
     Did(&'a Did),
     Handle(&'a Handle),
+}
+
+impl<'a> Authority<'a> {
+    pub const fn is_did(&self) -> bool {
+        matches!(self, Self::Did(_))
+    }
+
+    pub const fn is_handle(&self) -> bool {
+        matches!(self, Self::Handle(_))
+    }
+
+    pub const fn as_str(&self) -> &str {
+        match self {
+            Self::Did(did) => did.as_str(),
+            Self::Handle(handle) => handle.as_str(),
+        }
+    }
+}
+
+impl fmt::Display for Authority<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_str())
+    }
 }
 
 #[derive(Debug, thiserror::Error)]
···
     }
 }
 
+impl fmt::Display for AtUri<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "at://{}", self.authority)?;
+        if let Some(collection) = self.collection {
+            write!(f, "/{collection}")?;
+            if let Some(rkey) = self.rkey {
+                write!(f, "/{rkey}")?;
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(feature = "serde")]
 impl<'de: 'a, 'a> Deserialize<'de> for AtUri<'a> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
···
     }
 }
 
+#[cfg(feature = "serde")]
 impl Serialize for AtUri<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
-        unimplemented!()
+        serializer.serialize_str(&self.to_string())
     }
 }
 
···
     fn valid_samples() {
         let samples = ["at://foo.com/com.example.foo/123"];
         for sample in samples {
-            assert!(AtUri::parse(sample).is_ok(), "{sample} should be valid");
+            let parsed = AtUri::parse(sample);
+            assert!(parsed.is_ok(), "{sample} should be valid");
+
+            let s = parsed.unwrap().to_string();
+            assert_eq!(s, sample);
         }
     }
 

crates/identity/src/resolvers/direct.rs

···
                 continue;
             };
 
-            if let Some(old_did) = resolved_did.replace(did.clone()) {
-                if old_did != did {
-                    tracing::error!(
-                        ?handle,
-                        ?did,
-                        ?old_did,
-                        "multiple conflicting DIDs found for handle"
-                    );
-                    // @TODO Replace this with an error so we can retry with a
-                    // recursive dns resolver.
-                    return Ok(None);
-                }
+            if let Some(old_did) = resolved_did.replace(did.clone())
+                && old_did != did
+            {
+                tracing::error!(
+                    ?handle,
+                    ?did,
+                    ?old_did,
+                    "multiple conflicting DIDs found for handle"
+                );
+                // @TODO Replace this with an error so we can retry with a
+                // recursive dns resolver.
+                return Ok(None);
             }
         }
     }

crates/knot/src/model/knot_state.rs

···
                         continue;
                     };
 
-                    db.upsert_public_key(&did, &rkey, &rev, &record.cid, &public_key)
+                    db.upsert_public_key(&did, rkey, &rev, &record.cid, &public_key)
                         .await?;
                 }
 
···
                     }
 
                     if let Ok(true) = db
-                        .insert_repository(&did, &rkey, &rev, &record.cid, &repo)
+                        .insert_repository(&did, rkey, &rev, &record.cid, &repo)
                         .await
                     {
                         let path = base.join(did.as_str()).join(rkey);

crates/knot/src/model/nicediff.rs

···
     #[error("{0}")]
     Io(#[from] std::io::Error),
     #[error("{0}")]
-    Platform(#[from] gix::diff::blob::platform::set_resource::Error),
+    Platform(Box<gix::diff::blob::platform::set_resource::Error>),
     #[error("{0}")]
     Diff(#[from] gix::object::blob::diff::lines::Error<SubError>),
+}
+
+impl From<gix::diff::blob::platform::set_resource::Error> for Error {
+    fn from(value: gix::diff::blob::platform::set_resource::Error) -> Self {
+        Self::Platform(Box::new(value))
+    }
 }
 
 #[derive(Debug, thiserror::Error)]

crates/knot/src/services/atrepo.rs

···
     Callback(E),
 }
 
-pub async fn fetch_collection<'de, F, E>(
+pub async fn fetch_collection<F, E>(
     resolver: &identity::Resolver,
     http: &reqwest::Client,
     did: &Did,