nushell/src/commands/cp.rs

285 lines
10 KiB
Rust
Raw Normal View History

2019-07-22 04:23:02 +02:00
use crate::errors::ShellError;
use crate::parser::hir::SyntaxType;
2019-08-09 06:51:21 +02:00
use crate::parser::registry::{CommandRegistry, Signature};
2019-07-22 04:23:02 +02:00
use crate::prelude::*;
2019-08-14 22:04:44 +02:00
use crate::utils::FileStructure;
use std::path::PathBuf;
2019-07-22 04:23:02 +02:00
2019-08-14 22:04:44 +02:00
pub struct Cpy;
2019-07-22 04:23:02 +02:00
2019-08-14 22:04:44 +02:00
impl StaticCommand for Cpy {
2019-08-09 06:51:21 +02:00
fn run(
&self,
args: CommandArgs,
registry: &CommandRegistry,
) -> Result<OutputStream, ShellError> {
cp(args, registry)
2019-07-22 04:23:02 +02:00
}
fn name(&self) -> &str {
"cp"
}
2019-08-09 06:51:21 +02:00
fn signature(&self) -> Signature {
Signature::build("cp")
.named("file", SyntaxType::Any)
.switch("recursive")
2019-07-22 04:23:02 +02:00
}
}
2019-08-09 06:51:21 +02:00
pub fn cp(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
2019-08-07 19:49:11 +02:00
let mut source = PathBuf::from(args.shell_manager.path());
let mut destination = PathBuf::from(args.shell_manager.path());
let name_span = args.call_info.name_span;
2019-08-09 06:51:21 +02:00
let args = args.evaluate_once(registry)?;
2019-07-22 04:23:02 +02:00
match args
.nth(0)
.ok_or_else(|| ShellError::string(&format!("No file or directory specified")))?
.as_string()?
.as_str()
{
file => {
2019-07-22 04:23:02 +02:00
source.push(file);
}
}
match args
.nth(1)
.ok_or_else(|| ShellError::string(&format!("No file or directory specified")))?
.as_string()?
.as_str()
{
file => {
2019-07-22 04:23:02 +02:00
destination.push(file);
}
2019-07-22 04:23:02 +02:00
}
let sources = glob::glob(&source.to_string_lossy());
2019-08-06 09:05:47 +02:00
if sources.is_err() {
return Err(ShellError::labeled_error(
"Invalid pattern.",
"Invalid pattern.",
args.nth(0).unwrap().span(),
));
2019-08-06 09:05:47 +02:00
}
let sources: Vec<_> = sources.unwrap().collect();
2019-08-06 09:05:47 +02:00
if sources.len() == 1 {
if let Ok(entry) = &sources[0] {
if entry.is_dir() && !args.has("recursive") {
return Err(ShellError::labeled_error(
"is a directory (not copied). Try using \"--recursive\".",
"is a directory (not copied). Try using \"--recursive\".",
args.nth(0).unwrap().span(),
));
}
2019-08-06 09:05:47 +02:00
let mut sources: FileStructure = FileStructure::new();
sources.walk_decorate(&entry);
if entry.is_file() {
let strategy = |(source_file, _depth_level)| {
if destination.exists() {
let mut new_dst = dunce::canonicalize(destination.clone()).unwrap();
new_dst.push(entry.file_name().unwrap());
(source_file, new_dst)
2019-08-06 09:05:47 +02:00
} else {
(source_file, destination.clone())
}
};
for (ref src, ref dst) in sources.paths_applying_with(strategy) {
if src.is_file() {
match std::fs::copy(src, dst) {
Err(e) => {
return Err(ShellError::labeled_error(
e.to_string(),
e.to_string(),
name_span,
));
}
Ok(o) => o,
};
2019-08-06 09:05:47 +02:00
}
}
}
if entry.is_dir() {
if !destination.exists() {
match std::fs::create_dir_all(&destination) {
Err(e) => {
return Err(ShellError::labeled_error(
e.to_string(),
e.to_string(),
name_span,
));
2019-08-06 09:05:47 +02:00
}
Ok(o) => o,
};
2019-08-06 09:05:47 +02:00
let strategy = |(source_file, depth_level)| {
let mut new_dst = destination.clone();
let path = dunce::canonicalize(&source_file).unwrap();
2019-08-06 09:05:47 +02:00
let mut comps: Vec<_> = path
.components()
.map(|fragment| fragment.as_os_str())
.rev()
.take(1 + depth_level)
.collect();
2019-08-06 09:05:47 +02:00
comps.reverse();
for fragment in comps.iter() {
new_dst.push(fragment);
}
(PathBuf::from(&source_file), PathBuf::from(new_dst))
};
for (ref src, ref dst) in sources.paths_applying_with(strategy) {
if src.is_dir() {
if !dst.exists() {
match std::fs::create_dir_all(dst) {
Err(e) => {
2019-08-06 09:05:47 +02:00
return Err(ShellError::labeled_error(
e.to_string(),
e.to_string(),
name_span,
2019-08-06 09:05:47 +02:00
));
}
Ok(o) => o,
};
}
}
if src.is_file() {
match std::fs::copy(src, dst) {
Err(e) => {
return Err(ShellError::labeled_error(
e.to_string(),
e.to_string(),
name_span,
));
2019-08-06 09:05:47 +02:00
}
Ok(o) => o,
};
}
}
} else {
destination.push(entry.file_name().unwrap());
2019-08-06 09:05:47 +02:00
match std::fs::create_dir_all(&destination) {
Err(e) => {
return Err(ShellError::labeled_error(
e.to_string(),
e.to_string(),
name_span,
));
}
Ok(o) => o,
};
2019-08-06 09:05:47 +02:00
let strategy = |(source_file, depth_level)| {
let mut new_dst = dunce::canonicalize(&destination).unwrap();
let path = dunce::canonicalize(&source_file).unwrap();
2019-08-06 09:05:47 +02:00
let mut comps: Vec<_> = path
.components()
.map(|fragment| fragment.as_os_str())
.rev()
.take(1 + depth_level)
.collect();
2019-08-06 09:05:47 +02:00
comps.reverse();
2019-08-06 09:05:47 +02:00
for fragment in comps.iter() {
new_dst.push(fragment);
}
2019-08-06 09:05:47 +02:00
(PathBuf::from(&source_file), PathBuf::from(new_dst))
};
for (ref src, ref dst) in sources.paths_applying_with(strategy) {
if src.is_dir() {
if !dst.exists() {
match std::fs::create_dir_all(dst) {
Err(e) => {
return Err(ShellError::labeled_error(
e.to_string(),
e.to_string(),
name_span,
));
}
Ok(o) => o,
};
2019-08-06 09:05:47 +02:00
}
}
if src.is_file() {
match std::fs::copy(src, dst) {
Err(e) => {
return Err(ShellError::labeled_error(
e.to_string(),
e.to_string(),
name_span,
));
}
Ok(o) => o,
};
}
2019-08-06 09:05:47 +02:00
}
}
}
}
} else {
if destination.exists() {
2019-08-14 22:04:44 +02:00
if !sources.iter().all(|x| (x.as_ref().unwrap()).is_file()) {
return Err(ShellError::labeled_error(
"Copy aborted (directories found). Recursive copying in patterns not supported yet (try copying the directory directly)",
"Copy aborted (directories found). Recursive copying in patterns not supported yet (try copying the directory directly)",
args.nth(0).unwrap().span(),
));
2019-08-06 09:05:47 +02:00
}
for entry in sources {
if let Ok(entry) = entry {
let mut to = PathBuf::from(&destination);
to.push(&entry.file_name().unwrap());
2019-08-06 09:05:47 +02:00
2019-08-14 22:04:44 +02:00
if entry.is_file() {
match std::fs::copy(&entry, &to) {
Err(e) => {
return Err(ShellError::labeled_error(
e.to_string(),
e.to_string(),
args.nth(0).unwrap().span(),
));
}
Ok(o) => o,
};
}
}
}
} else {
return Err(ShellError::labeled_error(
format!(
"Copy aborted. (Does {:?} exist?)",
&destination.file_name().unwrap()
),
format!(
"Copy aborted. (Does {:?} exist?)",
&destination.file_name().unwrap()
),
args.nth(1).unwrap().span(),
));
2019-07-22 04:23:02 +02:00
}
}
2019-08-06 09:05:47 +02:00
Ok(OutputStream::empty())
}