Merge pull request sharkdp#812 from yyogo/master

Append trailing path separators to directories

Author: sharkdp

CHANGELOG.md

@@ -14,6 +14,7 @@
 ## Changes
 
 - Changed `-u` flag to be equivalent to `-HI`. Multiple `-u` flags still allowed but do nothing, see #840 (@jacksontheel)
+- Directories are now printed with an additional path separator at the end: `foo/bar/`, see #436 and #812 (@yyogo)
 
 ## Other
 

src/config.rs

@@ -111,6 +111,9 @@ pub struct Config {
     /// The separator used to print file paths.
     pub path_separator: Option<String>,
 
+    /// The actual separator, either the system default separator or `path_separator`
+    pub actual_path_separator: String,
+
     /// The maximum number of search results
     pub max_results: Option<usize>,
 

src/dir_entry.rs

@@ -0,0 +1,92 @@
+use std::{
+    fs::{FileType, Metadata},
+    path::{Path, PathBuf},
+};
+
+use once_cell::unsync::OnceCell;
+
+enum DirEntryInner {
+    Normal(ignore::DirEntry),
+    BrokenSymlink(PathBuf),
+}
+
+pub struct DirEntry {
+    inner: DirEntryInner,
+    metadata: OnceCell<Option<Metadata>>,
+}
+
+impl DirEntry {
+    #[inline]
+    pub fn normal(e: ignore::DirEntry) -> Self {
+        Self {
+            inner: DirEntryInner::Normal(e),
+            metadata: OnceCell::new(),
+        }
+    }
+
+    pub fn broken_symlink(path: PathBuf) -> Self {
+        Self {
+            inner: DirEntryInner::BrokenSymlink(path),
+            metadata: OnceCell::new(),
+        }
+    }
+
+    pub fn path(&self) -> &Path {
+        match &self.inner {
+            DirEntryInner::Normal(e) => e.path(),
+            DirEntryInner::BrokenSymlink(pathbuf) => pathbuf.as_path(),
+        }
+    }
+
+    pub fn into_path(self) -> PathBuf {
+        match self.inner {
+            DirEntryInner::Normal(e) => e.into_path(),
+            DirEntryInner::BrokenSymlink(p) => p,
+        }
+    }
+
+    pub fn file_type(&self) -> Option<FileType> {
+        match &self.inner {
+            DirEntryInner::Normal(e) => e.file_type(),
+            DirEntryInner::BrokenSymlink(_) => self.metadata().map(|m| m.file_type()),
+        }
+    }
+
+    pub fn metadata(&self) -> Option<&Metadata> {
+        self.metadata
+            .get_or_init(|| match &self.inner {
+                DirEntryInner::Normal(e) => e.metadata().ok(),
+                DirEntryInner::BrokenSymlink(path) => path.symlink_metadata().ok(),
+            })
+            .as_ref()
+    }
+
+    pub fn depth(&self) -> Option<usize> {
+        match &self.inner {
+            DirEntryInner::Normal(e) => Some(e.depth()),
+            DirEntryInner::BrokenSymlink(_) => None,
+        }
+    }
+}
+
+impl PartialEq for DirEntry {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.path() == other.path()
+    }
+}
+impl Eq for DirEntry {}
+
+impl PartialOrd for DirEntry {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        self.path().partial_cmp(other.path())
+    }
+}
+
+impl Ord for DirEntry {
+    #[inline]
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.path().cmp(other.path())
+    }
+}

src/exec/job.rs

@@ -1,7 +1,7 @@
-use std::path::PathBuf;
 use std::sync::mpsc::Receiver;
 use std::sync::{Arc, Mutex};
 
+use crate::dir_entry::DirEntry;
 use crate::error::print_error;
 use crate::exit_codes::{merge_exitcodes, ExitCode};
 use crate::walk::WorkerResult;
@@ -25,8 +25,8 @@ pub fn job(
 
         // Obtain the next result from the receiver, else if the channel
         // has closed, exit from the loop
-        let value: PathBuf = match lock.recv() {
-            Ok(WorkerResult::Entry(path)) => path,
+        let dir_entry: DirEntry = match lock.recv() {
+            Ok(WorkerResult::Entry(dir_entry)) => dir_entry,
             Ok(WorkerResult::Error(err)) => {
                 if show_filesystem_errors {
                     print_error(err.to_string());
@@ -39,7 +39,7 @@ pub fn job(
         // Drop the lock so that other threads can read from the receiver.
         drop(lock);
         // Generate a command, execute it and store its exit code.
-        results.push(cmd.execute(&value, Arc::clone(&out_perm), buffer_output))
+        results.push(cmd.execute(dir_entry.path(), Arc::clone(&out_perm), buffer_output))
     }
     // Returns error in case of any error.
     merge_exitcodes(results)
@@ -51,15 +51,17 @@ pub fn batch(
     show_filesystem_errors: bool,
     limit: usize,
 ) -> ExitCode {
-    let paths = rx.iter().filter_map(|value| match value {
-        WorkerResult::Entry(path) => Some(path),
-        WorkerResult::Error(err) => {
-            if show_filesystem_errors {
-                print_error(err.to_string());
+    let paths = rx
+        .into_iter()
+        .filter_map(|worker_result| match worker_result {
+            WorkerResult::Entry(dir_entry) => Some(dir_entry.into_path()),
+            WorkerResult::Error(err) => {
+                if show_filesystem_errors {
+                    print_error(err.to_string());
+                }
+                None
             }
-            None
-        }
-    });
+        });
     if limit == 0 {
         // no limit
         return cmd.execute_batch(paths);

src/filesystem.rs

@@ -9,7 +9,7 @@ use std::path::{Path, PathBuf};
 
 use normpath::PathExt;
 
-use crate::walk;
+use crate::dir_entry;
 
 pub fn path_absolute_form(path: &Path) -> io::Result<PathBuf> {
     if path.is_absolute() {
@@ -51,7 +51,7 @@ pub fn is_executable(_: &fs::Metadata) -> bool {
     false
 }
 
-pub fn is_empty(entry: &walk::DirEntry) -> bool {
+pub fn is_empty(entry: &dir_entry::DirEntry) -> bool {
     if let Some(file_type) = entry.file_type() {
         if file_type.is_dir() {
             if let Ok(mut entries) = fs::read_dir(entry.path()) {

src/filetypes.rs

@@ -1,5 +1,5 @@
+use crate::dir_entry;
 use crate::filesystem;
-use crate::walk;
 
 /// Whether or not to show
 #[derive(Default)]
@@ -14,7 +14,7 @@ pub struct FileTypes {
 }
 
 impl FileTypes {
-    pub fn should_ignore(&self, entry: &walk::DirEntry) -> bool {
+    pub fn should_ignore(&self, entry: &dir_entry::DirEntry) -> bool {
         if let Some(ref entry_type) = entry.file_type() {
             (!self.files && entry_type.is_file())
                 || (!self.directories && entry_type.is_dir())

src/main.rs

@@ -1,5 +1,6 @@
 mod app;
 mod config;
+mod dir_entry;
 mod error;
 mod exec;
 mod exit_codes;
@@ -221,6 +222,9 @@ fn construct_config(matches: clap::ArgMatches, pattern_regex: &str) -> Result<Co
     let path_separator = matches
         .value_of("path-separator")
         .map_or_else(filesystem::default_path_separator, |s| Some(s.to_owned()));
+    let actual_path_separator = path_separator
+        .clone()
+        .unwrap_or_else(|| std::path::MAIN_SEPARATOR.to_string());
     check_path_separator_length(path_separator.as_deref())?;
 
     let size_limits = extract_size_limits(&matches)?;
@@ -367,6 +371,7 @@ fn construct_config(matches: clap::ArgMatches, pattern_regex: &str) -> Result<Co
         owner_constraint,
         show_filesystem_errors: matches.is_present("show-errors"),
         path_separator,
+        actual_path_separator,
         max_results: matches
             .value_of("max-results")
             .map(|n| n.parse::<usize>())

src/output.rs

@@ -5,6 +5,7 @@ use std::path::Path;
 use lscolors::{Indicator, LsColors, Style};
 
 use crate::config::Config;
+use crate::dir_entry::DirEntry;
 use crate::error::print_error;
 use crate::exit_codes::ExitCode;
 use crate::filesystem::strip_current_dir;
@@ -13,18 +14,21 @@ fn replace_path_separator(path: &str, new_path_separator: &str) -> String {
     path.replace(std::path::MAIN_SEPARATOR, new_path_separator)
 }
 
-// TODO: this function is performance critical and can probably be optimized
-pub fn print_entry<W: Write>(stdout: &mut W, entry: &Path, config: &Config) {
-    let path = if config.strip_cwd_prefix {
-        strip_current_dir(entry)
+fn stripped_path<'a>(entry: &'a DirEntry, config: &Config) -> &'a Path {
+    let path = entry.path();
+    if config.strip_cwd_prefix {
+        strip_current_dir(path)
     } else {
-        entry
-    };
+        path
+    }
+}
 
+// TODO: this function is performance critical and can probably be optimized
+pub fn print_entry<W: Write>(stdout: &mut W, entry: &DirEntry, config: &Config) {
     let r = if let Some(ref ls_colors) = config.ls_colors {
-        print_entry_colorized(stdout, path, config, ls_colors)
+        print_entry_colorized(stdout, entry, config, ls_colors)
     } else {
-        print_entry_uncolorized(stdout, path, config)
+        print_entry_uncolorized(stdout, entry, config)
     };
 
     if let Err(e) = r {
@@ -38,15 +42,39 @@ pub fn print_entry<W: Write>(stdout: &mut W, entry: &Path, config: &Config) {
     }
 }
 
+// Display a trailing slash if the path is a directory and the config option is enabled.
+// If the path_separator option is set, display that instead.
+// The trailing slash will not be colored.
+#[inline]
+fn print_trailing_slash<W: Write>(
+    stdout: &mut W,
+    entry: &DirEntry,
+    config: &Config,
+    style: Option<&Style>,
+) -> io::Result<()> {
+    if entry.file_type().map_or(false, |ft| ft.is_dir()) {
+        write!(
+            stdout,
+            "{}",
+            style
+                .map(Style::to_ansi_term_style)
+                .unwrap_or_default()
+                .paint(&config.actual_path_separator)
+        )?;
+    }
+    Ok(())
+}
+
 // TODO: this function is performance critical and can probably be optimized
 fn print_entry_colorized<W: Write>(
     stdout: &mut W,
-    path: &Path,
+    entry: &DirEntry,
     config: &Config,
     ls_colors: &LsColors,
 ) -> io::Result<()> {
     // Split the path between the parent and the last component
     let mut offset = 0;
+    let path = stripped_path(entry, config);
     let path_str = path.to_string_lossy();
 
     if let Some(parent) = path.parent() {
@@ -74,11 +102,18 @@ fn print_entry_colorized<W: Write>(
     }
 
     let style = ls_colors
-        .style_for_path(path)
+        .style_for_path_with_metadata(path, entry.metadata())
         .map(Style::to_ansi_term_style)
         .unwrap_or_default();
     write!(stdout, "{}", style.paint(&path_str[offset..]))?;
 
+    print_trailing_slash(
+        stdout,
+        entry,
+        config,
+        ls_colors.style_for_indicator(Indicator::Directory),
+    )?;
+
     if config.null_separator {
         write!(stdout, "\0")?;
     } else {
@@ -91,42 +126,46 @@ fn print_entry_colorized<W: Write>(
 // TODO: this function is performance critical and can probably be optimized
 fn print_entry_uncolorized_base<W: Write>(
     stdout: &mut W,
-    path: &Path,
+    entry: &DirEntry,
     config: &Config,
 ) -> io::Result<()> {
     let separator = if config.null_separator { "\0" } else { "\n" };
+    let path = stripped_path(entry, config);
 
     let mut path_string = path.to_string_lossy();
     if let Some(ref separator) = config.path_separator {
         *path_string.to_mut() = replace_path_separator(&path_string, separator);
     }
-    write!(stdout, "{}{}", path_string, separator)
+    write!(stdout, "{}", path_string)?;
+    print_trailing_slash(stdout, entry, config, None)?;
+    write!(stdout, "{}", separator)
 }
 
 #[cfg(not(unix))]
 fn print_entry_uncolorized<W: Write>(
     stdout: &mut W,
-    path: &Path,
+    entry: &DirEntry,
     config: &Config,
 ) -> io::Result<()> {
-    print_entry_uncolorized_base(stdout, path, config)
+    print_entry_uncolorized_base(stdout, entry, config)
 }
 
 #[cfg(unix)]
 fn print_entry_uncolorized<W: Write>(
     stdout: &mut W,
-    path: &Path,
+    entry: &DirEntry,
     config: &Config,
 ) -> io::Result<()> {
     use std::os::unix::ffi::OsStrExt;
 
     if config.interactive_terminal || config.path_separator.is_some() {
         // Fall back to the base implementation
-        print_entry_uncolorized_base(stdout, path, config)
+        print_entry_uncolorized_base(stdout, entry, config)
     } else {
         // Print path as raw bytes, allowing invalid UTF-8 filenames to be passed to other processes
         let separator = if config.null_separator { b"\0" } else { b"\n" };
-        stdout.write_all(path.as_os_str().as_bytes())?;
+        stdout.write_all(stripped_path(entry, config).as_os_str().as_bytes())?;
+        print_trailing_slash(stdout, entry, config, None)?;
         stdout.write_all(separator)
     }
 }