Fixed key comparison

src/kv/key.rs

@@ -178,4 +178,25 @@ mod tests {
     fn key_to_borrowed() {
         assert_eq!("a key", Key::from_str("a key").to_borrowed_str().unwrap());
     }
+
+    #[test]
+    fn key_static_eq() {
+        assert_eq!(Key::from_str_static("a key"), Key::from_str_static("a key"));
+    }
+
+    #[test]
+    fn key_borrowed_eq() {
+        const KEY: &str = "a key";
+        let k1 = String::from(KEY);
+        let k2 = String::from(KEY);
+        assert_eq!(Key::from_str(&k1), Key::from_str(&k2));
+    }
+
+    #[test]
+    fn key_borrowed_and_static_eq() {
+        const KEY: &str = "a key";
+        let static_key = Key::from_str_static(KEY);
+        let borrowed_key = Key::from_str(KEY);
+        assert_eq!(static_key, borrowed_key);
+    }
 }

src/lib.rs

@@ -777,7 +777,7 @@ impl LevelFilter {
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
+#[derive(Copy, Clone, Debug)]
 enum MaybeStaticStr<'a> {
     Static(&'static str),
     Borrowed(&'a str),
@@ -793,6 +793,32 @@ impl<'a> MaybeStaticStr<'a> {
     }
 }
 
+impl Eq for MaybeStaticStr<'_> {}
+
+impl PartialEq for MaybeStaticStr<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        self.get() == other.get()
+    }
+}
+
+impl Ord for MaybeStaticStr<'_> {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+        self.get().cmp(other.get())
+    }
+}
+
+impl PartialOrd for MaybeStaticStr<'_> {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl std::hash::Hash for MaybeStaticStr<'_> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.get().hash(state);
+    }
+}
+
 /// The "payload" of a log message.
 ///
 /// # Use