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(
2019-08-14 22:04:44 +02:00
"Copy aborted (directories found).",
"Copy aborted (directories found).",
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())
}