mirror of
https://github.com/nushell/nushell.git
synced 2024-11-07 09:04:18 +01:00
Allow filesystem commands to access files with glob metachars in name (#10694)
(squashed version of #10557, clean commit history and review thread) Fixes #10571, also potentially: #10364, #10211, #9558, #9310, # Description Changes processing of arguments to filesystem commands that are source paths or globs. Applies to `cp, cp-old, mv, rm, du` but not `ls` (because it uses a different globbing interface) or `glob` (because it uses a different globbing library). The core of the change is to lookup the argument first as a file and only glob if it is not. That way, a path containing glob metacharacters can be referenced without glob quoting, though it will have to be single quoted to avoid nushell parsing. Before: A file path that looks like a glob is not matched by the glob specified as a (source) argument and takes some thinking about to access. You might say the glob pattern shadows a file with the same spelling. ``` > ls a* ╭───┬────────┬──────┬──────┬────────────────╮ │ # │ name │ type │ size │ modified │ ├───┼────────┼──────┼──────┼────────────────┤ │ 0 │ a[bc]d │ file │ 0 B │ 34 seconds ago │ │ 1 │ abd │ file │ 0 B │ now │ │ 2 │ acd │ file │ 0 B │ now │ ╰───┴────────┴──────┴──────┴────────────────╯ > cp --verbose 'a[bc]d' dest copied /home/bobhy/src/rust/work/r4/abd to /home/bobhy/src/rust/work/r4/dest/abd copied /home/bobhy/src/rust/work/r4/acd to /home/bobhy/src/rust/work/r4/dest/acd > ## Note -- a[bc]d *not* copied, and seemingly hard to access. > cp --verbose 'a\[bc\]d' dest Error: × No matches found ╭─[entry #33:1:1] 1 │ cp --verbose 'a\[bc\]d' dest · ─────┬──── · ╰── no matches found ╰──── > #.. but is accessible with enough glob quoting. > cp --verbose 'a[[]bc[]]d' dest copied /home/bobhy/src/rust/work/r4/a[bc]d to /home/bobhy/src/rust/work/r4/dest/a[bc]d ``` Before_2: if file has glob metachars but isn't a valid pattern, user gets a confusing error: ``` > touch 'a[b' > cp 'a[b' dest Error: × Pattern syntax error near position 30: invalid range pattern ╭─[entry #13:1:1] 1 │ cp 'a[b' dest · ──┬── · ╰── invalid pattern ╰──── ``` After: Args to cp, mv, etc. are tried first as literal files, and only as globs if not found to be files. ``` > cp --verbose 'a[bc]d' dest copied /home/bobhy/src/rust/work/r4/a[bc]d to /home/bobhy/src/rust/work/r4/dest/a[bc]d > cp --verbose '[a][bc]d' dest copied /home/bobhy/src/rust/work/r4/abd to /home/bobhy/src/rust/work/r4/dest/abd copied /home/bobhy/src/rust/work/r4/acd to /home/bobhy/src/rust/work/r4/dest/acd ``` After_2: file with glob metachars but invalid pattern just works. (though Windows does not allow file name to contain `*`.). ``` > cp --verbose 'a[b' dest copied /home/bobhy/src/rust/work/r4/a[b to /home/bobhy/src/rust/work/r4/dest/a[b ``` So, with this fix, a file shadows a glob pattern with the same spelling. If you have such a file and really want to use the glob pattern, you will have to glob quote some of the characters in the pattern. I think that's less confusing to the user: if ls shows a file with a weird name, s/he'll still be able to copy, rename or delete it. # User-Facing Changes Could break some existing scripts. If user happened to have a file with a globbish name but was using a glob pattern with the same spelling, the new version will process the file and not expand the glob. # Tests + Formatting <!-- Don't forget to add tests that cover your changes. Make sure you've run and fixed any issues with these commands: - `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes) - `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used` to check that you're using the standard code style - `cargo test --workspace` to check that all tests pass (on Windows make sure to [enable developer mode](https://learn.microsoft.com/en-us/windows/apps/get-started/developer-mode-features-and-debugging)) - `cargo run -- -c "use std testing; testing run-tests --path crates/nu-std"` to run the tests for the standard library > **Note** > from `nushell` you can also use the `toolkit` as follows > ```bash > use toolkit.nu # or use an `env_change` hook to activate it automatically > toolkit check pr > ``` --> # After Submitting <!-- If your PR had any user-facing changes, update [the documentation](https://github.com/nushell/nushell.github.io) after the PR is merged, if necessary. This will help us keep the docs up to date. --> --------- Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com>
This commit is contained in:
parent
88a87158c2
commit
09b3dab35d
4
Cargo.lock
generated
4
Cargo.lock
generated
@ -2713,9 +2713,13 @@ dependencies = [
|
||||
"indexmap 2.0.2",
|
||||
"miette",
|
||||
"nu-engine",
|
||||
"nu-glob",
|
||||
"nu-parser",
|
||||
"nu-path",
|
||||
"nu-protocol",
|
||||
"nu-test-support",
|
||||
"nu-utils",
|
||||
"rstest",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
@ -11,8 +11,15 @@ version = "0.86.1"
|
||||
|
||||
[dependencies]
|
||||
nu-engine = { path = "../nu-engine", version = "0.86.1" }
|
||||
nu-glob = { path = "../nu-glob", version = "0.86.1" }
|
||||
nu-parser = { path = "../nu-parser", version = "0.86.1" }
|
||||
nu-path = { path = "../nu-path", version = "0.86.1" }
|
||||
nu-protocol = { version = "0.86.1", path = "../nu-protocol" }
|
||||
indexmap = { version = "2.0" }
|
||||
miette = { version = "5.10", features = ["fancy-no-backtrace"] }
|
||||
nu-protocol = { path = "../nu-protocol", version = "0.86.1" }
|
||||
nu-utils = { path = "../nu-utils", version = "0.86.1" }
|
||||
|
||||
indexmap = "2.0"
|
||||
miette = "5.10.0"
|
||||
|
||||
[dev-dependencies]
|
||||
nu-test-support = { path = "../nu-test-support", version = "0.86.1" }
|
||||
rstest = "0.18.2"
|
||||
|
207
crates/nu-cmd-base/src/arg_glob.rs
Normal file
207
crates/nu-cmd-base/src/arg_glob.rs
Normal file
@ -0,0 +1,207 @@
|
||||
// utilities for expanding globs in command arguments
|
||||
|
||||
use nu_glob::{glob_with_parent, MatchOptions, Paths};
|
||||
use nu_protocol::{ShellError, Spanned};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
// standard glob options to use for filesystem command arguments
|
||||
|
||||
const GLOB_PARAMS: MatchOptions = MatchOptions {
|
||||
case_sensitive: true,
|
||||
require_literal_separator: false,
|
||||
require_literal_leading_dot: false,
|
||||
recursive_match_hidden_dir: true,
|
||||
};
|
||||
|
||||
// handle an argument that could be a literal path or a glob.
|
||||
// if literal path, return just that (whether user can access it or not).
|
||||
// if glob, expand into matching paths, using GLOB_PARAMS options.
|
||||
pub fn arg_glob(
|
||||
pattern: &Spanned<String>, // alleged path or glob
|
||||
cwd: &Path, // current working directory
|
||||
) -> Result<Paths, ShellError> {
|
||||
arg_glob_opt(pattern, cwd, GLOB_PARAMS)
|
||||
}
|
||||
|
||||
// variant of [arg_glob] that requires literal dot prefix in pattern to match dot-prefixed path.
|
||||
pub fn arg_glob_leading_dot(pattern: &Spanned<String>, cwd: &Path) -> Result<Paths, ShellError> {
|
||||
arg_glob_opt(
|
||||
pattern,
|
||||
cwd,
|
||||
MatchOptions {
|
||||
require_literal_leading_dot: true,
|
||||
..GLOB_PARAMS
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
fn arg_glob_opt(
|
||||
pattern: &Spanned<String>,
|
||||
cwd: &Path,
|
||||
options: MatchOptions,
|
||||
) -> Result<Paths, ShellError> {
|
||||
// remove ansi coloring (?)
|
||||
let pattern = {
|
||||
Spanned {
|
||||
item: nu_utils::strip_ansi_string_unlikely(pattern.item.clone()),
|
||||
span: pattern.span,
|
||||
}
|
||||
};
|
||||
|
||||
// if there's a file with same path as the pattern, just return that.
|
||||
let pp = cwd.join(&pattern.item);
|
||||
let md = fs::metadata(pp);
|
||||
#[allow(clippy::single_match)]
|
||||
match md {
|
||||
Ok(_metadata) => {
|
||||
return Ok(Paths::single(&PathBuf::from(pattern.item), cwd));
|
||||
}
|
||||
// file not found, but also "invalid chars in file" (e.g * on Windows). Fall through and glob
|
||||
Err(_) => {}
|
||||
}
|
||||
|
||||
// user wasn't referring to a specific thing in filesystem, try to glob it.
|
||||
match glob_with_parent(&pattern.item, options, cwd) {
|
||||
Ok(p) => Ok(p),
|
||||
Err(pat_err) => {
|
||||
Err(ShellError::InvalidGlobPattern(
|
||||
pat_err.msg.into(),
|
||||
pattern.span, // improve specificity
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use super::*;
|
||||
use nu_glob::GlobResult;
|
||||
use nu_protocol::{Span, Spanned};
|
||||
use nu_test_support::fs::Stub::EmptyFile;
|
||||
use nu_test_support::playground::Playground;
|
||||
use rstest::rstest;
|
||||
|
||||
fn spanned_string(str: &str) -> Spanned<String> {
|
||||
Spanned {
|
||||
item: str.to_string(),
|
||||
span: Span::test_data(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn does_something() {
|
||||
let act = arg_glob(&spanned_string("*"), &PathBuf::from("."));
|
||||
assert!(act.is_ok());
|
||||
for f in act.expect("checked ok") {
|
||||
match f {
|
||||
Ok(p) => {
|
||||
assert!(!p.to_str().unwrap().is_empty());
|
||||
}
|
||||
Err(e) => panic!("unexpected error {:?}", e),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn glob_format_error() {
|
||||
let act = arg_glob(&spanned_string(r#"ab]c[def"#), &PathBuf::from("."));
|
||||
assert!(act.is_err());
|
||||
}
|
||||
|
||||
#[rstest]
|
||||
#[case("*", 4, "no dirs")]
|
||||
#[case("**/*", 7, "incl dirs")]
|
||||
fn glob_subdirs(#[case] pat: &str, #[case] exp_count: usize, #[case] case: &str) {
|
||||
Playground::setup("glob_subdirs", |dirs, sandbox| {
|
||||
sandbox.with_files(vec![
|
||||
EmptyFile("yehuda.txt"),
|
||||
EmptyFile("jttxt"),
|
||||
EmptyFile("andres.txt"),
|
||||
]);
|
||||
sandbox.mkdir(".children");
|
||||
sandbox.within(".children").with_files(vec![
|
||||
EmptyFile("timothy.txt"),
|
||||
EmptyFile("tiffany.txt"),
|
||||
EmptyFile("trish.txt"),
|
||||
]);
|
||||
|
||||
let p: Vec<GlobResult> = arg_glob(&spanned_string(pat), &dirs.test)
|
||||
.expect("no error")
|
||||
.collect();
|
||||
assert_eq!(
|
||||
exp_count,
|
||||
p.iter().filter(|i| i.is_ok()).count(),
|
||||
" case: {case} ",
|
||||
);
|
||||
|
||||
// expected behavior -- that directories are included in results (if name matches pattern)
|
||||
let t = p
|
||||
.iter()
|
||||
.any(|i| i.as_ref().unwrap().to_string_lossy().contains(".children"));
|
||||
assert!(t, "check for dir, case {case}");
|
||||
})
|
||||
}
|
||||
|
||||
#[rstest]
|
||||
#[case("yehuda.txt", true, 1, "matches literal path")]
|
||||
#[case("*", false, 3, "matches glob")]
|
||||
#[case(r#"bad[glob.foo"#, true, 1, "matches literal, would be bad glob pat")]
|
||||
fn exact_vs_glob(
|
||||
#[case] pat: &str,
|
||||
#[case] exp_matches_input: bool,
|
||||
#[case] exp_count: usize,
|
||||
#[case] case: &str,
|
||||
) {
|
||||
Playground::setup("exact_vs_glob", |dirs, sandbox| {
|
||||
sandbox.with_files(vec![
|
||||
EmptyFile("yehuda.txt"),
|
||||
EmptyFile("jttxt"),
|
||||
EmptyFile("bad[glob.foo"),
|
||||
]);
|
||||
|
||||
let res = arg_glob(&spanned_string(pat), &dirs.test)
|
||||
.expect("no error")
|
||||
.collect::<Vec<GlobResult>>();
|
||||
|
||||
eprintln!("res: {:?}", res);
|
||||
if exp_matches_input {
|
||||
assert_eq!(
|
||||
exp_count,
|
||||
res.len(),
|
||||
" case {case}: matches input, but count not 1? "
|
||||
);
|
||||
assert_eq!(
|
||||
&res[0].as_ref().unwrap().to_string_lossy(),
|
||||
pat, // todo: is it OK for glob to return relative paths (not to current cwd, but to arg cwd of arg_glob)?
|
||||
);
|
||||
} else {
|
||||
assert_eq!(exp_count, res.len(), " case: {}: matched glob", case);
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
#[rstest]
|
||||
#[case(r#"realbad[glob.foo"#, true, 1, "error, bad glob")]
|
||||
fn exact_vs_bad_glob(
|
||||
// if path doesn't exist but pattern is not valid glob, should get error.
|
||||
#[case] pat: &str,
|
||||
#[case] _exp_matches_input: bool,
|
||||
#[case] _exp_count: usize,
|
||||
#[case] _tag: &str,
|
||||
) {
|
||||
Playground::setup("exact_vs_bad_glob", |dirs, sandbox| {
|
||||
sandbox.with_files(vec![
|
||||
EmptyFile("yehuda.txt"),
|
||||
EmptyFile("jttxt"),
|
||||
EmptyFile("bad[glob.foo"),
|
||||
]);
|
||||
|
||||
let res = arg_glob(&spanned_string(pat), &dirs.test);
|
||||
assert!(res
|
||||
.expect_err("expected error")
|
||||
.to_string()
|
||||
.contains("Invalid glob pattern"));
|
||||
})
|
||||
}
|
||||
}
|
@ -1,4 +1,7 @@
|
||||
mod arg_glob;
|
||||
pub mod formats;
|
||||
pub mod hook;
|
||||
pub mod input_handler;
|
||||
pub mod util;
|
||||
pub use arg_glob::arg_glob;
|
||||
pub use arg_glob::arg_glob_leading_dot;
|
||||
|
@ -4,6 +4,7 @@ use std::path::PathBuf;
|
||||
use std::sync::atomic::AtomicBool;
|
||||
use std::sync::Arc;
|
||||
|
||||
use nu_cmd_base::arg_glob;
|
||||
use nu_engine::env::current_dir;
|
||||
use nu_engine::CallExt;
|
||||
use nu_path::{canonicalize_with, expand_path_with};
|
||||
@ -19,13 +20,6 @@ use super::util::try_interaction;
|
||||
use crate::filesystem::util::FileStructure;
|
||||
use crate::progress_bar;
|
||||
|
||||
const GLOB_PARAMS: nu_glob::MatchOptions = nu_glob::MatchOptions {
|
||||
case_sensitive: true,
|
||||
require_literal_separator: false,
|
||||
require_literal_leading_dot: false,
|
||||
recursive_match_hidden_dir: true,
|
||||
};
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Cp;
|
||||
|
||||
@ -81,12 +75,6 @@ impl Command for Cp {
|
||||
_input: PipelineData,
|
||||
) -> Result<PipelineData, ShellError> {
|
||||
let src: Spanned<String> = call.req(engine_state, stack, 0)?;
|
||||
let src = {
|
||||
Spanned {
|
||||
item: nu_utils::strip_ansi_string_unlikely(src.item),
|
||||
span: src.span,
|
||||
}
|
||||
};
|
||||
let dst: Spanned<String> = call.req(engine_state, stack, 1)?;
|
||||
let recursive = call.has_flag("recursive");
|
||||
let verbose = call.has_flag("verbose");
|
||||
@ -95,7 +83,6 @@ impl Command for Cp {
|
||||
let update_mode = call.has_flag("update");
|
||||
|
||||
let current_dir_path = current_dir(engine_state, stack)?;
|
||||
let source = current_dir_path.join(src.item.as_str());
|
||||
let destination = current_dir_path.join(dst.item.as_str());
|
||||
|
||||
let path_last_char = destination.as_os_str().to_string_lossy().chars().last();
|
||||
@ -110,7 +97,7 @@ impl Command for Cp {
|
||||
let span = call.head;
|
||||
|
||||
// Get an iterator with all the source files.
|
||||
let sources: Vec<_> = match nu_glob::glob_with(&source.to_string_lossy(), GLOB_PARAMS) {
|
||||
let sources: Vec<_> = match arg_glob(&src, ¤t_dir_path) {
|
||||
Ok(files) => files.collect(),
|
||||
Err(e) => {
|
||||
return Err(ShellError::GenericError(
|
||||
@ -124,13 +111,7 @@ impl Command for Cp {
|
||||
};
|
||||
|
||||
if sources.is_empty() {
|
||||
return Err(ShellError::GenericError(
|
||||
"No matches found".into(),
|
||||
"no matches found".into(),
|
||||
Some(src.span),
|
||||
None,
|
||||
Vec::new(),
|
||||
));
|
||||
return Err(ShellError::FileNotFound(src.span));
|
||||
}
|
||||
|
||||
if sources.len() > 1 && !destination.is_dir() {
|
||||
@ -189,9 +170,7 @@ impl Command for Cp {
|
||||
}
|
||||
|
||||
let res = if src == dst {
|
||||
let message = format!(
|
||||
"src {source:?} and dst {destination:?} are identical(not copied)"
|
||||
);
|
||||
let message = format!("src and dst identical: {:?} (not copied)", src);
|
||||
|
||||
return Err(ShellError::GenericError(
|
||||
"Copy aborted".into(),
|
||||
|
@ -1,6 +1,7 @@
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use super::util::try_interaction;
|
||||
use nu_cmd_base::arg_glob;
|
||||
use nu_engine::env::current_dir;
|
||||
use nu_engine::CallExt;
|
||||
use nu_protocol::ast::Call;
|
||||
@ -10,13 +11,6 @@ use nu_protocol::{
|
||||
Spanned, SyntaxShape, Type, Value,
|
||||
};
|
||||
|
||||
const GLOB_PARAMS: nu_glob::MatchOptions = nu_glob::MatchOptions {
|
||||
case_sensitive: true,
|
||||
require_literal_separator: false,
|
||||
require_literal_leading_dot: false,
|
||||
recursive_match_hidden_dir: true,
|
||||
};
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Mv;
|
||||
|
||||
@ -70,12 +64,6 @@ impl Command for Mv {
|
||||
) -> Result<PipelineData, ShellError> {
|
||||
// TODO: handle invalid directory or insufficient permissions when moving
|
||||
let spanned_source: Spanned<String> = call.req(engine_state, stack, 0)?;
|
||||
let spanned_source = {
|
||||
Spanned {
|
||||
item: nu_utils::strip_ansi_string_unlikely(spanned_source.item),
|
||||
span: spanned_source.span,
|
||||
}
|
||||
};
|
||||
let spanned_destination: Spanned<String> = call.req(engine_state, stack, 1)?;
|
||||
let verbose = call.has_flag("verbose");
|
||||
let interactive = call.has_flag("interactive");
|
||||
@ -88,17 +76,11 @@ impl Command for Mv {
|
||||
let source = path.join(spanned_source.item.as_str());
|
||||
let destination = path.join(spanned_destination.item.as_str());
|
||||
|
||||
let mut sources = nu_glob::glob_with(&source.to_string_lossy(), GLOB_PARAMS)
|
||||
.map_or_else(|_| Vec::new(), Iterator::collect);
|
||||
let mut sources =
|
||||
arg_glob(&spanned_source, &path).map_or_else(|_| Vec::new(), Iterator::collect);
|
||||
|
||||
if sources.is_empty() {
|
||||
return Err(ShellError::GenericError(
|
||||
"File(s) not found".into(),
|
||||
"could not find any files matching this glob pattern".into(),
|
||||
Some(spanned_source.span),
|
||||
None,
|
||||
Vec::new(),
|
||||
));
|
||||
return Err(ShellError::FileNotFound(spanned_source.span));
|
||||
}
|
||||
|
||||
// We have two possibilities.
|
||||
|
@ -7,6 +7,7 @@ use std::path::PathBuf;
|
||||
|
||||
use super::util::try_interaction;
|
||||
|
||||
use nu_cmd_base::arg_glob_leading_dot;
|
||||
use nu_engine::env::current_dir;
|
||||
use nu_engine::CallExt;
|
||||
use nu_protocol::ast::Call;
|
||||
@ -16,13 +17,6 @@ use nu_protocol::{
|
||||
Spanned, SyntaxShape, Type, Value,
|
||||
};
|
||||
|
||||
const GLOB_PARAMS: nu_glob::MatchOptions = nu_glob::MatchOptions {
|
||||
case_sensitive: true,
|
||||
require_literal_separator: false,
|
||||
require_literal_leading_dot: false,
|
||||
recursive_match_hidden_dir: true,
|
||||
};
|
||||
|
||||
const TRASH_SUPPORTED: bool = cfg!(all(
|
||||
feature = "trash-support",
|
||||
not(any(target_os = "android", target_os = "ios"))
|
||||
@ -49,8 +43,8 @@ impl Command for Rm {
|
||||
.input_output_types(vec![(Type::Nothing, Type::Nothing)])
|
||||
.required(
|
||||
"filename",
|
||||
SyntaxShape::Filepath,
|
||||
"the path of the file you want to remove",
|
||||
SyntaxShape::GlobPattern,
|
||||
"the file or files you want to remove",
|
||||
)
|
||||
.switch(
|
||||
"trash",
|
||||
@ -252,13 +246,7 @@ fn rm(
|
||||
}
|
||||
|
||||
let path = currentdir_path.join(&target.item);
|
||||
match nu_glob::glob_with(
|
||||
&path.to_string_lossy(),
|
||||
nu_glob::MatchOptions {
|
||||
require_literal_leading_dot: true,
|
||||
..GLOB_PARAMS
|
||||
},
|
||||
) {
|
||||
match arg_glob_leading_dot(&target, ¤tdir_path) {
|
||||
Ok(files) => {
|
||||
for file in files {
|
||||
match file {
|
||||
|
@ -1,5 +1,6 @@
|
||||
use nu_engine::CallExt;
|
||||
use nu_path::expand_to_real_path;
|
||||
use nu_cmd_base::arg_glob;
|
||||
use nu_engine::{current_dir, CallExt};
|
||||
use nu_glob::GlobResult;
|
||||
use nu_protocol::{
|
||||
ast::Call,
|
||||
engine::{Command, EngineState, Stack},
|
||||
@ -10,12 +11,6 @@ use uu_cp::{BackupMode, UpdateMode};
|
||||
|
||||
// TODO: related to uucore::error::set_exit_code(EXIT_ERR)
|
||||
// const EXIT_ERR: i32 = 1;
|
||||
const GLOB_PARAMS: nu_glob::MatchOptions = nu_glob::MatchOptions {
|
||||
case_sensitive: true,
|
||||
require_literal_separator: false,
|
||||
require_literal_leading_dot: false,
|
||||
recursive_match_hidden_dir: true,
|
||||
};
|
||||
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
const PATH_SEPARATOR: &str = "/";
|
||||
@ -154,20 +149,22 @@ impl Command for UCp {
|
||||
Vec::new(),
|
||||
));
|
||||
};
|
||||
|
||||
// paths now contains the sources
|
||||
let sources: Vec<Vec<PathBuf>> = paths
|
||||
.iter()
|
||||
.map(|p| {
|
||||
// Need to expand too make it work with globbing
|
||||
let expanded_src = expand_to_real_path(&p.item);
|
||||
match nu_glob::glob_with(&expanded_src.to_string_lossy(), GLOB_PARAMS) {
|
||||
Ok(files) => {
|
||||
let f = files.filter_map(Result::ok).collect::<Vec<PathBuf>>();
|
||||
if f.is_empty() {
|
||||
return Err(ShellError::FileNotFound(p.span));
|
||||
}
|
||||
let any_source_is_dir = f.iter().any(|f| matches!(f, f if f.is_dir()));
|
||||
if any_source_is_dir && !recursive {
|
||||
|
||||
let cwd = current_dir(engine_state, stack)?;
|
||||
let mut sources: Vec<PathBuf> = Vec::new();
|
||||
|
||||
for p in paths {
|
||||
let exp_files = arg_glob(&p, &cwd)?.collect::<Vec<GlobResult>>();
|
||||
if exp_files.is_empty() {
|
||||
return Err(ShellError::FileNotFound(p.span));
|
||||
};
|
||||
let mut app_vals: Vec<PathBuf> = Vec::new();
|
||||
for v in exp_files {
|
||||
match v {
|
||||
Ok(path) => {
|
||||
if !recursive && path.is_dir() {
|
||||
return Err(ShellError::GenericError(
|
||||
"could_not_copy_directory".into(),
|
||||
"resolves to a directory (not copied)".into(),
|
||||
@ -175,22 +172,20 @@ impl Command for UCp {
|
||||
Some("Directories must be copied using \"--recursive\"".into()),
|
||||
Vec::new(),
|
||||
));
|
||||
}
|
||||
|
||||
Ok(f)
|
||||
};
|
||||
app_vals.push(path)
|
||||
}
|
||||
Err(e) => {
|
||||
return Err(ShellError::ErrorExpandingGlob(
|
||||
format!("error {} in path {}", e.error(), e.path().display()),
|
||||
p.span,
|
||||
));
|
||||
}
|
||||
Err(e) => Err(ShellError::GenericError(
|
||||
e.to_string(),
|
||||
"invalid pattern".to_string(),
|
||||
Some(p.span),
|
||||
None,
|
||||
Vec::new(),
|
||||
)),
|
||||
}
|
||||
})
|
||||
.collect::<Result<Vec<Vec<PathBuf>>, ShellError>>()?;
|
||||
}
|
||||
sources.append(&mut app_vals);
|
||||
}
|
||||
|
||||
let sources = sources.into_iter().flatten().collect::<Vec<PathBuf>>();
|
||||
let options = uu_cp::Options {
|
||||
overwrite,
|
||||
reflink_mode,
|
||||
|
@ -1,28 +1,21 @@
|
||||
use crate::{DirBuilder, DirInfo, FileInfo};
|
||||
use nu_engine::CallExt;
|
||||
use nu_glob::{GlobError, MatchOptions, Pattern};
|
||||
use nu_cmd_base::arg_glob;
|
||||
use nu_engine::{current_dir, CallExt};
|
||||
use nu_glob::{GlobError, Pattern};
|
||||
use nu_protocol::{
|
||||
ast::Call,
|
||||
engine::{Command, EngineState, Stack},
|
||||
Category, Example, IntoInterruptiblePipelineData, PipelineData, ShellError, Signature, Spanned,
|
||||
SyntaxShape, Type, Value,
|
||||
Category, Example, IntoInterruptiblePipelineData, PipelineData, ShellError, Signature, Span,
|
||||
Spanned, SyntaxShape, Type, Value,
|
||||
};
|
||||
use serde::Deserialize;
|
||||
use std::path::PathBuf;
|
||||
|
||||
const GLOB_PARAMS: MatchOptions = MatchOptions {
|
||||
case_sensitive: true,
|
||||
require_literal_separator: true,
|
||||
require_literal_leading_dot: false,
|
||||
recursive_match_hidden_dir: true,
|
||||
};
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Du;
|
||||
|
||||
#[derive(Deserialize, Clone, Debug)]
|
||||
pub struct DuArgs {
|
||||
path: Option<Spanned<PathBuf>>,
|
||||
path: Option<Spanned<String>>,
|
||||
all: bool,
|
||||
deref: bool,
|
||||
exclude: Option<Spanned<String>>,
|
||||
@ -97,6 +90,8 @@ impl Command for Du {
|
||||
return Err(ShellError::NeedsPositiveValue(min_size.span));
|
||||
}
|
||||
}
|
||||
let current_dir = current_dir(engine_state, stack)?;
|
||||
|
||||
let args = DuArgs {
|
||||
path: call.opt(engine_state, stack, 0)?,
|
||||
all: call.has_flag("all"),
|
||||
@ -107,38 +102,22 @@ impl Command for Du {
|
||||
};
|
||||
|
||||
let exclude = args.exclude.map_or(Ok(None), move |x| {
|
||||
Pattern::new(&x.item).map(Some).map_err(|e| {
|
||||
ShellError::GenericError(
|
||||
"glob error".to_string(),
|
||||
e.msg.to_string(),
|
||||
Some(x.span),
|
||||
None,
|
||||
Vec::new(),
|
||||
)
|
||||
})
|
||||
Pattern::new(&x.item)
|
||||
.map(Some)
|
||||
.map_err(|e| ShellError::InvalidGlobPattern(e.msg.to_string(), x.span))
|
||||
})?;
|
||||
|
||||
let include_files = args.all;
|
||||
let mut paths = match args.path {
|
||||
Some(p) => {
|
||||
let item = p.item.to_str().expect("Why isn't this encoded properly?");
|
||||
match nu_glob::glob_with(item, GLOB_PARAMS) {
|
||||
// Convert the PatternError to a ShellError, preserving the span
|
||||
// of the inputted glob.
|
||||
Err(e) => {
|
||||
return Err(ShellError::GenericError(
|
||||
"glob error".to_string(),
|
||||
e.msg.to_string(),
|
||||
Some(p.span),
|
||||
None,
|
||||
Vec::new(),
|
||||
))
|
||||
}
|
||||
Ok(path) => path,
|
||||
}
|
||||
}
|
||||
Some(p) => arg_glob(&p, ¤t_dir)?,
|
||||
// The * pattern should never fail.
|
||||
None => nu_glob::glob_with("*", GLOB_PARAMS).expect("du: * pattern failed to glob"),
|
||||
None => arg_glob(
|
||||
&Spanned {
|
||||
item: "*".into(),
|
||||
span: Span::unknown(),
|
||||
},
|
||||
¤t_dir,
|
||||
)?,
|
||||
}
|
||||
.filter(move |p| {
|
||||
if include_files {
|
||||
|
@ -203,7 +203,7 @@ fn errors_if_source_doesnt_exist() {
|
||||
cwd: dirs.test(),
|
||||
"mv non-existing-file test_folder/"
|
||||
);
|
||||
assert!(actual.err.contains("File(s) not found"));
|
||||
assert!(actual.err.contains("file not found"));
|
||||
})
|
||||
}
|
||||
|
||||
|
@ -6,6 +6,7 @@ use nu_test_support::fs::{
|
||||
use nu_test_support::nu;
|
||||
use nu_test_support::playground::Playground;
|
||||
|
||||
use rstest::rstest;
|
||||
use std::path::Path;
|
||||
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
@ -968,3 +969,46 @@ fn test_cp_with_vars() {
|
||||
assert!(dirs.test().join("target").exists());
|
||||
});
|
||||
}
|
||||
|
||||
#[rstest]
|
||||
#[case(r#"'a]c'"#)]
|
||||
#[case(r#"'a[c'"#)]
|
||||
#[case(r#"'a[bc]d'"#)]
|
||||
#[case(r#"'a][c'"#)]
|
||||
fn copies_files_with_glob_metachars(#[case] src_name: &str) {
|
||||
Playground::setup("ucp_test_34", |dirs, sandbox| {
|
||||
sandbox.with_files(vec![FileWithContent(
|
||||
src_name,
|
||||
"What is the sound of one hand clapping?",
|
||||
)]);
|
||||
|
||||
let src = dirs.test().join(src_name);
|
||||
|
||||
// -- open command doesn't like file name
|
||||
//// Get the hash of the file content to check integrity after copy.
|
||||
//let src_hash = get_file_hash(src.display());
|
||||
|
||||
let actual = nu!(
|
||||
cwd: dirs.test(),
|
||||
"cp {} {}",
|
||||
src.display(),
|
||||
TEST_HELLO_WORLD_DEST
|
||||
);
|
||||
|
||||
assert!(actual.err.is_empty());
|
||||
assert!(dirs.test().join(TEST_HELLO_WORLD_DEST).exists());
|
||||
|
||||
//// Get the hash of the copied file content to check against first_hash.
|
||||
//let after_cp_hash = get_file_hash(dirs.test().join(TEST_HELLO_WORLD_DEST).display());
|
||||
//assert_eq!(src_hash, after_cp_hash);
|
||||
});
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
#[rstest]
|
||||
#[case(r#"'a]?c'"#)]
|
||||
#[case(r#"'a*.?c'"#)]
|
||||
// windows doesn't allow filename with `*`.
|
||||
fn copies_files_with_glob_metachars_nw(#[case] src_name: &str) {
|
||||
copies_files_with_glob_metachars(src_name);
|
||||
}
|
||||
|
@ -103,6 +103,19 @@ pub struct Paths {
|
||||
scope: Option<PathBuf>,
|
||||
}
|
||||
|
||||
impl Paths {
|
||||
/// An iterator representing a single path.
|
||||
pub fn single(path: &Path, relative_to: &Path) -> Self {
|
||||
Paths {
|
||||
dir_patterns: vec![Pattern::new("*").expect("hard coded pattern")],
|
||||
require_dir: false,
|
||||
options: MatchOptions::default(),
|
||||
todo: vec![Ok((path.to_path_buf(), 0))],
|
||||
scope: Some(relative_to.into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Return an iterator that produces all the `Path`s that match the given
|
||||
/// pattern using default match options, which may be absolute or relative to
|
||||
/// the current working directory.
|
||||
@ -110,7 +123,7 @@ pub struct Paths {
|
||||
/// This may return an error if the pattern is invalid.
|
||||
///
|
||||
/// This method uses the default match options and is equivalent to calling
|
||||
/// `glob_with(pattern, MatchOptions::new())`. Use `glob_with` directly if you
|
||||
/// `glob_with(pattern, MatchOptions::default())`. Use `glob_with` directly if you
|
||||
/// want to use non-default match options.
|
||||
///
|
||||
/// When iterating, each result is a `GlobResult` which expresses the
|
||||
@ -273,6 +286,32 @@ pub fn glob_with(pattern: &str, options: MatchOptions) -> Result<Paths, PatternE
|
||||
})
|
||||
}
|
||||
|
||||
/// Return an iterator that produces all the `Path`s that match the given
|
||||
/// pattern relative to a specified parent directory and using specified match options.
|
||||
/// Paths may be absolute or relative to the current working directory.
|
||||
///
|
||||
/// This is provided primarily for testability, so multithreaded test runners can
|
||||
/// test pattern matches in different test directories at the same time without
|
||||
/// having to append the parent to the pattern under test.
|
||||
|
||||
pub fn glob_with_parent(
|
||||
pattern: &str,
|
||||
options: MatchOptions,
|
||||
parent: &Path,
|
||||
) -> Result<Paths, PatternError> {
|
||||
match glob_with(pattern, options) {
|
||||
Ok(mut p) => {
|
||||
p.scope = match p.scope {
|
||||
None => Some(parent.to_path_buf()),
|
||||
Some(s) if &s.to_string_lossy() == "." => Some(parent.to_path_buf()),
|
||||
Some(s) => Some(s),
|
||||
};
|
||||
Ok(p)
|
||||
}
|
||||
Err(e) => Err(e),
|
||||
}
|
||||
}
|
||||
|
||||
/// A glob iteration error.
|
||||
///
|
||||
/// This is typically returned when a particular path cannot be read
|
||||
@ -347,7 +386,10 @@ impl Iterator for Paths {
|
||||
// Shouldn't happen, but we're using -1 as a special index.
|
||||
assert!(self.dir_patterns.len() < !0);
|
||||
|
||||
fill_todo(&mut self.todo, &self.dir_patterns, 0, &scope, self.options);
|
||||
// if there's one prefilled result, take it, otherwise fill the todo buffer
|
||||
if self.todo.len() != 1 {
|
||||
fill_todo(&mut self.todo, &self.dir_patterns, 0, &scope, self.options);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -704,7 +746,7 @@ impl Pattern {
|
||||
}
|
||||
|
||||
/// Return if the given `str` matches this `Pattern` using the default
|
||||
/// match options (i.e. `MatchOptions::new()`).
|
||||
/// match options (i.e. `MatchOptions::default()`).
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@ -720,7 +762,7 @@ impl Pattern {
|
||||
}
|
||||
|
||||
/// Return if the given `Path`, when converted to a `str`, matches this
|
||||
/// `Pattern` using the default match options (i.e. `MatchOptions::new()`).
|
||||
/// `Pattern` using the default match options (i.e. `MatchOptions::default()`).
|
||||
pub fn matches_path(&self, path: &Path) -> bool {
|
||||
// FIXME (#9639): This needs to handle non-utf8 paths
|
||||
path.to_str().map_or(false, |s| self.matches(s))
|
||||
|
@ -1128,6 +1128,31 @@ This is an internal Nushell error, please file an issue https://github.com/nushe
|
||||
help("Help messages are currently not supported to be constants.")
|
||||
)]
|
||||
NotAConstHelp(#[label = "Cannot get help message at parse time."] Span),
|
||||
|
||||
/// Invalid glob pattern
|
||||
///
|
||||
/// ## Resolution
|
||||
///
|
||||
/// Correct glob pattern
|
||||
#[error("Invalid glob pattern")]
|
||||
#[diagnostic(
|
||||
code(nu::shell::invalid_glob_pattern),
|
||||
help("Refer to xxx for help on nushell glob patterns.")
|
||||
)]
|
||||
InvalidGlobPattern(String, #[label = "{0}"] Span),
|
||||
|
||||
/// Error expanding glob pattern
|
||||
///
|
||||
/// ## Resolution
|
||||
///
|
||||
/// Correct glob pattern or file access issue
|
||||
#[error("Error expanding glob pattern")]
|
||||
#[diagnostic(
|
||||
code(nu::shell::error_expanding_glob),
|
||||
help("Correct glob pattern or file access issue")
|
||||
)]
|
||||
//todo: add error detail
|
||||
ErrorExpandingGlob(String, #[label = "{0}"] Span),
|
||||
}
|
||||
|
||||
// TODO: Implement as From trait
|
||||
|
Loading…
Reference in New Issue
Block a user