exa/options.rs

98 lines
2.7 KiB
Rust
Raw Normal View History

2014-05-25 16:14:50 +00:00
extern crate getopts;
use file::File;
2014-05-24 01:32:57 +00:00
use std::cmp::lexical_ordering;
2014-05-25 18:42:31 +00:00
use column::{Column, Permissions, FileName, FileSize, User, Group};
pub enum SortField {
2014-05-24 01:32:57 +00:00
Name, Extension, Size
}
pub struct Options {
pub showInvisibles: bool,
pub sortField: SortField,
2014-05-24 20:45:24 +00:00
pub reverse: bool,
2014-05-26 10:08:33 +00:00
pub dirs: Vec<String>,
2014-05-26 17:08:58 +00:00
pub columns: Vec<Column>,
}
impl SortField {
fn from_word(word: String) -> SortField {
match word.as_slice() {
"name" => Name,
"size" => Size,
2014-05-24 01:32:57 +00:00
"ext" => Extension,
_ => fail!("Invalid sorting order"),
}
}
}
impl Options {
2014-05-26 10:08:33 +00:00
pub fn getopts(args: Vec<String>) -> Result<Options, getopts::Fail_> {
2014-05-25 16:14:50 +00:00
let opts = ~[
getopts::optflag("a", "all", "show dot-files"),
getopts::optflag("b", "binary", "use binary prefixes in file sizes"),
2014-05-26 17:08:58 +00:00
getopts::optflag("g", "group", "show group as well as user"),
2014-05-25 16:14:50 +00:00
getopts::optflag("r", "reverse", "reverse order of files"),
getopts::optopt("s", "sort", "field to sort by", "WORD"),
];
match getopts::getopts(args.tail(), opts) {
Err(f) => Err(f),
Ok(matches) => Ok(Options {
showInvisibles: matches.opt_present("all"),
reverse: matches.opt_present("reverse"),
sortField: matches.opt_str("sort").map(|word| SortField::from_word(word)).unwrap_or(Name),
dirs: matches.free.clone(),
columns: Options::columns(matches),
2014-05-25 16:14:50 +00:00
})
}
}
2014-05-26 17:08:58 +00:00
fn columns(matches: getopts::Matches) -> Vec<Column> {
let mut columns = vec![
Permissions,
FileSize(matches.opt_present("binary")),
User,
];
2014-05-26 17:08:58 +00:00
if matches.opt_present("group") {
columns.push(Group);
}
columns.push(FileName);
return columns;
}
fn show(&self, f: &File) -> bool {
if self.showInvisibles {
true
} else {
!f.name.starts_with(".")
}
}
2014-05-25 18:42:31 +00:00
pub fn transform_files<'a>(&self, unordered_files: &'a Vec<File<'a>>) -> Vec<&'a File<'a>> {
let mut files: Vec<&'a File<'a>> = unordered_files.iter()
.filter(|&f| self.show(f))
.collect();
match self.sortField {
Name => files.sort_by(|a, b| a.name.cmp(&b.name)),
Size => files.sort_by(|a, b| a.stat.size.cmp(&b.stat.size)),
Extension => files.sort_by(|a, b| {
let exts = a.ext.cmp(&b.ext);
let names = a.name.cmp(&b.name);
lexical_ordering(exts, names)
}),
}
if self.reverse {
files.reverse();
}
return files;
}
}