Fix touch to allow changing timestamps on directories, remake from #11760 (#12005)

<!--
if this PR closes one or more issues, you can automatically link the PR
with
them by using one of the [*linking
keywords*](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword),
e.g.
- this PR should close #xxxx
- fixes #xxxx

you can also mention related issues, PRs or discussions!
-->

Based off of #11760 to be mergable without conflicts.

# Description
<!--
Thank you for improving Nushell. Please, check our [contributing
guide](../CONTRIBUTING.md) and talk to the core team before making major
changes.

Description of your pull request goes here. **Provide examples and/or
screenshots** if your changes affect the user experience.
-->
Fix for #11757.
The main issue in #11757 is I tried to copy the timestamp from one
directory to another only to realize that did not work whereas the
coreutils `^touch` had no problems. I thought `--reference` just did not
work, but apparently the whole `touch` command could not work on
directories because
`OpenOptions::new().write(true).create(true).open(&item)` tries to
create `touch`'s target in advance and then modify its timestamps. But
if the target is a directory that already exists then this would fail
even though the crate used for working with timestamps, `filetime`,
already works on directories.

# User-Facing Changes
<!-- List of all changes that impact the user experience here. This
helps us keep track of breaking changes. -->
I don't believe this should change any existing valid behaviors. It just
changes a non-working behavior.

# Tests + Formatting
<!--
Don't forget to add tests that cover your changes.

Make sure you've run and fixed any issues with these commands:

- `cargo fmt --all -- --check` to check standard code formatting (`cargo
fmt --all` applies these changes)
- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used` to
check that you're using the standard code style
- `cargo test --workspace` to check that all tests pass (on Windows make
sure to [enable developer
mode](https://learn.microsoft.com/en-us/windows/apps/get-started/developer-mode-features-and-debugging))
- `cargo run -- -c "use std testing; testing run-tests --path
crates/nu-std"` to run the tests for the standard library

> **Note**
> from `nushell` you can also use the `toolkit` as follows
> ```bash
> use toolkit.nu # or use an `env_change` hook to activate it
automatically
> toolkit check pr
> ```
-->
~~I only could not run `cargo test` because I get compilation errors on
the latest main branch~~
All tests pass with `cargo test --features=sqlite`

# After Submitting
<!-- If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.
-->

crates/nu-command/src/filesystem/touch.rs

@@ -1,7 +1,6 @@
-use std::fs::OpenOptions;
 use std::path::Path;
+use std::{fs::OpenOptions, time::SystemTime};
 
-use chrono::{DateTime, Local};
 use filetime::FileTime;
 
 use nu_engine::CallExt;
@@ -64,7 +63,7 @@ impl Command for Touch {
     ) -> Result<PipelineData, ShellError> {
         let mut change_mtime: bool = call.has_flag(engine_state, stack, "modified")?;
         let mut change_atime: bool = call.has_flag(engine_state, stack, "access")?;
-        let use_reference: bool = call.has_flag(engine_state, stack, "reference")?;
+        let reference: Option<Spanned<String>> = call.get_flag(engine_state, stack, "reference")?;
         let no_create: bool = call.has_flag(engine_state, stack, "no-create")?;
         let files: Vec<String> = call.rest(engine_state, stack, 0)?;
 
@@ -75,88 +74,73 @@ impl Command for Touch {
             });
         }
 
-        let mut date: Option<DateTime<Local>> = None;
+        let mut mtime = SystemTime::now();
-        let mut ref_date_atime: Option<DateTime<Local>> = None;
+        let mut atime = mtime;
 
-        // Change both times if none is specified
+        // Change both times if neither is specified
         if !change_mtime && !change_atime {
             change_mtime = true;
             change_atime = true;
         }
 
-        if change_mtime || change_atime {
+        if let Some(reference) = reference {
-            date = Some(Local::now());
+            let reference_path = Path::new(&reference.item);
-        }
+            if !reference_path.exists() {
-
+                return Err(ShellError::FileNotFoundCustom {
-        if use_reference {
+                    msg: "Reference path not found".into(),
-            let reference: Option<Spanned<String>> =
+                    span: reference.span,
-                call.get_flag(engine_state, stack, "reference")?;
+                });
-            match reference {
-                Some(reference) => {
-                    let reference_path = Path::new(&reference.item);
-                    if !reference_path.exists() {
-                        return Err(ShellError::TypeMismatch {
-                            err_message: "path provided is invalid".to_string(),
-                            span: reference.span,
-                        });
-                    }
-
-                    date = Some(
-                        reference_path
-                            .metadata()
-                            .expect("should be a valid path") // Should never fail as the path exists
-                            .modified()
-                            .expect("should have metadata") // This should always be valid as it is available on all nushell's supported platforms (Linux, Windows, MacOS)
-                            .into(),
-                    );
-
-                    ref_date_atime = Some(
-                        reference_path
-                            .metadata()
-                            .expect("should be a valid path") // Should never fail as the path exists
-                            .accessed()
-                            .expect("should have metadata") // This should always be valid as it is available on all nushell's supported platforms (Linux, Windows, MacOS)
-                            .into(),
-                    );
-                }
-                None => {
-                    return Err(ShellError::MissingParameter {
-                        param_name: "reference".to_string(),
-                        span: call.head,
-                    });
-                }
             }
+
+            let metadata = reference_path
+                .metadata()
+                .map_err(|err| ShellError::IOErrorSpanned {
+                    msg: format!("Failed to read metadata: {err}"),
+                    span: reference.span,
+                })?;
+            mtime = metadata
+                .modified()
+                .map_err(|err| ShellError::IOErrorSpanned {
+                    msg: format!("Failed to read modified time: {err}"),
+                    span: reference.span,
+                })?;
+            atime = metadata
+                .accessed()
+                .map_err(|err| ShellError::IOErrorSpanned {
+                    msg: format!("Failed to read access time: {err}"),
+                    span: reference.span,
+                })?;
         }
 
         for (index, item) in files.into_iter().enumerate() {
-            if no_create {
+            let path = Path::new(&item);
-                let path = Path::new(&item);
+
-                if !path.exists() {
+            // If --no-create is passed and the file/dir does not exist there's nothing to do
-                    continue;
+            if no_create && !path.exists() {
-                }
+                continue;
             }
 
-            if let Err(err) = OpenOptions::new()
+            // Create a file at the given path unless the path is a directory
-                .write(true)
+            if !path.is_dir() {
-                .create(true)
+                if let Err(err) = OpenOptions::new()
-                .truncate(false)
+                    .write(true)
-                .open(&item)
+                    .create(true)
-            {
+                    .truncate(false)
-                return Err(ShellError::CreateNotPossible {
+                    .open(path)
-                    msg: format!("Failed to create file: {err}"),
+                {
-                    span: call
+                    return Err(ShellError::CreateNotPossible {
-                        .positional_nth(index)
+                        msg: format!("Failed to create file: {err}"),
-                        .expect("already checked positional")
+                        span: call
-                        .span,
+                            .positional_nth(index)
-                });
+                            .expect("already checked positional")
-            };
+                            .span,
+                    });
+                };
+            }
 
             if change_mtime {
-                // Should not panic as we return an error above if we can't parse the date
+                if let Err(err) = filetime::set_file_mtime(&item, FileTime::from_system_time(mtime))
-                if let Err(err) = filetime::set_file_mtime(
+                {
-                    &item,
-                    FileTime::from_system_time(date.expect("should be a valid date").into()),
-                ) {
                     return Err(ShellError::ChangeModifiedTimeNotPossible {
                         msg: format!("Failed to change the modified time: {err}"),
                         span: call
@@ -168,38 +152,16 @@ impl Command for Touch {
             }
 
             if change_atime {
-                // Reference file/directory may have different access and modified times
+                if let Err(err) = filetime::set_file_atime(&item, FileTime::from_system_time(atime))
-                if use_reference {
+                {
-                    // Should not panic as we return an error above if we can't parse the date
+                    return Err(ShellError::ChangeAccessTimeNotPossible {
-                    if let Err(err) = filetime::set_file_atime(
+                        msg: format!("Failed to change the access time: {err}"),
-                        &item,
+                        span: call
-                        FileTime::from_system_time(
+                            .positional_nth(index)
-                            ref_date_atime.expect("should be a valid date").into(),
+                            .expect("already checked positional")
-                        ),
+                            .span,
-                    ) {
+                    });
-                        return Err(ShellError::ChangeAccessTimeNotPossible {
+                };
-                            msg: format!("Failed to change the access time: {err}"),
-                            span: call
-                                .positional_nth(index)
-                                .expect("already checked positional")
-                                .span,
-                        });
-                    };
-                } else {
-                    // Should not panic as we return an error above if we can't parse the date
-                    if let Err(err) = filetime::set_file_atime(
-                        &item,
-                        FileTime::from_system_time(date.expect("should be a valid date").into()),
-                    ) {
-                        return Err(ShellError::ChangeAccessTimeNotPossible {
-                            msg: format!("Failed to change the access time: {err}"),
-                            span: call
-                                .positional_nth(index)
-                                .expect("already checked positional")
-                                .span,
-                        });
-                    };
-                }
             }
         }
 

crates/nu-command/tests/commands/touch.rs

@@ -3,6 +3,9 @@ use nu_test_support::fs::Stub;
 use nu_test_support::nu;
 use nu_test_support::playground::Playground;
 
+// Use 1 instead of 0 because 0 has a special meaning in Windows
+const TIME_ONE: filetime::FileTime = filetime::FileTime::from_unix_time(1, 0);
+
 #[test]
 fn creates_a_file_when_it_doesnt_exist() {
     Playground::setup("create_test_1", |dirs, _sandbox| {
@@ -36,21 +39,29 @@ fn creates_two_files() {
 fn change_modified_time_of_file_to_today() {
     Playground::setup("change_time_test_9", |dirs, sandbox| {
         sandbox.with_files(vec![Stub::EmptyFile("file.txt")]);
+        let path = dirs.test().join("file.txt");
+
+        // Set file.txt's times to the past before the test to make sure `touch` actually changes the mtime to today
+        filetime::set_file_times(&path, TIME_ONE, TIME_ONE).unwrap();
 
         nu!(
             cwd: dirs.test(),
             "touch -m file.txt"
         );
 
-        let path = dirs.test().join("file.txt");
+        let metadata = path.metadata().unwrap();
 
         // Check only the date since the time may not match exactly
-        let date = Local::now().date_naive();
+        let today = Local::now().date_naive();
-        let actual_date_time: DateTime<Local> =
+        let mtime_day = DateTime::<Local>::from(metadata.modified().unwrap()).date_naive();
-            DateTime::from(path.metadata().unwrap().modified().unwrap());
-        let actual_date = actual_date_time.date_naive();
 
-        assert_eq!(date, actual_date);
+        assert_eq!(today, mtime_day);
+
+        // Check that atime remains unchanged
+        assert_eq!(
+            TIME_ONE,
+            filetime::FileTime::from_system_time(metadata.accessed().unwrap())
+        );
     })
 }
 
@@ -58,21 +69,29 @@ fn change_modified_time_of_file_to_today() {
 fn change_access_time_of_file_to_today() {
     Playground::setup("change_time_test_18", |dirs, sandbox| {
         sandbox.with_files(vec![Stub::EmptyFile("file.txt")]);
+        let path = dirs.test().join("file.txt");
+
+        // Set file.txt's times to the past before the test to make sure `touch` actually changes the atime to today
+        filetime::set_file_times(&path, TIME_ONE, TIME_ONE).unwrap();
 
         nu!(
             cwd: dirs.test(),
             "touch -a file.txt"
         );
 
-        let path = dirs.test().join("file.txt");
+        let metadata = path.metadata().unwrap();
 
         // Check only the date since the time may not match exactly
-        let date = Local::now().date_naive();
+        let today = Local::now().date_naive();
-        let actual_date_time: DateTime<Local> =
+        let atime_day = DateTime::<Local>::from(metadata.accessed().unwrap()).date_naive();
-            DateTime::from(path.metadata().unwrap().accessed().unwrap());
-        let actual_date = actual_date_time.date_naive();
 
-        assert_eq!(date, actual_date);
+        assert_eq!(today, atime_day);
+
+        // Check that mtime remains unchanged
+        assert_eq!(
+            TIME_ONE,
+            filetime::FileTime::from_system_time(metadata.modified().unwrap())
+        );
     })
 }
 
@@ -80,30 +99,31 @@ fn change_access_time_of_file_to_today() {
 fn change_modified_and_access_time_of_file_to_today() {
     Playground::setup("change_time_test_27", |dirs, sandbox| {
         sandbox.with_files(vec![Stub::EmptyFile("file.txt")]);
+        let path = dirs.test().join("file.txt");
+
+        filetime::set_file_times(&path, TIME_ONE, TIME_ONE).unwrap();
 
         nu!(
             cwd: dirs.test(),
             "touch -a -m file.txt"
         );
 
-        let metadata = dirs.test().join("file.txt").metadata().unwrap();
+        let metadata = path.metadata().unwrap();
 
         // Check only the date since the time may not match exactly
-        let date = Local::now().date_naive();
+        let today = Local::now().date_naive();
-        let adate_time: DateTime<Local> = DateTime::from(metadata.accessed().unwrap());
+        let mtime_day = DateTime::<Local>::from(metadata.modified().unwrap()).date_naive();
-        let adate = adate_time.date_naive();
+        let atime_day = DateTime::<Local>::from(metadata.accessed().unwrap()).date_naive();
-        let mdate_time: DateTime<Local> = DateTime::from(metadata.modified().unwrap());
-        let mdate = mdate_time.date_naive();
 
-        assert_eq!(date, adate);
+        assert_eq!(today, mtime_day);
-        assert_eq!(date, mdate);
+        assert_eq!(today, atime_day);
     })
 }
 
 #[test]
 fn not_create_file_if_it_not_exists() {
     Playground::setup("change_time_test_28", |dirs, _sandbox| {
-        nu!(
+        let outcome = nu!(
             cwd: dirs.test(),
             "touch -c file.txt"
         );
@@ -112,17 +132,39 @@ fn not_create_file_if_it_not_exists() {
 
         assert!(!path.exists());
 
-        nu!(
+        // If --no-create is improperly handled `touch` may error when trying to change the times of a nonexistent file
-            cwd: dirs.test(),
+        assert!(outcome.status.success())
-            "touch -c file.txt"
-        );
-
-        let path = dirs.test().join("file.txt");
-
-        assert!(!path.exists());
     })
 }
 
+#[test]
+fn change_file_times_if_exists_with_no_create() {
+    Playground::setup(
+        "change_file_times_if_exists_with_no_create",
+        |dirs, sandbox| {
+            sandbox.with_files(vec![Stub::EmptyFile("file.txt")]);
+            let path = dirs.test().join("file.txt");
+
+            filetime::set_file_times(&path, TIME_ONE, TIME_ONE).unwrap();
+
+            nu!(
+                cwd: dirs.test(),
+                "touch -c file.txt"
+            );
+
+            let metadata = path.metadata().unwrap();
+
+            // Check only the date since the time may not match exactly
+            let today = Local::now().date_naive();
+            let mtime_day = DateTime::<Local>::from(metadata.modified().unwrap()).date_naive();
+            let atime_day = DateTime::<Local>::from(metadata.accessed().unwrap()).date_naive();
+
+            assert_eq!(today, mtime_day);
+            assert_eq!(today, atime_day);
+        },
+    )
+}
+
 #[test]
 fn creates_file_three_dots() {
     Playground::setup("create_test_1", |dirs, _sandbox| {
@@ -161,3 +203,287 @@ fn creates_file_four_dots_quotation_marks() {
         assert!(path.exists());
     })
 }
+
+#[test]
+fn change_file_times_to_reference_file() {
+    Playground::setup("change_dir_times_to_reference_dir", |dirs, sandbox| {
+        sandbox.with_files(vec![
+            Stub::EmptyFile("reference_file"),
+            Stub::EmptyFile("target_file"),
+        ]);
+
+        let reference = dirs.test().join("reference_file");
+        let target = dirs.test().join("target_file");
+
+        // Change the times for reference
+        filetime::set_file_times(
+            &reference,
+            filetime::FileTime::from_unix_time(1337, 0),
+            TIME_ONE,
+        )
+        .unwrap();
+
+        // target should have today's date since it was just created, but reference should be different
+        assert_ne!(
+            reference.metadata().unwrap().accessed().unwrap(),
+            target.metadata().unwrap().accessed().unwrap()
+        );
+        assert_ne!(
+            reference.metadata().unwrap().modified().unwrap(),
+            target.metadata().unwrap().modified().unwrap()
+        );
+
+        nu!(
+            cwd: dirs.test(),
+            "touch -r reference_file target_file"
+        );
+
+        assert_eq!(
+            reference.metadata().unwrap().accessed().unwrap(),
+            target.metadata().unwrap().accessed().unwrap()
+        );
+        assert_eq!(
+            reference.metadata().unwrap().modified().unwrap(),
+            target.metadata().unwrap().modified().unwrap()
+        );
+    })
+}
+
+#[test]
+fn change_file_mtime_to_reference() {
+    Playground::setup("change_file_mtime_to_reference", |dirs, sandbox| {
+        sandbox.with_files(vec![
+            Stub::EmptyFile("reference_file"),
+            Stub::EmptyFile("target_file"),
+        ]);
+
+        let reference = dirs.test().join("reference_file");
+        let target = dirs.test().join("target_file");
+
+        // Change the times for reference
+        filetime::set_file_times(
+            &reference,
+            TIME_ONE,
+            filetime::FileTime::from_unix_time(1337, 0),
+        )
+        .unwrap();
+
+        // target should have today's date since it was just created, but reference should be different
+        assert_ne!(
+            reference.metadata().unwrap().accessed().unwrap(),
+            target.metadata().unwrap().accessed().unwrap()
+        );
+        assert_ne!(
+            reference.metadata().unwrap().modified().unwrap(),
+            target.metadata().unwrap().modified().unwrap()
+        );
+
+        // Save target's current atime to make sure it is preserved
+        let target_original_atime = target.metadata().unwrap().accessed().unwrap();
+
+        nu!(
+            cwd: dirs.test(),
+            "touch -mr reference_file target_file"
+        );
+
+        assert_eq!(
+            reference.metadata().unwrap().modified().unwrap(),
+            target.metadata().unwrap().modified().unwrap()
+        );
+        assert_ne!(
+            reference.metadata().unwrap().accessed().unwrap(),
+            target.metadata().unwrap().accessed().unwrap()
+        );
+        assert_eq!(
+            target_original_atime,
+            target.metadata().unwrap().accessed().unwrap()
+        );
+    })
+}
+
+#[test]
+fn change_modified_time_of_dir_to_today() {
+    Playground::setup("change_dir_mtime", |dirs, sandbox| {
+        sandbox.mkdir("test_dir");
+        let path = dirs.test().join("test_dir");
+
+        filetime::set_file_mtime(&path, TIME_ONE).unwrap();
+
+        nu!(
+            cwd: dirs.test(),
+            "touch -m test_dir"
+        );
+
+        // Check only the date since the time may not match exactly
+        let today = Local::now().date_naive();
+        let mtime_day =
+            DateTime::<Local>::from(path.metadata().unwrap().modified().unwrap()).date_naive();
+
+        assert_eq!(today, mtime_day);
+    })
+}
+
+#[test]
+fn change_access_time_of_dir_to_today() {
+    Playground::setup("change_dir_atime", |dirs, sandbox| {
+        sandbox.mkdir("test_dir");
+        let path = dirs.test().join("test_dir");
+
+        filetime::set_file_atime(&path, TIME_ONE).unwrap();
+
+        nu!(
+            cwd: dirs.test(),
+            "touch -a test_dir"
+        );
+
+        // Check only the date since the time may not match exactly
+        let today = Local::now().date_naive();
+        let atime_day =
+            DateTime::<Local>::from(path.metadata().unwrap().accessed().unwrap()).date_naive();
+
+        assert_eq!(today, atime_day);
+    })
+}
+
+#[test]
+fn change_modified_and_access_time_of_dir_to_today() {
+    Playground::setup("change_dir_times", |dirs, sandbox| {
+        sandbox.mkdir("test_dir");
+        let path = dirs.test().join("test_dir");
+
+        filetime::set_file_times(&path, TIME_ONE, TIME_ONE).unwrap();
+
+        nu!(
+            cwd: dirs.test(),
+            "touch -a -m test_dir"
+        );
+
+        let metadata = path.metadata().unwrap();
+
+        // Check only the date since the time may not match exactly
+        let today = Local::now().date_naive();
+        let mtime_day = DateTime::<Local>::from(metadata.modified().unwrap()).date_naive();
+        let atime_day = DateTime::<Local>::from(metadata.accessed().unwrap()).date_naive();
+
+        assert_eq!(today, mtime_day);
+        assert_eq!(today, atime_day);
+    })
+}
+
+#[test]
+fn change_dir_three_dots_times() {
+    Playground::setup("change_dir_three_dots_times", |dirs, sandbox| {
+        sandbox.mkdir("test_dir...");
+        let path = dirs.test().join("test_dir...");
+
+        filetime::set_file_times(&path, TIME_ONE, TIME_ONE).unwrap();
+
+        nu!(
+            cwd: dirs.test(),
+            "touch test_dir..."
+        );
+
+        let metadata = path.metadata().unwrap();
+
+        // Check only the date since the time may not match exactly
+        let today = Local::now().date_naive();
+        let mtime_day = DateTime::<Local>::from(metadata.modified().unwrap()).date_naive();
+        let atime_day = DateTime::<Local>::from(metadata.accessed().unwrap()).date_naive();
+
+        assert_eq!(today, mtime_day);
+        assert_eq!(today, atime_day);
+    })
+}
+
+#[test]
+fn change_dir_times_to_reference_dir() {
+    Playground::setup("change_dir_times_to_reference_dir", |dirs, sandbox| {
+        sandbox.mkdir("reference_dir");
+        sandbox.mkdir("target_dir");
+
+        let reference = dirs.test().join("reference_dir");
+        let target = dirs.test().join("target_dir");
+
+        // Change the times for reference
+        filetime::set_file_times(
+            &reference,
+            filetime::FileTime::from_unix_time(1337, 0),
+            TIME_ONE,
+        )
+        .unwrap();
+
+        // target should have today's date since it was just created, but reference should be different
+        assert_ne!(
+            reference.metadata().unwrap().accessed().unwrap(),
+            target.metadata().unwrap().accessed().unwrap()
+        );
+        assert_ne!(
+            reference.metadata().unwrap().modified().unwrap(),
+            target.metadata().unwrap().modified().unwrap()
+        );
+
+        nu!(
+            cwd: dirs.test(),
+            "touch -r reference_dir target_dir"
+        );
+
+        assert_eq!(
+            reference.metadata().unwrap().accessed().unwrap(),
+            target.metadata().unwrap().accessed().unwrap()
+        );
+        assert_eq!(
+            reference.metadata().unwrap().modified().unwrap(),
+            target.metadata().unwrap().modified().unwrap()
+        );
+    })
+}
+
+#[test]
+fn change_dir_atime_to_reference() {
+    Playground::setup("change_dir_atime_to_reference", |dirs, sandbox| {
+        sandbox.mkdir("reference_dir");
+        sandbox.mkdir("target_dir");
+
+        let reference = dirs.test().join("reference_dir");
+        let target = dirs.test().join("target_dir");
+
+        // Change the times for reference
+        filetime::set_file_times(
+            &reference,
+            filetime::FileTime::from_unix_time(1337, 0),
+            TIME_ONE,
+        )
+        .unwrap();
+
+        // target should have today's date since it was just created, but reference should be different
+        assert_ne!(
+            reference.metadata().unwrap().accessed().unwrap(),
+            target.metadata().unwrap().accessed().unwrap()
+        );
+        assert_ne!(
+            reference.metadata().unwrap().modified().unwrap(),
+            target.metadata().unwrap().modified().unwrap()
+        );
+
+        // Save target's current mtime to make sure it is preserved
+        let target_original_mtime = target.metadata().unwrap().modified().unwrap();
+
+        nu!(
+            cwd: dirs.test(),
+            "touch -ar reference_dir target_dir"
+        );
+
+        assert_eq!(
+            reference.metadata().unwrap().accessed().unwrap(),
+            target.metadata().unwrap().accessed().unwrap()
+        );
+        assert_ne!(
+            reference.metadata().unwrap().modified().unwrap(),
+            target.metadata().unwrap().modified().unwrap()
+        );
+        assert_eq!(
+            target_original_mtime,
+            target.metadata().unwrap().modified().unwrap()
+        );
+    })
+}