Merge branch 'main' into xargs-replace

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "findutils"
-version = "0.5.0"
+version = "0.5.1"
 homepage = "https://github.com/uutils/findutils"
 repository = "https://github.com/uutils/findutils"
 edition = "2021"
@@ -54,6 +54,6 @@ ci = ["github"]
 # The installers to generate for each app
 installers = []
 # Target platforms to build apps for (Rust target-triple syntax)
-targets = ["aarch64-apple-darwin", "x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"]
+targets = ["aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-unknown-linux-musl", "x86_64-pc-windows-msvc"]
 # Publish jobs to run in CI
 pr-run-mode = "plan"

src/find/matchers/mod.rs

@@ -220,7 +220,7 @@ fn convert_arg_to_comparable_value(
     option_name: &str,
     value_as_string: &str,
 ) -> Result<ComparableValue, Box<dyn Error>> {
-    let re = Regex::new(r"([+-]?)(\d+)$")?;
+    let re = Regex::new(r"^([+-]?)(\d+)$")?;
     if let Some(groups) = re.captures(value_as_string) {
         if let Ok(val) = groups[2].parse::<u64>() {
             return Ok(match &groups[1] {
@@ -296,7 +296,29 @@ fn parse_date_str_to_timestamps(date_str: &str) -> Option<i64> {
 /// X and Y from the -newerXY string.
 /// X and Y are constrained to a/B/c/m and t.
 /// such as: "-neweraB" -> Some(a, B) "-neweraD" -> None
+///
+/// Additionally, there is support for the -anewer and -cnewer short arguments. as follows:
+/// 1. -anewer is equivalent to -neweram
+/// 2. -cnewer is equivalent to - newercm
+///
+/// If -newer is used it will be resolved to -newermm.
 fn parse_str_to_newer_args(input: &str) -> Option<(String, String)> {
+    if input.is_empty() {
+        return None;
+    }
+
+    if input == "-newer" {
+        return Some(("m".to_string(), "m".to_string()));
+    }
+
+    if input == "-anewer" {
+        return Some(("a".to_string(), "m".to_string()));
+    }
+
+    if input == "-cnewer" {
+        return Some(("c".to_string(), "m".to_string()));
+    }
+
     let re = Regex::new(r"-newer([aBcm])([aBcmt])").unwrap();
     if let Some(captures) = re.captures(input) {
         let x = captures.get(1)?.as_str().to_string();
@@ -1260,6 +1282,20 @@ mod tests {
         }
     }
 
+    #[test]
+    fn convert_exception_arg_to_comparable_value_test() {
+        let exception_args = ["1%2", "1%2%3", "1a2", "1%2a", "abc", "-", "+", "%"];
+
+        for arg in exception_args {
+            let comparable = convert_arg_to_comparable_value("test", arg);
+            assert!(
+                comparable.is_err(),
+                "{} should be parse to Comparable correctly",
+                arg
+            );
+        }
+    }
+
     #[test]
     fn parse_date_str_to_timestamps_test() {
         let full_date_timestamps = parse_date_str_to_timestamps("jan 01, 2025 00:00:01").unwrap();
@@ -1284,6 +1320,23 @@ mod tests {
 
     #[test]
     fn parse_str_to_newer_args_test() {
+        // test for error case
+        let arg = parse_str_to_newer_args("");
+        assert!(arg.is_none());
+
+        // test for short options
+        // -newer equivalent to -newermm
+        let arg = parse_str_to_newer_args("-newer").unwrap();
+        assert_eq!(("m".to_string(), "m".to_string()), arg);
+
+        // -anewer equivalent to -neweram
+        let arg = parse_str_to_newer_args("-anewer").unwrap();
+        assert_eq!(("a".to_string(), "m".to_string()), arg);
+
+        // -cnewer equivalent to - newercm
+        let arg = parse_str_to_newer_args("-cnewer").unwrap();
+        assert_eq!(("c".to_string(), "m".to_string()), arg);
+
         let x_options = ["a", "B", "c", "m"];
         let y_options = ["a", "B", "c", "m", "t"];
 

src/find/matchers/time.rs

@@ -506,16 +506,12 @@ mod tests {
     #[test]
     fn newer_option_matcher() {
         #[cfg(target_os = "linux")]
-        let x_options = ["a", "c", "m"];
+        let options = ["a", "c", "m"];
         #[cfg(not(target_os = "linux"))]
-        let x_options = ["a", "B", "c", "m"];
-        #[cfg(target_os = "linux")]
-        let y_options = ["a", "c", "m"];
-        #[cfg(not(target_os = "linux"))]
-        let y_options = ["a", "B", "c", "m"];
+        let options = ["a", "B", "c", "m"];
 
-        for x_option in &x_options {
-            for y_option in &y_options {
+        for x_option in options {
+            for y_option in options {
                 let temp_dir = Builder::new().prefix("example").tempdir().unwrap();
                 let temp_dir_path = temp_dir.path().to_string_lossy();
                 let new_file_name = "newFile";
@@ -526,8 +522,8 @@ mod tests {
                 let old_file = get_dir_entry_for("test_data", "simple");
                 let deps = FakeDependencies::new();
                 let matcher = NewerOptionMatcher::new(
-                    (*x_option).to_string(),
-                    (*y_option).to_string(),
+                    x_option.to_string(),
+                    y_option.to_string(),
                     &old_file.path().to_string_lossy(),
                 );
 
@@ -542,8 +538,8 @@ mod tests {
                 // thus causing the Matcher to generate an IO error after matching.
                 let _ = fs::remove_file(&*new_file.path().to_string_lossy());
                 let matcher = NewerOptionMatcher::new(
-                    (*x_option).to_string(),
-                    (*y_option).to_string(),
+                    x_option.to_string(),
+                    y_option.to_string(),
                     &old_file.path().to_string_lossy(),
                 );
                 assert!(

src/find/mod.rs

@@ -921,15 +921,17 @@ mod tests {
         let args = ["-newerat", "-newerBt", "-newerct", "-newermt"];
         let times = ["jan 01, 2000", "jan 01, 2000 00:00:00"];
 
-        for (arg, time) in args.iter().zip(times.iter()) {
-            let deps = FakeDependencies::new();
-            let rc = find_main(&["find", "./test_data/simple/subdir", arg, time], &deps);
+        for arg in args {
+            for time in times {
+                let deps = FakeDependencies::new();
+                let rc = find_main(&["find", "./test_data/simple/subdir", arg, time], &deps);
 
-            assert_eq!(rc, 0);
-            assert_eq!(
-                deps.get_output_as_string(),
-                fix_up_slashes("./test_data/simple/subdir\n./test_data/simple/subdir/ABBBC\n"),
-            );
+                assert_eq!(rc, 0);
+                assert_eq!(
+                    deps.get_output_as_string(),
+                    fix_up_slashes("./test_data/simple/subdir\n./test_data/simple/subdir/ABBBC\n"),
+                );
+            }
         }
     }
 
@@ -942,12 +944,14 @@ mod tests {
         let args = ["-newerat", "-newerBt", "-newerct", "-newermt"];
         let times = ["jan 01, 2037", "jan 01, 2037 00:00:00"];
 
-        for (arg, time) in args.iter().zip(times.iter()) {
-            let deps = FakeDependencies::new();
-            let rc = find_main(&["find", "./test_data/simple/subdir", arg, time], &deps);
+        for arg in args {
+            for time in times {
+                let deps = FakeDependencies::new();
+                let rc = find_main(&["find", "./test_data/simple/subdir", arg, time], &deps);
 
-            assert_eq!(rc, 0);
-            assert_eq!(deps.get_output_as_string(), "");
+                assert_eq!(rc, 0);
+                assert_eq!(deps.get_output_as_string(), "");
+            }
         }
     }
 

tests/find_cmd_tests.rs

@@ -506,6 +506,32 @@ fn find_accessible() {
         .stdout(predicate::str::contains("abbbc").not());
 }
 
+#[test]
+fn find_time() {
+    let args = ["1", "+1", "-1"];
+    let exception_args = ["1%2", "1%2%3", "1a2", "1%2a", "abc", "-", "+", "%"];
+
+    ["-ctime", "-atime", "-mtime"].iter().for_each(|flag| {
+        args.iter().for_each(|arg| {
+            Command::cargo_bin("find")
+                .expect("found binary")
+                .args([".", flag, arg])
+                .assert()
+                .success()
+                .stderr(predicate::str::is_empty());
+        });
+
+        exception_args.iter().for_each(|arg| {
+            Command::cargo_bin("find")
+                .expect("found binary")
+                .args([".", flag, arg])
+                .assert()
+                .failure()
+                .stdout(predicate::str::is_empty());
+        });
+    });
+}
+
 #[test]
 fn expression_empty_parentheses() {
     Command::cargo_bin("find")
@@ -518,3 +544,46 @@ fn expression_empty_parentheses() {
         ))
         .stdout(predicate::str::is_empty());
 }
+
+#[test]
+#[serial(working_dir)]
+fn find_newer_xy() {
+    #[cfg(target_os = "linux")]
+    let options = ["a", "c", "m"];
+    #[cfg(not(target_os = "linux"))]
+    let options = ["a", "B", "c", "m"];
+
+    for x in options {
+        for y in options {
+            let arg = &format!("-newer{x}{y}");
+            Command::cargo_bin("find")
+                .expect("found binary")
+                .args([
+                    "./test_data/simple/subdir",
+                    arg,
+                    "./test_data/simple/subdir/ABBBC",
+                ])
+                .assert()
+                .success()
+                .stderr(predicate::str::is_empty());
+        }
+    }
+
+    #[cfg(target_os = "linux")]
+    let args = ["-newerat", "-newerct", "-newermt"];
+    #[cfg(not(target_os = "linux"))]
+    let args = ["-newerat", "-newerBt", "-newerct", "-newermt"];
+    let times = ["jan 01, 2000", "jan 01, 2000 00:00:00"];
+
+    for arg in args {
+        for time in times {
+            let arg = &format!("{arg}{time}");
+            Command::cargo_bin("find")
+                .expect("found binary")
+                .args(["./test_data/simple/subdir", arg, time])
+                .assert()
+                .success()
+                .stderr(predicate::str::is_empty());
+        }
+    }
+}