fix: clippy

darkskygit · darkskygit · commit 5cc1d33c2830 · 2025-03-05T13:03:13.000+08:00
diff --git a/libs/jwst-codec/src/codec/integer.rs b/libs/jwst-codec/src/codec/integer.rs
@@ -146,7 +146,7 @@ mod tests {
         test_var_uint_enc_dec(0b10_0000_0000);
         test_var_uint_enc_dec(0b11_1111_1111);
         test_var_uint_enc_dec(0x7fff_ffff_ffff_ffff);
-        test_var_uint_enc_dec(u64::max_value());
+        test_var_uint_enc_dec(u64::MAX);
     }
 
     #[test]
diff --git a/libs/jwst-codec/src/doc/awareness.rs b/libs/jwst-codec/src/doc/awareness.rs
@@ -210,7 +210,7 @@ mod tests {
 
                 let values: MutexGuard<Vec<AwarenessEvent>> = values.lock().unwrap();
                 assert_eq!(values.len(), 4);
-                let event = values.get(0).unwrap();
+                let event = values.first().unwrap();
 
                 let mut added = event.added.clone();
                 added.sort();
diff --git a/libs/jwst-codec/src/doc/codec/delete_set.rs b/libs/jwst-codec/src/doc/codec/delete_set.rs
@@ -166,6 +166,7 @@ impl<W: CrdtWriter> CrdtWrite<W> for DeleteSet {
 }
 
 #[cfg(test)]
+#[allow(clippy::single_range_in_vec_init)]
 mod tests {
     use super::*;
 
diff --git a/libs/jwst-codec/src/doc/codec/item.rs b/libs/jwst-codec/src/doc/codec/item.rs
@@ -376,10 +376,13 @@ impl Item {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(not(loom))]
     use proptest::{collection::vec, prelude::*};
 
+    #[cfg(not(loom))]
     use super::*;
 
+    #[cfg(not(loom))]
     fn item_round_trip(item: &mut Item) -> JwstCodecResult {
         if !item.is_valid() {
             return Ok(());
diff --git a/libs/jwst-codec/src/doc/codec/item_flag.rs b/libs/jwst-codec/src/doc/codec/item_flag.rs
@@ -110,11 +110,11 @@ mod tests {
     fn test_flag_set_and_clear() {
         {
             let flag = super::ItemFlag::default();
-            assert_eq!(flag.keep(), false);
+            assert!(!flag.keep());
             flag.set_keep();
-            assert_eq!(flag.keep(), true);
+            assert!(flag.keep());
             flag.clear_keep();
-            assert_eq!(flag.keep(), false);
+            assert!(!flag.keep());
             assert_eq!(
                 flag.0.load(Ordering::SeqCst),
                 ItemFlag::default().0.load(Ordering::SeqCst)
@@ -123,11 +123,11 @@ mod tests {
 
         {
             let flag = super::ItemFlag::default();
-            assert_eq!(flag.countable(), false);
+            assert!(!flag.countable());
             flag.set_countable();
-            assert_eq!(flag.countable(), true);
+            assert!(flag.countable());
             flag.clear_countable();
-            assert_eq!(flag.countable(), false);
+            assert!(!flag.countable());
             assert_eq!(
                 flag.0.load(Ordering::SeqCst),
                 ItemFlag::default().0.load(Ordering::SeqCst)
@@ -136,11 +136,11 @@ mod tests {
 
         {
             let flag = super::ItemFlag::default();
-            assert_eq!(flag.deleted(), false);
+            assert!(!flag.deleted());
             flag.set_deleted();
-            assert_eq!(flag.deleted(), true);
+            assert!(flag.deleted());
             flag.clear_deleted();
-            assert_eq!(flag.deleted(), false);
+            assert!(!flag.deleted());
             assert_eq!(
                 flag.0.load(Ordering::SeqCst),
                 ItemFlag::default().0.load(Ordering::SeqCst)
@@ -152,15 +152,15 @@ mod tests {
             flag.set_keep();
             flag.set_countable();
             flag.set_deleted();
-            assert_eq!(flag.keep(), true);
-            assert_eq!(flag.countable(), true);
-            assert_eq!(flag.deleted(), true);
+            assert!(flag.keep());
+            assert!(flag.countable());
+            assert!(flag.deleted());
             flag.clear_keep();
             flag.clear_countable();
             flag.clear_deleted();
-            assert_eq!(flag.keep(), false);
-            assert_eq!(flag.countable(), false);
-            assert_eq!(flag.deleted(), false);
+            assert!(!flag.keep());
+            assert!(!flag.countable());
+            assert!(!flag.deleted());
             assert_eq!(
                 flag.0.load(Ordering::SeqCst),
                 ItemFlag::default().0.load(Ordering::SeqCst)
diff --git a/libs/jwst-codec/src/doc/codec/refs.rs b/libs/jwst-codec/src/doc/codec/refs.rs
@@ -344,6 +344,7 @@ impl From<Option<&Node>> for Somr<Item> {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(not(loom))]
     use proptest::{collection::vec, prelude::*};
 
     use super::{utils::ItemBuilder, *};
@@ -440,6 +441,7 @@ mod tests {
         });
     }
 
+    #[cfg(not(loom))]
     fn struct_info_round_trip(info: &mut Node) -> JwstCodecResult {
         if let Node::Item(item) = info {
             if let Some(item) = item.get_mut() {
diff --git a/libs/jwst-codec/src/doc/common/range.rs b/libs/jwst-codec/src/doc/common/range.rs
@@ -303,7 +303,7 @@ pub struct OrderRangeIter<'a> {
     idx: usize,
 }
 
-impl<'a> Iterator for OrderRangeIter<'a> {
+impl Iterator for OrderRangeIter<'_> {
     type Item = Range<u64>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -330,6 +330,7 @@ impl<'a> Iterator for OrderRangeIter<'a> {
 }
 
 #[cfg(test)]
+#[allow(clippy::single_range_in_vec_init)]
 mod tests {
     use super::OrderRange;
     #[test]
diff --git a/libs/jwst-codec/src/doc/common/somr.rs b/libs/jwst-codec/src/doc/common/somr.rs
@@ -50,15 +50,15 @@ pub(crate) struct InnerRefMut<'a, T> {
     _marker: PhantomData<&'a mut T>,
 }
 
-impl<'a, T> Deref for InnerRefMut<'a, T> {
+impl<T> Deref for InnerRefMut<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
         unsafe { &*self.inner.as_ptr() }
     }
 }
 
-impl<'a, T> DerefMut for InnerRefMut<'a, T> {
+impl<T> DerefMut for InnerRefMut<'_, T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         unsafe { &mut *self.inner.as_ptr() }
     }
diff --git a/libs/jwst-codec/src/doc/document.rs b/libs/jwst-codec/src/doc/document.rs
@@ -409,14 +409,14 @@ mod tests {
 
                 let map = yrs_doc.get_or_insert_map("abc");
                 let mut trx = yrs_doc.transact_mut();
-                map.insert(&mut trx, "a", 1).unwrap();
-                let binary = trx.encode_update_v1().unwrap();
+                map.insert(&mut trx, "a", 1);
+                let binary = trx.encode_update_v1();
 
                 let yrs_doc_new = yrs::Doc::with_options(yrs_options_right.clone());
                 let array = yrs_doc_new.get_or_insert_array("array");
                 let mut trx = yrs_doc_new.transact_mut();
-                array.insert(&mut trx, 0, "array_value").unwrap();
-                let binary_new = trx.encode_update_v1().unwrap();
+                array.insert(&mut trx, 0, "array_value");
+                let binary_new = trx.encode_update_v1();
 
                 (binary, binary_new)
             };
@@ -446,20 +446,21 @@ mod tests {
             let doc = yrs::Doc::with_options(yrs_options.clone());
             let array = doc.get_or_insert_array("abc");
             let mut trx = doc.transact_mut();
-            array.insert(&mut trx, 0, 42).unwrap();
-            array.insert(&mut trx, 1, -42).unwrap();
-            array.insert(&mut trx, 2, true).unwrap();
-            array.insert(&mut trx, 3, false).unwrap();
-            array.insert(&mut trx, 4, "hello").unwrap();
-            array.insert(&mut trx, 5, "world").unwrap();
+            array.insert(&mut trx, 0, 42);
+            array.insert(&mut trx, 1, -42);
+            array.insert(&mut trx, 2, true);
+            array.insert(&mut trx, 3, false);
+            array.insert(&mut trx, 4, "hello");
+            array.insert(&mut trx, 5, "world");
 
             let sub_array = yrs::ArrayPrelim::default();
-            let sub_array = array.insert(&mut trx, 6, sub_array).unwrap();
-            sub_array.insert(&mut trx, 0, 1).unwrap();
+            let sub_array = array.insert(&mut trx, 6, sub_array);
+            sub_array.insert(&mut trx, 0, 1);
 
             drop(trx);
-
-            assert_json_diff::assert_json_eq!(array.to_json(&doc.transact()), json);
+            let config = assert_json_diff::Config::new(assert_json_diff::CompareMode::Strict)
+                .numeric_mode(assert_json_diff::NumericMode::AssumeFloat);
+            assert_json_diff::assert_json_matches!(array.to_json(&doc.transact()), json, config);
         };
 
         let binary = {
@@ -483,9 +484,11 @@ mod tests {
         let ydoc = yrs::Doc::with_options(yrs_options);
         let array = ydoc.get_or_insert_array("abc");
         let mut trx = ydoc.transact_mut();
-        trx.apply_update(yrs::Update::decode_v1(&binary).unwrap());
+        trx.apply_update(yrs::Update::decode_v1(&binary).unwrap()).unwrap();
 
-        assert_json_diff::assert_json_eq!(array.to_json(&trx), json);
+        let config = assert_json_diff::Config::new(assert_json_diff::CompareMode::Strict)
+            .numeric_mode(assert_json_diff::NumericMode::AssumeFloat);
+        assert_json_diff::assert_json_matches!(array.to_json(&trx), json, config);
 
         let mut doc = Doc::new();
         let array = doc.get_or_create_array("abc").unwrap();
diff --git a/libs/jwst-codec/src/doc/publisher.rs b/libs/jwst-codec/src/doc/publisher.rs
@@ -175,7 +175,7 @@ mod tests {
         loom_model!({
             let doc = Doc::default();
 
-            let ret = vec![
+            let ret = [
                 vec![vec!["(1, 0)", "test.key1", "val1"]],
                 vec![vec!["(1, 1)", "test.key2", "val2"], vec!["(1, 2)", "test.key3", "val3"]],
                 vec![
diff --git a/libs/jwst-codec/src/doc/types/array.rs b/libs/jwst-codec/src/doc/types/array.rs
@@ -114,11 +114,11 @@ mod tests {
             let array = doc.get_or_insert_text("abc");
 
             let mut trx = doc.transact_mut();
-            array.insert(&mut trx, 0, " ").unwrap();
-            array.insert(&mut trx, 0, "Hello").unwrap();
-            array.insert(&mut trx, 6, "World").unwrap();
-            array.insert(&mut trx, 11, "!").unwrap();
-            let buffer = trx.encode_update_v1().unwrap();
+            array.insert(&mut trx, 0, " ");
+            array.insert(&mut trx, 0, "Hello");
+            array.insert(&mut trx, 6, "World");
+            array.insert(&mut trx, 11, "!");
+            let buffer = trx.encode_update_v1();
 
             let mut decoder = RawDecoder::new(&buffer);
             let update = Update::read(&mut decoder).unwrap();
@@ -141,11 +141,11 @@ mod tests {
             let array = doc.get_or_insert_text("abc");
 
             let mut trx = doc.transact_mut();
-            array.insert(&mut trx, 0, "Hello").unwrap();
-            array.insert(&mut trx, 5, " ").unwrap();
-            array.insert(&mut trx, 6, "World").unwrap();
-            array.insert(&mut trx, 11, "!").unwrap();
-            let buffer = trx.encode_update_v1().unwrap();
+            array.insert(&mut trx, 0, "Hello");
+            array.insert(&mut trx, 5, " ");
+            array.insert(&mut trx, 6, "World");
+            array.insert(&mut trx, 11, "!");
+            let buffer = trx.encode_update_v1();
 
             let mut decoder = RawDecoder::new(&buffer);
             let update = Update::read(&mut decoder).unwrap();
@@ -165,19 +165,19 @@ mod tests {
     #[cfg_attr(miri, ignore)]
     fn test_yrs_array_decode() {
         use yrs::{Array, Transact};
-        let update = {
-            let doc = yrs::Doc::new();
-            let array = doc.get_or_insert_array("abc");
-            let mut trx = doc.transact_mut();
 
-            array.insert(&mut trx, 0, "hello").unwrap();
-            array.insert(&mut trx, 1, "world").unwrap();
-            array.insert(&mut trx, 1, " ").unwrap();
+        loom_model!({
+            let update = {
+                let doc = yrs::Doc::new();
+                let array = doc.get_or_insert_array("abc");
+                let mut trx = doc.transact_mut();
 
-            trx.encode_update_v1().unwrap()
-        };
+                array.insert(&mut trx, 0, "hello");
+                array.insert(&mut trx, 1, "world");
+                array.insert(&mut trx, 1, " ");
 
-        loom_model!({
+                trx.encode_update_v1()
+            };
             let doc = Doc::try_from_binary_v1_with_options(
                 update.clone(),
                 DocOptions {
diff --git a/libs/jwst-codec/src/doc/types/list/search_marker.rs b/libs/jwst-codec/src/doc/types/list/search_marker.rs
@@ -227,7 +227,9 @@ impl MarkerList {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(not(loom))]
     use rand::{Rng, SeedableRng};
+    #[cfg(not(loom))]
     use rand_chacha::ChaCha20Rng;
     use yrs::{Array, Options, Transact};
 
@@ -253,11 +255,11 @@ mod tests {
                 let array = doc.get_or_insert_array("abc");
 
                 let mut trx = doc.transact_mut();
-                array.insert(&mut trx, 0, " ").unwrap();
-                array.insert(&mut trx, 0, "Hello").unwrap();
-                array.insert(&mut trx, 2, "World").unwrap();
+                array.insert(&mut trx, 0, " ");
+                array.insert(&mut trx, 0, "Hello");
+                array.insert(&mut trx, 2, "World");
 
-                (doc.client_id(), trx.encode_update_v1().unwrap())
+                (doc.client_id(), trx.encode_update_v1())
             };
 
             let mut decoder = RawDecoder::new(&buffer);
@@ -297,6 +299,7 @@ mod tests {
         });
     }
 
+    #[cfg(not(loom))]
     fn search_with_seed(seed: u64) {
         let rand = ChaCha20Rng::seed_from_u64(seed);
         let iteration = 20;
diff --git a/libs/jwst-codec/src/doc/types/map.rs b/libs/jwst-codec/src/doc/types/map.rs
@@ -135,7 +135,7 @@ impl<'a> Iterator for KeysIterator<'a> {
     }
 }
 
-impl<'a> Iterator for ValuesIterator<'a> {
+impl Iterator for ValuesIterator<'_> {
     type Item = Value;
 
     fn next(&mut self) -> Option<Self::Item> {
diff --git a/libs/jwst-codec/src/doc/types/text.rs b/libs/jwst-codec/src/doc/types/text.rs
@@ -56,11 +56,9 @@ mod tests {
     use rand_chacha::ChaCha20Rng;
     use yrs::{Options, Text, Transact};
 
-    use crate::{
-        loom_model,
-        sync::{thread, Arc, AtomicUsize, Ordering},
-        Doc,
-    };
+    #[cfg(not(loom))]
+    use crate::sync::{Arc, AtomicUsize, Ordering};
+    use crate::{loom_model, sync::thread, Doc};
 
     #[test]
     fn test_manipulate_text() {
@@ -145,6 +143,7 @@ mod tests {
         assert_eq!(text.len(), added_len.load(Ordering::SeqCst) as u64);
     }
 
+    #[cfg(not(loom))]
     fn parallel_ins_del_text(seed: u64, thread: i32, iteration: i32) {
         let doc = Doc::with_client(1);
         let rand = ChaCha20Rng::seed_from_u64(seed);
@@ -241,18 +240,18 @@ mod tests {
             guid: nanoid::nanoid!().into(),
             ..Default::default()
         };
-        let binary = {
-            let doc = yrs::Doc::with_options(yrs_options.clone());
-            let text = doc.get_or_insert_text("greating");
-            let mut trx = doc.transact_mut();
-            text.insert(&mut trx, 0, "hello").unwrap();
-            text.insert(&mut trx, 5, " world!").unwrap();
-            text.remove_range(&mut trx, 11, 1).unwrap();
-
-            trx.encode_update_v1().unwrap()
-        };
 
         loom_model!({
+            let binary = {
+                let doc = yrs::Doc::with_options(yrs_options.clone());
+                let text = doc.get_or_insert_text("greating");
+                let mut trx = doc.transact_mut();
+                text.insert(&mut trx, 0, "hello");
+                text.insert(&mut trx, 5, " world!");
+                text.remove_range(&mut trx, 11, 1);
+
+                trx.encode_update_v1()
+            };
             // in loom loop
             #[allow(clippy::needless_borrow)]
             let doc = Doc::try_from_binary_v1(&binary).unwrap();
diff --git a/libs/jwst-codec/src/sync.rs b/libs/jwst-codec/src/sync.rs
@@ -14,7 +14,7 @@ pub(crate) use std::{
 #[cfg(loom)]
 pub(crate) use loom::{
     sync::{
-        atomic::{AtomicBool, AtomicU16, AtomicU32, AtomicU8, AtomicUsize, Ordering},
+        atomic::{AtomicBool, AtomicU16, AtomicU8, AtomicUsize, Ordering},
         Mutex, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard,
     },
     thread,

Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ mod tests {`
`146`	`146`	`test_var_uint_enc_dec(0b10_0000_0000);`
`147`	`147`	`test_var_uint_enc_dec(0b11_1111_1111);`
`148`	`148`	`test_var_uint_enc_dec(0x7fff_ffff_ffff_ffff);`
`149`		`- test_var_uint_enc_dec(u64::max_value());`
	`149`	`+ test_var_uint_enc_dec(u64::MAX);`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`#[test]`
Original file line number	Diff line number	Diff line change
`@@ -166,6 +166,7 @@ impl<W: CrdtWriter> CrdtWrite<W> for DeleteSet {`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`#[cfg(test)]`
	`169`	`+#[allow(clippy::single_range_in_vec_init)]`
`169`	`170`	`mod tests {`
`170`	`171`	`use super::*;`
`171`	`172`
Original file line number	Diff line number	Diff line change
`@@ -303,7 +303,7 @@ pub struct OrderRangeIter<'a> {`
`303`	`303`	`idx: usize,`
`304`	`304`	`}`
`305`	`305`
`306`		`-impl<'a> Iterator for OrderRangeIter<'a> {`
	`306`	`+impl Iterator for OrderRangeIter<'_> {`
`307`	`307`	`type Item = Range<u64>;`
`308`	`308`
`309`	`309`	`fn next(&mut self) -> Option<Self::Item> {`
`@@ -330,6 +330,7 @@ impl<'a> Iterator for OrderRangeIter<'a> {`
`330`	`330`	`}`
`331`	`331`
`332`	`332`	`#[cfg(test)]`
	`333`	`+#[allow(clippy::single_range_in_vec_init)]`
`333`	`334`	`mod tests {`
`334`	`335`	`use super::OrderRange;`
`335`	`336`	`#[test]`
Original file line number	Diff line number	Diff line change
`@@ -50,15 +50,15 @@ pub(crate) struct InnerRefMut<'a, T> {`
`50`	`50`	`_marker: PhantomData<&'a mut T>,`
`51`	`51`	`}`
`52`	`52`
`53`		`-impl<'a, T> Deref for InnerRefMut<'a, T> {`
	`53`	`+impl<T> Deref for InnerRefMut<'_, T> {`
`54`	`54`	`type Target = T;`
`55`	`55`
`56`	`56`	`fn deref(&self) -> &Self::Target {`
`57`	`57`	`unsafe { &*self.inner.as_ptr() }`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`61`		`-impl<'a, T> DerefMut for InnerRefMut<'a, T> {`
	`61`	`+impl<T> DerefMut for InnerRefMut<'_, T> {`
`62`	`62`	`fn deref_mut(&mut self) -> &mut Self::Target {`
`63`	`63`	`unsafe { &mut *self.inner.as_ptr() }`
`64`	`64`	`}`