fix: resolve relative paths when constructing TempPath

1. Try to transform relative paths into absolute paths in
`TempPath::from_path` and silently proceed when we can't.

2. Deprecate `TempPath::from_path` and add `TempPath::try_from_path` as
a replacement that propegates errors.

reported by @meng-xu-cs

fixes #395

Author: Stebalien

src/file/mod.rs

@@ -325,19 +325,65 @@ impl TempPath {
         self.disable_cleanup = disable_cleanup
     }
 
-    /// Create a new TempPath from an existing path. This can be done even if no
-    /// file exists at the given path.
+    /// Create a new TempPath from an existing path. This can be done even if no file exists at the
+    /// given path.
     ///
-    /// This is mostly useful for interacting with libraries and external
-    /// components that provide files to be consumed or expect a path with no
-    /// existing file to be given.
+    /// This is mostly useful for interacting with libraries and external components that provide
+    /// files to be consumed or expect a path with no existing file to be given.
+    ///
+    /// When passed a relative path, this function first tries to make it absolute (relative to the
+    /// current directory). If this fails, this function uses the relative path as-is.
+    ///
+    /// **DEPRECATED:** Use [`TempPath::try_from_path`] instead to handle the case where looking up
+    /// the current directory fails.
+    #[deprecated = "use TempPath::try_from_path"]
     pub fn from_path(path: impl Into<PathBuf>) -> Self {
+        let mut path = path.into();
+        // Best effort to resolve a relative path. If we fail, we keep the path as-is to
+        // preserve backwards compatibility.
+        //
+        // Ignore empty paths entirely. There's nothing we can do about them.
+        if &path != "" && !path.is_absolute() {
+            if let Ok(cur_dir) = std::env::current_dir() {
+                path = cur_dir.join(path);
+            }
+        }
         Self {
-            path: path.into().into_boxed_path(),
+            path: path.into_boxed_path(),
             disable_cleanup: false,
         }
     }
 
+    /// Create a new TempPath from an existing path. This can be done even if no file exists at the
+    /// given path.
+    ///
+    /// This is mostly useful for interacting with libraries and external components that provide
+    /// files to be consumed or expect a path with no existing file to be given.
+    ///
+    /// Relative paths are resolved relative to the current working directory. If the current
+    /// working directory cannot be determined, this function returns an error.
+    ///
+    /// **NOTE:** this function does not check if the target path exists.
+    pub fn try_from_path(path: impl Into<PathBuf>) -> io::Result<Self> {
+        let mut path = path.into();
+        if !path.is_absolute() {
+            if &path == "" {
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    "cannot construct a TempPath from an empty path",
+                ));
+            }
+            let mut cwd = std::env::current_dir()?;
+            cwd.push(path);
+            path = cwd;
+        };
+
+        Ok(Self {
+            path: path.into_boxed_path(),
+            disable_cleanup: false,
+        })
+    }
+
     pub(crate) fn new(path: PathBuf, disable_cleanup: bool) -> Self {
         Self {
             path: path.into_boxed_path(),

tests/namedtempfile.rs

@@ -4,6 +4,7 @@ use std::ffi::{OsStr, OsString};
 use std::fs::File;
 use std::io::{self, Read, Seek, SeekFrom, Write};
 use std::path::{Path, PathBuf};
+use std::time::Duration;
 use tempfile::{env, tempdir, Builder, NamedTempFile, TempPath};
 
 fn exists<P: AsRef<Path>>(path: P) -> bool {
@@ -280,7 +281,7 @@ fn temp_path_from_existing() {
     File::create(&tmp_file_path_2).unwrap();
     assert!(tmp_file_path_2.exists(), "Test file 2 hasn't been created");
 
-    let tmp_path = TempPath::from_path(&tmp_file_path_1);
+    let tmp_path = TempPath::try_from_path(&tmp_file_path_1).unwrap();
     assert!(
         tmp_file_path_1.exists(),
         "Test file has been deleted before dropping TempPath"
@@ -303,13 +304,49 @@ fn temp_path_from_argument_types() {
     // This just has to compile
     return;
 
-    TempPath::from_path("");
-    TempPath::from_path(String::new());
-    TempPath::from_path(OsStr::new(""));
-    TempPath::from_path(OsString::new());
-    TempPath::from_path(Path::new(""));
-    TempPath::from_path(PathBuf::new());
-    TempPath::from_path(PathBuf::new().into_boxed_path());
+    TempPath::try_from_path("").unwrap();
+    TempPath::try_from_path(String::new()).unwrap();
+    TempPath::try_from_path(OsStr::new("")).unwrap();
+    TempPath::try_from_path(OsString::new()).unwrap();
+    TempPath::try_from_path(Path::new("")).unwrap();
+    TempPath::try_from_path(PathBuf::new()).unwrap();
+    TempPath::try_from_path(PathBuf::new().into_boxed_path()).unwrap();
+}
+
+#[test]
+fn test_temp_path_resolve_missing_cwd() {
+    let tmpdir = tempdir().unwrap();
+    std::env::set_current_dir(&tmpdir).expect("failed to change to the temporary directory");
+    tmpdir.close().unwrap();
+    // It can sometimes take a bit for the OS to realize the CWD is removed. I'm not sure why, but
+    // this test fails occasionally without this.
+    while std::env::current_dir().is_ok() {
+        std::thread::sleep(Duration::from_millis(1));
+    }
+
+    #[allow(deprecated)]
+    let path = TempPath::from_path("foo");
+    assert_eq!(&*path, "foo");
+
+    TempPath::try_from_path("foo").expect_err("should have failed to make path absolute file");
+}
+
+#[test]
+fn test_temp_path_resolve_existing_cwd() {
+    let tmpdir = tempdir().unwrap();
+    std::env::set_current_dir(&tmpdir).expect("failed to change to directory");
+
+    #[allow(deprecated)]
+    let path = TempPath::from_path("foo");
+    assert_eq!(&*path, tmpdir.path().join("foo"));
+
+    #[allow(deprecated)]
+    let path = TempPath::from_path("");
+    assert_eq!(&*path, "");
+
+    TempPath::try_from_path("").expect_err("empty paths should fail");
+
+    tmpdir.close().unwrap();
 }
 
 #[test]
@@ -327,7 +364,7 @@ fn test_change_dir() {
     let dir_a = tempdir().unwrap();
     let dir_b = tempdir().unwrap();
 
-    std::env::set_current_dir(&dir_a).expect("failed to change to directory ~");
+    std::env::set_current_dir(&dir_a).expect("failed to change to directory A");
     let tmpfile = NamedTempFile::new_in(".").unwrap();
     let path = std::env::current_dir().unwrap().join(tmpfile.path());
     std::env::set_current_dir(&dir_b).expect("failed to change to directory B");
@@ -574,7 +611,10 @@ fn test_reseed() {
             .open(path)
             .unwrap();
 
-        files.push(NamedTempFile::from_parts(f, TempPath::from_path(path)));
+        files.push(NamedTempFile::from_parts(
+            f,
+            TempPath::try_from_path(path).unwrap(),
+        ));
         Err(io::Error::new(io::ErrorKind::AlreadyExists, "fake!"))
     });