refactor: to filetime for platform-agnostic atime, ctime, mtime inspe…

…ction

Cargo.toml

@@ -64,6 +64,8 @@ open = "4.1.0"
 winnow = "0.4.6"
 byte-unit = "4.0.19"
 
+# date related
+filetime = "0.2.21"
 
 # infer file and MIME type by magic number
 infer = "0.13"
@@ -159,6 +161,7 @@ dialoguer = { workspace = true }
 ron = { workspace = true }
 open = { workspace = true }
 
+
 [dev-dependencies]
 abscissa_core = { workspace = true, features = ["testing"] }
 once_cell = { workspace = true }

TODO.md

@@ -13,6 +13,7 @@
 
 1. implement Terminal UI
     - generate config interactively `generate config --interactive`
+    - <https://crates.io/crates/ratatui/0.20.1> + <https://crates.io/crates/tui-react>
 
 1. implement scripting
 1. build GUI

crates/organize-rs_core/Cargo.toml

@@ -64,6 +64,7 @@ winnow = { workspace = true }
 byte-unit = { workspace = true }
 trash = { workspace = true }
 rayon = { workspace = true }
+filetime = { workspace = true }
 
 [dev-dependencies]
 rustup-toolchain = "0.1.4"

crates/organize-rs_core/src/filters/impl_.rs

@@ -1,5 +1,6 @@
 use chrono::{DateTime, Utc};
 
+use filetime::FileTime;
 use itertools::Itertools;
 use jwalk::{ClientState, DirEntry};
 
@@ -198,9 +199,8 @@ impl FilterKind {
     ) -> Box<dyn FnMut(&DirEntry<C>) -> bool + 'args> {
         Box::new(|entry| {
             entry.metadata().ok().map_or(false, |metadata| {
-                metadata.accessed().map_or(false, |sys_time| {
-                    Self::matches_date(&sys_time, &range.clone())
-                })
+                let atime = FileTime::from_last_access_time(&metadata);
+                Self::matches_date(&atime, &range.clone())
             })
         })
     }
@@ -210,30 +210,28 @@ impl FilterKind {
     ) -> Box<dyn FnMut(&DirEntry<C>) -> bool + 'args> {
         Box::new(|entry| {
             entry.metadata().ok().map_or(false, |metadata| {
-                metadata.modified().map_or(false, |sys_time| {
-                    Self::matches_date(&sys_time, &range.clone())
-                })
+                let mtime = FileTime::from_last_modification_time(&metadata);
+                Self::matches_date(&mtime, &range.clone())
             })
         })
     }
+
     fn filter_by_created<'a, 'args, C: ClientState>(
         &'a self,
         range: &'args PeriodRange,
     ) -> Box<dyn FnMut(&DirEntry<C>) -> bool + 'args> {
         Box::new(|entry| {
             entry.metadata().ok().map_or(false, |metadata| {
-                metadata.created().map_or(false, |sys_time| {
-                    Self::matches_date(&sys_time, &range.clone())
-                })
+                FileTime::from_creation_time(&metadata)
+                    .map_or(false, |ctime| Self::matches_date(&ctime, &range.clone()))
             })
         })
     }
 
-    fn matches_date(item_date: &std::time::SystemTime, range: &PeriodRange) -> bool {
-        let datetime_file: DateTime<Utc> = chrono::DateTime::from(*item_date);
-        let now = chrono::offset::Utc::now();
+    fn matches_date(item_date: &FileTime, range: &PeriodRange) -> bool {
+        let now = FileTime::now();
 
-        let seconds_since_created = match u64::try_from((now - datetime_file).num_seconds()) {
+        let seconds_since_created = match u64::try_from(now.seconds() - item_date.seconds()) {
             Ok(it) => it,
             Err(err) => {
                 eprintln!("subtraction of two datetimes can't be negative: {err}");

crates/organize-rs_core/src/filters/tests.rs

@@ -71,10 +71,10 @@ fn empty_file() -> Vec<PathBuf> {
 #[fixture]
 fn size() -> Vec<PathBuf> {
     vec![
-        get_fixtures_dir().join("different_sizes"),
-        get_fixtures_dir().join("different_sizes").join("1MiB"),
-        get_fixtures_dir().join("different_sizes").join("300KiB"),
-        get_fixtures_dir().join("different_sizes").join("empty.txt"),
+        get_fixtures_dir().join("size_based"),
+        get_fixtures_dir().join("size_based").join("1MiB"),
+        get_fixtures_dir().join("size_based").join("300KiB"),
+        get_fixtures_dir().join("size_based").join("empty.txt"),
     ]
 }
 
@@ -133,9 +133,28 @@ fn get_fixture_entries(sub_dir: impl AsRef<Path>) -> Vec<DirEntry<((), ())>> {
         .collect_vec()
 }
 
+#[rstest]
+fn test_filter_file_date_7d_passes(mut size: Vec<PathBuf>) {
+    let filter = FilterKind::Size {
+        range: SizeRange::from_str("..2mb").unwrap(),
+    };
+
+    let mut entries = get_fixture_entries("date_based");
+    let paths = entries.iter().map(|f| f.path()).collect_vec();
+    assert_eq!(entries.len(), size.len());
+    assert_eq!(paths, size);
+    entries.retain(|f| (filter.get_filter()(f)));
+    let paths = entries.iter().map(|f| f.path()).collect_vec();
+
+    _ = size.remove(0);
+
+    assert_eq!(entries.len(), size.len());
+    assert_eq!(paths, size);
+}
+
 #[rstest]
 #[should_panic]
-fn test_filter_mimetype_image_passes(mut mimetype: Vec<PathBuf>) {
+fn test_filter_mimetype_image_fails(mut mimetype: Vec<PathBuf>) {
     let filter = FilterKind::Mimetype {
         mimetype: vec![String::from("image")],
     };
@@ -522,7 +541,7 @@ fn test_filter_file_size_2mb_passes(mut size: Vec<PathBuf>) {
         range: SizeRange::from_str("..2mb").unwrap(),
     };
 
-    let mut entries = get_fixture_entries("different_sizes");
+    let mut entries = get_fixture_entries("size_based");
     let paths = entries.iter().map(|f| f.path()).collect_vec();
     assert_eq!(entries.len(), size.len());
     assert_eq!(paths, size);
@@ -541,7 +560,7 @@ fn test_filter_file_size_350_800_kib_passes(mut size: Vec<PathBuf>) {
         range: SizeRange::from_str("350KiB..800kib").unwrap(),
     };
 
-    let mut entries = get_fixture_entries("different_sizes");
+    let mut entries = get_fixture_entries("size_based");
     let paths = entries.iter().map(|f| f.path()).collect_vec();
     assert_eq!(entries.len(), size.len());
     assert_eq!(paths, size);
@@ -559,7 +578,7 @@ fn test_filter_file_size_250kib_passes(mut size: Vec<PathBuf>) {
         range: SizeRange::from_str("250KiB..").unwrap(),
     };
 
-    let mut entries = get_fixture_entries("different_sizes");
+    let mut entries = get_fixture_entries("size_based");
     let paths = entries.iter().map(|f| f.path()).collect_vec();
     assert_eq!(entries.len(), size.len());
     assert_eq!(paths, size);