From d08d8c802966a1856d29398ead84882f7349cf24 Mon Sep 17 00:00:00 2001 From: Arcterus Date: Tue, 17 Dec 2013 22:09:32 -0800 Subject: [PATCH 1/6] Add simple rm implementation --- Makefile | 1 + rm/rm.rs | 147 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 148 insertions(+) create mode 100644 rm/rm.rs diff --git a/Makefile b/Makefile index dd8a2e248..744aac842 100644 --- a/Makefile +++ b/Makefile @@ -15,6 +15,7 @@ EXES := \ false \ printenv \ pwd \ + rm \ true \ wc \ whoami \ diff --git a/rm/rm.rs b/rm/rm.rs new file mode 100644 index 000000000..45815602b --- /dev/null +++ b/rm/rm.rs @@ -0,0 +1,147 @@ +#[link(name="rm", vers="1.0.0", author="Arcterus")]; + +/* + * This file is part of the uutils coreutils package. + * + * (c) Arcterus + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +extern mod extra; + +use std::os; +use std::io::{stderr,fs,io_error}; +use extra::getopts::groups; + +enum InteractiveMode { + InteractiveNone, + InteractiveOnce, + InteractiveAlways +} + +fn main() { + let args = os::args(); + let program = args[0].clone(); + + // TODO: make getopts support -R in addition to -r + let opts = ~[ + groups::optflag("f", "force", "ignore nonexistent files and arguments, never prompt"), + groups::optflag("i", "", "prompt before every removal"), + groups::optflag("I", "", "prompt once before removing more than three files, or when removing recursively. Less intrusive than -i, while still giving some protection against most mistakes"), + groups::optflagopt("", "interactive", "prompt according to WHEN: never, once (-I), or always (-i). Without WHEN, prompts always", "WHEN"), + groups::optflag("", "one-file-system", "when removing a hierarchy recursively, skip any directory that is on a file system different from that of the corresponding command line argument"), + groups::optflag("", "no-preserve-root", "do not treat '/' specially"), + groups::optflag("", "preserve-root", "do not remove '/' (default)"), + groups::optflag("r", "recursive", "remove directories and their contents recursively"), + groups::optflag("d", "dir", "remove empty directories"), + groups::optflag("v", "verbose", "explain what is being done"), + groups::optflag("", "help", "display this help and exit"), + groups::optflag("", "version", "output version information and exit") + ]; + let matches = match groups::getopts(args.tail(), opts) { + Ok(m) => m, + Err(f) => { + writeln!(&mut stderr() as &mut Writer, + "{}", f.to_err_msg()); + os::set_exit_status(1); + return + } + }; + if matches.opt_present("help") { + println("rm 1.0.0"); + println(""); + println("Usage:"); + println!(" {0:s} [OPTION]... [FILE]...", program); + println(""); + print(groups::usage("Remove (unlink) the FILE(s).", opts)); + println(""); + println("By default, rm does not remove directories. Use the --recursive (-r)"); + println("option to remove each listed directory, too, along with all of its contents"); + println(""); + println("To remove a file whose name starts with a '-', for example '-foo',"); + println("use one of these commands:"); + println("rm -- -foo"); + println(""); + println("rm ./-foo"); + println(""); + println("Note that if you use rm to remove a file, it might be possible to recover"); + println("some of its contents, given sufficient expertise and/or time. For greater"); + println("assurance that the contents are truly unrecoverable, consider using shred."); + } else if matches.opt_present("version") { + println("rm 1.0.0"); + } else { + let force = matches.opt_present("force"); + let interactive = + if matches.opt_present("i") { + InteractiveAlways + } else if matches.opt_present("I") { + InteractiveOnce + } else if matches.opt_present("interactive") { + match matches.opt_str("interactive").unwrap() { + ~"none" => InteractiveNone, + ~"once" => InteractiveOnce, + ~"always" => InteractiveAlways, + val => { + writeln!(&mut stderr() as &mut Writer, + "Invalid argument to interactive ({})", val); + os::set_exit_status(1); + return + } + } + } else { + InteractiveNone + }; + let one_fs = matches.opt_present("one-file-system"); + let preserve_root = !matches.opt_present("no-preserve-root"); + let recursive = matches.opt_present("recursive"); + let dir = matches.opt_present("dir"); + let verbose = matches.opt_present("verbose"); + remove_files(matches.free, force, interactive, one_fs, preserve_root, + recursive, dir, verbose); + } +} + +fn remove_files(files: &[~str], force: bool, interactive: InteractiveMode, one_fs: bool, preserve_root: bool, recursive: bool, dir: bool, verbose: bool) { + for filename in files.iter() { + let file = Path::new(filename.to_owned()); + if file.exists() { + if file.is_dir() { + if recursive && (*filename != ~"/" || !preserve_root) { + remove_files(fs::walk_dir(&file).map(|x| x.as_str().unwrap().to_owned()).to_owned_vec(), force, interactive, one_fs, preserve_root, recursive, dir, verbose); + io_error::cond.trap(|_| { + writeln!(&mut stderr() as &mut Writer, + "Could not remove directory: '{}'", *filename); + }).inside(|| { + fs::rmdir(&file); + }); + } else if dir { + io_error::cond.trap(|_| { + writeln!(&mut stderr() as &mut Writer, + "Could not remove directory '{}'", *filename); + }).inside(|| { + fs::rmdir(&file); + }); + } else { + writeln!(&mut stderr() as &mut Writer, + "Could not remove directory '{}' (did you mean to pass '-r'?)", + *filename); + } + } else { + io_error::cond.trap(|_| { + writeln!(&mut stderr() as &mut Writer, + "Could not remove file: '{}'", *filename); + os::set_exit_status(1); + }).inside(|| { + fs::unlink(&file); + }); + } + } else if !force { + writeln!(&mut stderr() as &mut Writer, + "Invalid file: '{}'", *filename); + os::set_exit_status(1); + } + } +} + From 2021a557756d63165e218d56cd9b599eb31c7ef5 Mon Sep 17 00:00:00 2001 From: Arcterus Date: Tue, 17 Dec 2013 22:17:05 -0800 Subject: [PATCH 2/6] Add more '/' checks to rm --- rm/rm.rs | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/rm/rm.rs b/rm/rm.rs index 45815602b..01f4969ac 100644 --- a/rm/rm.rs +++ b/rm/rm.rs @@ -116,7 +116,7 @@ fn remove_files(files: &[~str], force: bool, interactive: InteractiveMode, one_f }).inside(|| { fs::rmdir(&file); }); - } else if dir { + } else if dir && (*filename != ~"/" || !preserve_root) { io_error::cond.trap(|_| { writeln!(&mut stderr() as &mut Writer, "Could not remove directory '{}'", *filename); @@ -124,9 +124,15 @@ fn remove_files(files: &[~str], force: bool, interactive: InteractiveMode, one_f fs::rmdir(&file); }); } else { - writeln!(&mut stderr() as &mut Writer, - "Could not remove directory '{}' (did you mean to pass '-r'?)", - *filename); + if recursive { + writeln!(&mut stderr() as &mut Writer, + "Could not remove directory '{}'", + *filename); + } else { + writeln!(&mut stderr() as &mut Writer, + "Could not remove directory '{}' (did you mean to pass '-r'?)", + *filename); + } } } else { io_error::cond.trap(|_| { From 216162593480b919f42a5163dec228427c066bd4 Mon Sep 17 00:00:00 2001 From: Arcterus Date: Tue, 17 Dec 2013 22:37:50 -0800 Subject: [PATCH 3/6] Add --verbose support to rm --- rm/rm.rs | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/rm/rm.rs b/rm/rm.rs index 01f4969ac..9fdb717df 100644 --- a/rm/rm.rs +++ b/rm/rm.rs @@ -103,6 +103,7 @@ fn main() { } } +// TODO: implement one-file-system and interactive fn remove_files(files: &[~str], force: bool, interactive: InteractiveMode, one_fs: bool, preserve_root: bool, recursive: bool, dir: bool, verbose: bool) { for filename in files.iter() { let file = Path::new(filename.to_owned()); @@ -113,15 +114,19 @@ fn remove_files(files: &[~str], force: bool, interactive: InteractiveMode, one_f io_error::cond.trap(|_| { writeln!(&mut stderr() as &mut Writer, "Could not remove directory: '{}'", *filename); + os::set_exit_status(1); }).inside(|| { fs::rmdir(&file); + println!("Removed '{}'", *filename); }); } else if dir && (*filename != ~"/" || !preserve_root) { io_error::cond.trap(|_| { writeln!(&mut stderr() as &mut Writer, "Could not remove directory '{}'", *filename); + os::set_exit_status(1); }).inside(|| { fs::rmdir(&file); + println!("Removed '{}'", *filename); }); } else { if recursive { @@ -132,6 +137,7 @@ fn remove_files(files: &[~str], force: bool, interactive: InteractiveMode, one_f writeln!(&mut stderr() as &mut Writer, "Could not remove directory '{}' (did you mean to pass '-r'?)", *filename); + os::set_exit_status(1); } } } else { @@ -141,11 +147,12 @@ fn remove_files(files: &[~str], force: bool, interactive: InteractiveMode, one_f os::set_exit_status(1); }).inside(|| { fs::unlink(&file); + println!("Removed '{}'", *filename); }); } } else if !force { writeln!(&mut stderr() as &mut Writer, - "Invalid file: '{}'", *filename); + "No such file or directory '{}'", *filename); os::set_exit_status(1); } } From af2437b725e7953f904dea51cb7ede87347e2e0d Mon Sep 17 00:00:00 2001 From: Arcterus Date: Wed, 18 Dec 2013 16:11:48 -0800 Subject: [PATCH 4/6] Implemented --interactive for rm --- rm/rm.rs | 144 +++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 113 insertions(+), 31 deletions(-) diff --git a/rm/rm.rs b/rm/rm.rs index 9fdb717df..72f9e36c0 100644 --- a/rm/rm.rs +++ b/rm/rm.rs @@ -12,7 +12,7 @@ extern mod extra; use std::os; -use std::io::{stderr,fs,io_error}; +use std::io::{stdin,stderr,stdio,fs,buffered,io_error}; use extra::getopts::groups; enum InteractiveMode { @@ -21,6 +21,21 @@ enum InteractiveMode { InteractiveAlways } +impl Eq for InteractiveMode { + fn eq(&self, other: &InteractiveMode) -> bool { + match (*self, *other) { + (InteractiveNone, InteractiveNone) | + (InteractiveOnce, InteractiveOnce) | + (InteractiveAlways, InteractiveAlways) => true, + _ => false + } + } + + fn ne(&self, other: &InteractiveMode) -> bool { + !self.eq(other) + } +} + fn main() { let args = os::args(); let program = args[0].clone(); @@ -71,6 +86,11 @@ fn main() { println("assurance that the contents are truly unrecoverable, consider using shred."); } else if matches.opt_present("version") { println("rm 1.0.0"); + } else if matches.free.is_empty() { + writeln!(&mut stderr() as &mut Writer, "Missing an argument"); + writeln!(&mut stderr() as &mut Writer, + "For help, try '{0:s} --help'", program); + os::set_exit_status(1); } else { let force = matches.opt_present("force"); let interactive = @@ -98,36 +118,33 @@ fn main() { let recursive = matches.opt_present("recursive"); let dir = matches.opt_present("dir"); let verbose = matches.opt_present("verbose"); - remove_files(matches.free, force, interactive, one_fs, preserve_root, - recursive, dir, verbose); + if interactive == InteractiveOnce && (recursive || matches.free.len() > 3) { + let msg = + if recursive { + "Remove all arguments recursively? " + } else { + "Remove all arguments? " + }; + if !prompt(msg) { + return; + } + } + remove(matches.free, force, interactive, one_fs, preserve_root, + recursive, dir, verbose); } } -// TODO: implement one-file-system and interactive -fn remove_files(files: &[~str], force: bool, interactive: InteractiveMode, one_fs: bool, preserve_root: bool, recursive: bool, dir: bool, verbose: bool) { +// TODO: implement one-file-system +fn remove(files: &[~str], force: bool, interactive: InteractiveMode, one_fs: bool, preserve_root: bool, recursive: bool, dir: bool, verbose: bool) { for filename in files.iter() { let file = Path::new(filename.to_owned()); if file.exists() { if file.is_dir() { if recursive && (*filename != ~"/" || !preserve_root) { - remove_files(fs::walk_dir(&file).map(|x| x.as_str().unwrap().to_owned()).to_owned_vec(), force, interactive, one_fs, preserve_root, recursive, dir, verbose); - io_error::cond.trap(|_| { - writeln!(&mut stderr() as &mut Writer, - "Could not remove directory: '{}'", *filename); - os::set_exit_status(1); - }).inside(|| { - fs::rmdir(&file); - println!("Removed '{}'", *filename); - }); + remove(fs::walk_dir(&file).map(|x| x.as_str().unwrap().to_owned()).to_owned_vec(), force, interactive, one_fs, preserve_root, recursive, dir, verbose); + remove_dir(&file, *filename, interactive, verbose); } else if dir && (*filename != ~"/" || !preserve_root) { - io_error::cond.trap(|_| { - writeln!(&mut stderr() as &mut Writer, - "Could not remove directory '{}'", *filename); - os::set_exit_status(1); - }).inside(|| { - fs::rmdir(&file); - println!("Removed '{}'", *filename); - }); + remove_dir(&file, *filename, interactive, verbose); } else { if recursive { writeln!(&mut stderr() as &mut Writer, @@ -137,18 +154,11 @@ fn remove_files(files: &[~str], force: bool, interactive: InteractiveMode, one_f writeln!(&mut stderr() as &mut Writer, "Could not remove directory '{}' (did you mean to pass '-r'?)", *filename); - os::set_exit_status(1); } + os::set_exit_status(1); } } else { - io_error::cond.trap(|_| { - writeln!(&mut stderr() as &mut Writer, - "Could not remove file: '{}'", *filename); - os::set_exit_status(1); - }).inside(|| { - fs::unlink(&file); - println!("Removed '{}'", *filename); - }); + remove_file(&file, *filename, interactive, verbose); } } else if !force { writeln!(&mut stderr() as &mut Writer, @@ -158,3 +168,75 @@ fn remove_files(files: &[~str], force: bool, interactive: InteractiveMode, one_f } } +fn remove_dir(path: &Path, name: &str, interactive: InteractiveMode, verbose: bool) { + let response = + if interactive == InteractiveAlways { + prompt_file(path, name) + } else { + true + }; + if response { + io_error::cond.trap(|_| { + writeln!(&mut stderr() as &mut Writer, + "Could not remove directory '{}'", name); + os::set_exit_status(1); + }).inside(|| { + fs::rmdir(path); + if verbose { + println!("Removed '{}'", name); + } + }); + } +} + +fn remove_file(path: &Path, name: &str, interactive: InteractiveMode, verbose: bool) { + let response = + if interactive == InteractiveAlways { + prompt_file(path, name) + } else { + true + }; + if response { + io_error::cond.trap(|_| { + writeln!(&mut stderr() as &mut Writer, + "Could not remove file '{}'", name); + os::set_exit_status(1); + }).inside(|| { + fs::unlink(path); + if verbose { + println!("Removed '{}'", name); + } + }); + } +} + +fn prompt_file(path: &Path, name: &str) -> bool { + if path.is_dir() { + prompt(format!("Remove directory '{}'? ", name)) + } else { + prompt(format!("Remove file '{}'? ", name)) + } +} + +fn prompt(msg: &str) -> bool { + print(msg); + read_prompt() +} + +fn read_prompt() -> bool { + stdio::flush(); + match buffered::BufferedReader::new(stdin()).read_line() { + Some(line) => { + match line.char_at(0) { + 'y' | 'Y' => true, + 'n' | 'N' => false, + _ => { + print("Please enter either Y or N: "); + read_prompt() + } + } + } + None => true + } +} + From 204260b739fbc7c12283c04a54518263b202cb23 Mon Sep 17 00:00:00 2001 From: Arcterus Date: Wed, 18 Dec 2013 16:31:25 -0800 Subject: [PATCH 5/6] Documentation changes for rm, resolves #36 --- README.md | 1 - rm/rm.rs | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/README.md b/README.md index b0acd8962..dc1532da5 100644 --- a/README.md +++ b/README.md @@ -104,7 +104,6 @@ To do - realpath - relpath - remove -- rm - rmdir - runcon - seq diff --git a/rm/rm.rs b/rm/rm.rs index 72f9e36c0..8c6652a03 100644 --- a/rm/rm.rs +++ b/rm/rm.rs @@ -46,7 +46,7 @@ fn main() { groups::optflag("i", "", "prompt before every removal"), groups::optflag("I", "", "prompt once before removing more than three files, or when removing recursively. Less intrusive than -i, while still giving some protection against most mistakes"), groups::optflagopt("", "interactive", "prompt according to WHEN: never, once (-I), or always (-i). Without WHEN, prompts always", "WHEN"), - groups::optflag("", "one-file-system", "when removing a hierarchy recursively, skip any directory that is on a file system different from that of the corresponding command line argument"), + groups::optflag("", "one-file-system", "when removing a hierarchy recursively, skip any directory that is on a file system different from that of the corresponding command line argument (NOT IMPLEMENTED)"), groups::optflag("", "no-preserve-root", "do not treat '/' specially"), groups::optflag("", "preserve-root", "do not remove '/' (default)"), groups::optflag("r", "recursive", "remove directories and their contents recursively"), From fe1edd9f67e71a3fb64edb7d11cf0eeb0db11f2e Mon Sep 17 00:00:00 2001 From: Arcterus Date: Wed, 18 Dec 2013 17:14:04 -0800 Subject: [PATCH 6/6] Added the aliases -h and -V for --help and --version to rm --- rm/rm.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rm/rm.rs b/rm/rm.rs index 8c6652a03..13d0c6333 100644 --- a/rm/rm.rs +++ b/rm/rm.rs @@ -52,8 +52,8 @@ fn main() { groups::optflag("r", "recursive", "remove directories and their contents recursively"), groups::optflag("d", "dir", "remove empty directories"), groups::optflag("v", "verbose", "explain what is being done"), - groups::optflag("", "help", "display this help and exit"), - groups::optflag("", "version", "output version information and exit") + groups::optflag("h", "help", "display this help and exit"), + groups::optflag("V", "version", "output version information and exit") ]; let matches = match groups::getopts(args.tail(), opts) { Ok(m) => m,