refactor: Avoid unnecessary allocation

Use Cow::borrowed, if we can re-use the already absolute path.

Author: tmccombs

src/filesystem.rs

@@ -20,17 +20,6 @@ pub fn path_absolute_form(path: &Path) -> io::Result<PathBuf> {
     env::current_dir().map(|path_buf| path_buf.join(path))
 }
 
-/// Construct an absolute path from a potentially relative path and a
-/// pre-resolved working directory. Unlike `path_absolute_form`, this
-/// does not call `env::current_dir()` and cannot fail.
-pub fn make_absolute(path: &Path, cwd: &Path) -> PathBuf {
-    if path.is_absolute() {
-        return path.to_path_buf();
-    }
-    let path = path.strip_prefix(".").unwrap_or(path);
-    cwd.join(path)
-}
-
 pub fn absolute_path(path: &Path) -> io::Result<PathBuf> {
     let path_buf = path_absolute_form(path)?;
 
@@ -164,40 +153,4 @@ mod tests {
             Path::new("foo/bar/baz")
         );
     }
-
-    #[test]
-    fn make_absolute_with_relative_path() {
-        use super::make_absolute;
-        use std::path::PathBuf;
-
-        let cwd = Path::new("/home/user");
-        assert_eq!(
-            make_absolute(Path::new("foo/bar"), cwd),
-            PathBuf::from("/home/user/foo/bar")
-        );
-    }
-
-    #[test]
-    fn make_absolute_strips_dot_prefix() {
-        use super::make_absolute;
-        use std::path::PathBuf;
-
-        let cwd = Path::new("/home/user");
-        assert_eq!(
-            make_absolute(Path::new("./foo/bar"), cwd),
-            PathBuf::from("/home/user/foo/bar")
-        );
-    }
-
-    #[test]
-    fn make_absolute_with_absolute_path() {
-        use super::make_absolute;
-        use std::path::PathBuf;
-
-        let cwd = Path::new("/home/user");
-        assert_eq!(
-            make_absolute(Path::new("/absolute/path"), cwd),
-            PathBuf::from("/absolute/path")
-        );
-    }
 }

src/walk.rs

@@ -665,11 +665,16 @@ impl WorkerState {
 
 fn search_str_for_entry<'a>(
     entry_path: &'a std::path::Path,
-    cwd: Option<&std::path::Path>,
+    full_path_base: Option<&std::path::Path>,
 ) -> Cow<'a, OsStr> {
-    if let Some(cwd) = cwd {
-        let abs_path = filesystem::make_absolute(entry_path, cwd);
-        Cow::Owned(abs_path.into_os_string())
+    if let Some(cwd) = full_path_base {
+        // If full_path_base is some, that means that we need to return
+        // the absolute path
+        if entry_path.is_absolute() {
+            return Cow::Borrowed(entry_path.as_os_str());
+        }
+        let path = entry_path.strip_prefix(".").unwrap_or(entry_path);
+        Cow::Owned(cwd.join(path).into())
     } else {
         match entry_path.file_name() {
             Some(filename) => Cow::Borrowed(filename),
@@ -690,3 +695,44 @@ fn search_str_for_entry<'a>(
 pub fn scan(paths: &[PathBuf], patterns: Vec<Regex>, config: Config) -> Result<ExitCode> {
     WorkerState::new(patterns, config).scan(paths)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::search_str_for_entry;
+    use std::path::{Path, PathBuf};
+
+    #[test]
+    fn search_str_for_entry_with_relative_path() {
+        let full_path_base = Some(Path::new("/home/user"));
+        assert_eq!(
+            search_str_for_entry(Path::new("foo/bar"), full_path_base),
+            PathBuf::from("/home/user/foo/bar")
+        );
+    }
+
+    #[test]
+    fn search_str_for_entry_strips_dot_prefix() {
+        let full_path_base = Some(Path::new("/home/user"));
+        assert_eq!(
+            search_str_for_entry(Path::new("./foo/bar"), full_path_base),
+            PathBuf::from("/home/user/foo/bar")
+        );
+    }
+
+    #[test]
+    fn search_str_for_entry_with_absolute_path() {
+        let full_path_base = Some(Path::new("/home/user"));
+        assert_eq!(
+            search_str_for_entry(Path::new("/absolute/path"), full_path_base),
+            PathBuf::from("/absolute/path")
+        );
+    }
+
+    #[test]
+    fn search_str_no_base_dir() {
+        assert_eq!(
+            search_str_for_entry(Path::new("./foo/bar"), None),
+            PathBuf::from("bar")
+        );
+    }
+}