fd/src/output.rs

161 lines
4.8 KiB
Rust
Raw Normal View History

use std::borrow::Cow;
use std::io::{self, Write};
2017-10-10 08:01:17 +02:00
use lscolors::{Indicator, LsColors, Style};
2017-10-10 08:01:17 +02:00
2021-08-23 13:31:01 +02:00
use crate::config::Config;
2021-11-30 08:51:16 +01:00
use crate::dir_entry::DirEntry;
use crate::error::print_error;
2020-04-03 19:01:29 +02:00
use crate::exit_codes::ExitCode;
2018-02-24 17:02:14 +01:00
2021-02-03 09:02:24 +01:00
fn replace_path_separator(path: &str, new_path_separator: &str) -> String {
2021-07-27 08:48:44 +02:00
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: &DirEntry, config: &Config) {
let r = if let Some(ref ls_colors) = config.ls_colors {
print_entry_colorized(stdout, entry, config, ls_colors)
} else {
print_entry_uncolorized(stdout, entry, config)
};
2017-10-10 08:01:17 +02:00
if let Err(e) = r {
if e.kind() == ::std::io::ErrorKind::BrokenPipe {
// Exit gracefully in case of a broken pipe (e.g. 'fd ... | head -n 3').
2021-11-14 22:31:38 +01:00
ExitCode::Success.exit();
} else {
print_error(format!("Could not write to output: {}", e));
2021-11-14 22:31:38 +01:00
ExitCode::GeneralError.exit();
}
}
}
2017-10-10 08:01:17 +02:00
// 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(())
}
2020-04-03 22:51:41 +02:00
// TODO: this function is performance critical and can probably be optimized
fn print_entry_colorized<W: Write>(
stdout: &mut W,
entry: &DirEntry,
2021-08-23 13:31:01 +02:00
config: &Config,
ls_colors: &LsColors,
) -> io::Result<()> {
// Split the path between the parent and the last component
let mut offset = 0;
let path = entry.stripped_path(config);
let path_str = path.to_string_lossy();
2017-10-10 08:01:17 +02:00
if let Some(parent) = path.parent() {
offset = parent.to_string_lossy().len();
for c in path_str[offset..].chars() {
if std::path::is_separator(c) {
offset += c.len_utf8();
} else {
break;
}
}
}
2017-10-10 08:01:17 +02:00
if offset > 0 {
let mut parent_str = Cow::from(&path_str[..offset]);
if let Some(ref separator) = config.path_separator {
*parent_str.to_mut() = replace_path_separator(&parent_str, separator);
}
let style = ls_colors
.style_for_indicator(Indicator::Directory)
.map(Style::to_ansi_term_style)
.unwrap_or_default();
write!(stdout, "{}", style.paint(parent_str))?;
}
2017-10-10 08:01:17 +02:00
let style = ls_colors
.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")?;
2017-10-10 08:01:17 +02:00
} else {
writeln!(stdout)?;
}
Ok(())
}
2017-10-10 08:01:17 +02:00
2020-04-03 22:51:41 +02:00
// TODO: this function is performance critical and can probably be optimized
fn print_entry_uncolorized_base<W: Write>(
stdout: &mut W,
entry: &DirEntry,
2021-08-23 13:31:01 +02:00
config: &Config,
2019-01-01 22:52:08 +01:00
) -> io::Result<()> {
let separator = if config.null_separator { "\0" } else { "\n" };
let path = entry.stripped_path(config);
2017-10-10 08:01:17 +02:00
let mut path_string = path.to_string_lossy();
if let Some(ref separator) = config.path_separator {
2021-07-27 08:48:44 +02:00
*path_string.to_mut() = replace_path_separator(&path_string, separator);
}
write!(stdout, "{}", path_string)?;
print_trailing_slash(stdout, entry, config, None)?;
write!(stdout, "{}", separator)
2017-10-14 03:44:24 +02:00
}
#[cfg(not(unix))]
fn print_entry_uncolorized<W: Write>(
stdout: &mut W,
entry: &DirEntry,
2021-08-23 13:31:01 +02:00
config: &Config,
) -> io::Result<()> {
print_entry_uncolorized_base(stdout, entry, config)
}
#[cfg(unix)]
fn print_entry_uncolorized<W: Write>(
stdout: &mut W,
entry: &DirEntry,
2021-08-23 13:31:01 +02:00
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, 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(entry.stripped_path(config).as_os_str().as_bytes())?;
print_trailing_slash(stdout, entry, config, None)?;
stdout.write_all(separator)
}
}