chore: Migrate to Edition 2024

Cargo.toml

@@ -1,12 +1,12 @@
 [workspace]
 members = ["crates/*"]
-resolver = "2"
+resolver = "3"
 
 [workspace.package]
 repository = "https://github.com/assert-rs/predicates-rs"
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.74"  # MSRV
+edition = "2024"
+rust-version = "1.85"  # MSRV
 include = [
   "build.rs",
   "src/**/*",

src/boolean.rs

@@ -11,8 +11,8 @@
 use std::fmt;
 use std::marker::PhantomData;
 
-use crate::reflection;
 use crate::Predicate;
+use crate::reflection;
 
 /// Predicate that combines two `Predicate`s, returning the AND of the results.
 ///
@@ -123,66 +123,82 @@ mod test_and {
 
     #[test]
     fn find_case_true() {
-        assert!(predicate::always()
-            .and(predicate::always())
-            .find_case(true, &5)
-            .is_some());
+        assert!(
+            predicate::always()
+                .and(predicate::always())
+                .find_case(true, &5)
+                .is_some()
+        );
     }
 
     #[test]
     fn find_case_true_left_fail() {
-        assert!(predicate::never()
-            .and(predicate::always())
-            .find_case(true, &5)
-            .is_none());
+        assert!(
+            predicate::never()
+                .and(predicate::always())
+                .find_case(true, &5)
+                .is_none()
+        );
     }
 
     #[test]
     fn find_case_true_right_fail() {
-        assert!(predicate::always()
-            .and(predicate::never())
-            .find_case(true, &5)
-            .is_none());
+        assert!(
+            predicate::always()
+                .and(predicate::never())
+                .find_case(true, &5)
+                .is_none()
+        );
     }
 
     #[test]
     fn find_case_true_fails() {
-        assert!(predicate::never()
-            .and(predicate::never())
-            .find_case(true, &5)
-            .is_none());
+        assert!(
+            predicate::never()
+                .and(predicate::never())
+                .find_case(true, &5)
+                .is_none()
+        );
     }
 
     #[test]
     fn find_case_false() {
-        assert!(predicate::never()
-            .and(predicate::never())
-            .find_case(false, &5)
-            .is_some());
+        assert!(
+            predicate::never()
+                .and(predicate::never())
+                .find_case(false, &5)
+                .is_some()
+        );
     }
 
     #[test]
     fn find_case_false_fails() {
-        assert!(predicate::always()
-            .and(predicate::always())
-            .find_case(false, &5)
-            .is_none());
+        assert!(
+            predicate::always()
+                .and(predicate::always())
+                .find_case(false, &5)
+                .is_none()
+        );
     }
 
     #[test]
     fn find_case_false_left_fail() {
-        assert!(predicate::never()
-            .and(predicate::always())
-            .find_case(false, &5)
-            .is_some());
+        assert!(
+            predicate::never()
+                .and(predicate::always())
+                .find_case(false, &5)
+                .is_some()
+        );
     }
 
     #[test]
     fn find_case_false_right_fail() {
-        assert!(predicate::always()
-            .and(predicate::never())
-            .find_case(false, &5)
-            .is_some());
+        assert!(
+            predicate::always()
+                .and(predicate::never())
+                .find_case(false, &5)
+                .is_some()
+        );
     }
 }
 
@@ -295,66 +311,82 @@ mod test_or {
 
     #[test]
     fn find_case_true() {
-        assert!(predicate::always()
-            .or(predicate::always())
-            .find_case(true, &5)
-            .is_some());
+        assert!(
+            predicate::always()
+                .or(predicate::always())
+                .find_case(true, &5)
+                .is_some()
+        );
     }
 
     #[test]
     fn find_case_true_left_fail() {
-        assert!(predicate::never()
-            .or(predicate::always())
-            .find_case(true, &5)
-            .is_some());
+        assert!(
+            predicate::never()
+                .or(predicate::always())
+                .find_case(true, &5)
+                .is_some()
+        );
     }
 
     #[test]
     fn find_case_true_right_fail() {
-        assert!(predicate::always()
-            .or(predicate::never())
-            .find_case(true, &5)
-            .is_some());
+        assert!(
+            predicate::always()
+                .or(predicate::never())
+                .find_case(true, &5)
+                .is_some()
+        );
     }
 
     #[test]
     fn find_case_true_fails() {
-        assert!(predicate::never()
-            .or(predicate::never())
-            .find_case(true, &5)
-            .is_none());
+        assert!(
+            predicate::never()
+                .or(predicate::never())
+                .find_case(true, &5)
+                .is_none()
+        );
     }
 
     #[test]
     fn find_case_false() {
-        assert!(predicate::never()
-            .or(predicate::never())
-            .find_case(false, &5)
-            .is_some());
+        assert!(
+            predicate::never()
+                .or(predicate::never())
+                .find_case(false, &5)
+                .is_some()
+        );
     }
 
     #[test]
     fn find_case_false_fails() {
-        assert!(predicate::always()
-            .or(predicate::always())
-            .find_case(false, &5)
-            .is_none());
+        assert!(
+            predicate::always()
+                .or(predicate::always())
+                .find_case(false, &5)
+                .is_none()
+        );
     }
 
     #[test]
     fn find_case_false_left_fail() {
-        assert!(predicate::never()
-            .or(predicate::always())
-            .find_case(false, &5)
-            .is_none());
+        assert!(
+            predicate::never()
+                .or(predicate::always())
+                .find_case(false, &5)
+                .is_none()
+        );
     }
 
     #[test]
     fn find_case_false_right_fail() {
-        assert!(predicate::always()
-            .or(predicate::never())
-            .find_case(false, &5)
-            .is_none());
+        assert!(
+            predicate::always()
+                .or(predicate::never())
+                .find_case(false, &5)
+                .is_none()
+        );
     }
 }
 

src/boxed.rs

@@ -11,8 +11,8 @@
 
 use std::fmt;
 
-use crate::reflection;
 use crate::Predicate;
+use crate::reflection;
 
 /// `Predicate` that wraps another `Predicate` as a trait object, allowing
 /// sized storage of predicate types.

src/constant.rs

@@ -10,9 +10,9 @@
 
 use std::fmt;
 
+use crate::Predicate;
 use crate::reflection;
 use crate::utils;
-use crate::Predicate;
 
 /// Predicate that always returns a constant (boolean) result.
 ///

src/float/close.rs

@@ -11,8 +11,8 @@ use std::fmt;
 use float_cmp::ApproxEq;
 use float_cmp::Ulps;
 
-use crate::reflection;
 use crate::Predicate;
+use crate::reflection;
 
 /// Predicate that ensures two numbers are "close" enough, understanding that rounding errors
 /// occur.

src/float/mod.rs

@@ -13,4 +13,4 @@
 #[cfg(feature = "float-cmp")]
 mod close;
 #[cfg(feature = "float-cmp")]
-pub use self::close::{is_close, IsClosePredicate};
+pub use self::close::{IsClosePredicate, is_close};

src/function.rs

@@ -11,9 +11,9 @@
 use std::fmt;
 use std::marker::PhantomData;
 
+use crate::Predicate;
 use crate::reflection;
 use crate::utils;
-use crate::Predicate;
 
 /// Predicate that wraps a function over a reference that returns a `bool`.
 /// This type is returned by the `predicate::function` function.

src/iter.rs

@@ -13,9 +13,9 @@ use std::fmt;
 use std::hash::Hash;
 use std::iter::FromIterator;
 
+use crate::Predicate;
 use crate::reflection;
 use crate::utils;
-use crate::Predicate;
 
 /// Predicate that returns `true` if `variable` is a member of the pre-defined
 /// set, otherwise returns `false`.

src/name.rs

@@ -11,8 +11,8 @@
 use std::fmt;
 use std::marker::PhantomData;
 
-use crate::reflection;
 use crate::Predicate;
+use crate::reflection;
 
 /// Augment an existing predicate with a name.
 ///

src/ord.rs

@@ -10,9 +10,9 @@
 
 use std::fmt;
 
+use crate::Predicate;
 use crate::reflection;
 use crate::utils;
-use crate::Predicate;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum EqOps {

src/path/existence.rs

@@ -9,9 +9,9 @@
 use std::fmt;
 use std::path;
 
+use crate::Predicate;
 use crate::reflection;
 use crate::utils;
-use crate::Predicate;
 
 /// Predicate that checks if a file is present
 ///

src/path/fc.rs

@@ -11,8 +11,8 @@ use std::fs;
 use std::io::{self, Read};
 use std::path;
 
-use crate::reflection;
 use crate::Predicate;
+use crate::reflection;
 
 fn read_file(path: &path::Path) -> io::Result<Vec<u8>> {
     let mut buffer = Vec::new();

src/path/fs.rs

@@ -11,9 +11,9 @@ use std::fs;
 use std::io::{self, Read};
 use std::path;
 
+use crate::Predicate;
 use crate::reflection;
 use crate::utils;
-use crate::Predicate;
 
 fn read_file(path: &path::Path) -> io::Result<Vec<u8>> {
     let mut buffer = Vec::new();

src/path/ft.rs

@@ -11,8 +11,8 @@ use std::fs;
 use std::io;
 use std::path;
 
-use crate::reflection;
 use crate::Predicate;
+use crate::reflection;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum FileType {

src/path/mod.rs

@@ -11,10 +11,10 @@
 //! This module contains predicates specific to the file system.
 
 mod existence;
-pub use self::existence::{exists, missing, ExistencePredicate};
+pub use self::existence::{ExistencePredicate, exists, missing};
 mod ft;
-pub use self::ft::{is_dir, is_file, is_symlink, FileTypePredicate};
+pub use self::ft::{FileTypePredicate, is_dir, is_file, is_symlink};
 mod fc;
 pub use self::fc::{FileContentPredicate, PredicateFileContentExt};
 mod fs;
-pub use self::fs::{eq_file, BinaryFilePredicate, StrFilePredicate};
+pub use self::fs::{BinaryFilePredicate, StrFilePredicate, eq_file};