Robot
/
fd
mirror of https://github.com/sharkdp/fd.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Reimplement dirname, basename, remove_extension for OsStr

This commit is contained in:
sharkdp 2020-04-04 11:40:27 +02:00 committed by David Peter
parent 439548c25a
commit 7e3c69c096
3 changed files with 64 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
src/exec/input.rs
View File

@ -1,70 +1,40 @@
use std::path::MAIN_SEPARATOR;
use std::ffi::{OsStr, OsString};
use std::path::{Path, PathBuf};
use crate::filesystem::strip_current_dir;
/// Removes the parent component of the path
pub fn basename(path: &str) -> &str {
let mut index = 0;
for (id, character) in path.char_indices() {
if character == MAIN_SEPARATOR {
index = id;
}
}
// FIXME: On Windows, should return what for C:file.txt D:file.txt and \\server\share ?
if index != 0 {
return &path[index + 1..];
}
path
pub fn basename(path: &Path) -> &OsStr {
path.file_name().unwrap_or(path.as_os_str())
}
/// Removes the extension from the path
pub fn remove_extension(path: &str) -> &str {
let mut has_dir = false;
let mut dir_index = 0;
let mut ext_index = 0;
pub fn remove_extension(path: &Path) -> OsString {
let dirname = dirname(path);
let stem = path.file_stem().unwrap_or(path.as_os_str());
for (id, character) in path.char_indices() {
if character == MAIN_SEPARATOR {
has_dir = true;
dir_index = id;
}
if character == '.' {
ext_index = id;
}
}
let path = PathBuf::from(dirname).join(stem);
// Account for hidden files and directories
if ext_index != 0 && (!has_dir || dir_index + 2 <= ext_index) {
return &path[0..ext_index];
}
path
strip_current_dir(&path).to_owned().into_os_string()
}
/// Removes the basename from the path.
pub fn dirname(path: &str) -> &str {
let mut has_dir = false;
let mut index = 0;
for (id, character) in path.char_indices() {
if character == MAIN_SEPARATOR {
has_dir = true;
index = id;
}
}
// FIXME: On Windows, return what for C:file.txt D:file.txt and \\server\share ?
if !has_dir {
"."
} else if index == 0 {
&path[..1]
} else {
&path[0..index]
}
pub fn dirname(path: &Path) -> OsString {
path.parent()
.map(|p| {
if p == OsStr::new("") {
OsString::from(".")
} else {
p.as_os_str().to_owned()
}
})
.unwrap_or(path.as_os_str().to_owned())
}
#[cfg(test)]
mod path_tests {
use super::*;
use std::path::MAIN_SEPARATOR;
fn correct(input: &str) -> String {
input.replace('/', &MAIN_SEPARATOR.to_string())
@ -75,7 +45,9 @@ mod path_tests {
$(
#[test]
fn $name() {
assert_eq!($func(&correct($input)), correct($output));
let input_path = PathBuf::from(&correct($input));
let output_string = OsString::from(correct($output));
assert_eq!($func(&input_path), output_string);
}
)+
}
@ -98,16 +70,18 @@ mod path_tests {
dirname_dir: dirname for "dir/foo.txt" => "dir"
dirname_utf8_0: dirname for "💖/foo.txt" => "💖"
dirname_utf8_1: dirname for "dir/💖.txt" => "dir"
dirname_empty: dirname for "" => "."
}
#[test]
#[cfg(windows)]
fn dirname_root() {
#[cfg(windows)]
assert_eq!(dirname("C:\\"), "C:");
#[cfg(windows)]
assert_eq!(dirname("\\"), "\\");
#[cfg(not(windows))]
assert_eq!(dirname("/"), "/");
assert_eq!(dirname(&PathBuf::from("C:\\")), OsString::from("C:"));
assert_eq!(dirname(&PathBuf::from("\\")), OsString::from("\\"));
}
#[test]
#[cfg(not(windows))]
fn dirname_root() {
assert_eq!(dirname(&PathBuf::from("/")), OsString::from("/"));
}
}

36
src/exec/mod.rs
View File

@ -3,7 +3,7 @@ mod input;
mod job;
mod token;
use std::borrow::Cow;
use std::ffi::OsString;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::{Arc, Mutex};
@ -136,9 +136,9 @@ impl CommandTemplate {
pub fn generate_and_execute(&self, input: &Path, out_perm: Arc<Mutex<()>>) -> ExitCode {
let input = strip_current_dir(input);
let mut cmd = Command::new(self.args[0].generate(&input).as_ref());
let mut cmd = Command::new(self.args[0].generate(&input));
for arg in &self.args[1..] {
cmd.arg(arg.generate(&input).as_ref());
cmd.arg(arg.generate(&input));
}
execute_command(cmd, &out_perm)
@ -152,7 +152,7 @@ impl CommandTemplate {
where
I: Iterator<Item = PathBuf>,
{
let mut cmd = Command::new(self.args[0].generate("").as_ref());
let mut cmd = Command::new(self.args[0].generate(""));
cmd.stdin(Stdio::inherit());
cmd.stdout(Stdio::inherit());
cmd.stderr(Stdio::inherit());
@ -167,11 +167,11 @@ impl CommandTemplate {
// A single `Tokens` is expected
// So we can directly consume the iterator once and for all
for path in &mut paths {
cmd.arg(arg.generate(strip_current_dir(path)).as_ref());
cmd.arg(arg.generate(strip_current_dir(path)));
has_path = true;
}
} else {
cmd.arg(arg.generate("").as_ref());
cmd.arg(arg.generate(""));
}
}
@ -201,27 +201,27 @@ impl ArgumentTemplate {
}
}
pub fn generate<'a>(&'a self, path: impl AsRef<Path>) -> Cow<'a, str> {
pub fn generate<'a>(&'a self, path: impl AsRef<Path>) -> OsString {
use self::Token::*;
let path = path.as_ref().to_string_lossy(); // TODO
match *self {
ArgumentTemplate::Tokens(ref tokens) => {
let mut s = String::new();
let mut s = OsString::new();
for token in tokens {
match *token {
Basename => s += basename(&path),
BasenameNoExt => s += remove_extension(basename(&path)),
NoExt => s += remove_extension(&path),
Parent => s += dirname(&path),
Placeholder => s += &path,
Text(ref string) => s += string,
Basename => s.push(basename(path.as_ref())),
BasenameNoExt => {
s.push(remove_extension(&PathBuf::from(basename(path.as_ref()))))
}
NoExt => s.push(remove_extension(path.as_ref())),
Parent => s.push(dirname(path.as_ref())),
Placeholder => s.push(path.as_ref()),
Text(ref string) => s.push(string),
}
}
Cow::Owned(s)
s
}
ArgumentTemplate::Text(ref text) => Cow::Borrowed(text),
ArgumentTemplate::Text(ref text) => OsString::from(text),
}
}
}

16
src/main.rs
View File

@ -38,7 +38,7 @@ fn run() -> Result<ExitCode> {
let matches = app::build_app().get_matches_from(env::args_os());
// Set the current working directory of the process
if let Some(base_directory) = matches.value_of("base-directory") {
if let Some(base_directory) = matches.value_of_os("base-directory") {
let base_directory = Path::new(base_directory);
if !filesystem::is_dir(base_directory) {
return Err(anyhow!(
@ -62,12 +62,20 @@ fn run() -> Result<ExitCode> {
}
// Get the search pattern
let pattern = matches.value_of("pattern").unwrap_or("");
let pattern = matches
.value_of_os("pattern")
.map(|p| {
p.to_str().ok_or(anyhow!(
"The search pattern includes invalid UTF-8 sequences."
))
})
.transpose()?
.unwrap_or("");
// Get one or more root directories to search.
let mut dir_vec: Vec<_> = match matches
.values_of("path")
.or_else(|| matches.values_of("search-path"))
.values_of_os("path")
.or_else(|| matches.values_of_os("search-path"))
{
Some(paths) => paths
.map(|path| {