exa/src/options.rs

150 lines
4.6 KiB
Rust
Raw Normal View History

2014-05-25 16:14:50 +00:00
extern crate getopts;
use file::File;
2014-11-23 21:29:11 +00:00
use column::Column;
use column::Column::*;
use term::dimensions;
use std::ascii::AsciiExt;
pub enum SortField {
2014-07-22 20:27:36 +00:00
Unsorted, Name, Extension, Size, FileInode
}
impl SortField {
fn from_word(word: String) -> SortField {
match word.as_slice() {
2014-11-23 21:29:11 +00:00
"name" => SortField::Name,
"size" => SortField::Size,
"ext" => SortField::Extension,
"none" => SortField::Unsorted,
"inode" => SortField::FileInode,
_ => panic!("Invalid sorting order"),
}
}
}
pub enum View {
Details(Vec<Column>),
Lines,
Grid(bool, uint),
}
pub struct Options {
pub show_invisibles: bool,
pub sort_field: SortField,
pub reverse: bool,
pub dirs: Vec<String>,
pub view: View,
pub header: bool,
}
impl Options {
2014-05-26 10:08:33 +00:00
pub fn getopts(args: Vec<String>) -> Result<Options, getopts::Fail_> {
2014-11-23 21:29:11 +00:00
let opts = &[
getopts::optflag("1", "oneline", "display one entry per line"),
2014-05-25 16:14:50 +00:00
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-06-23 17:26:35 +00:00
getopts::optflag("h", "header", "show a header row at the top"),
getopts::optflag("H", "links", "show number of hard links"),
getopts::optflag("l", "long", "display extended details and attributes"),
2014-06-22 06:44:00 +00:00
getopts::optflag("i", "inode", "show each file's inode number"),
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"),
2014-06-22 07:09:16 +00:00
getopts::optflag("S", "blocks", "show number of file system blocks"),
2014-07-07 18:18:09 +00:00
getopts::optflag("x", "across", "sort multi-column view entries across"),
2014-05-25 16:14:50 +00:00
];
match getopts::getopts(args.tail(), opts) {
Err(f) => Err(f),
2014-11-23 22:36:03 +00:00
Ok(ref matches) => Ok(Options {
show_invisibles: matches.opt_present("all"),
2014-05-25 16:14:50 +00:00
reverse: matches.opt_present("reverse"),
2014-06-23 17:26:35 +00:00
header: matches.opt_present("header"),
2014-11-23 21:29:11 +00:00
sort_field: matches.opt_str("sort").map(|word| SortField::from_word(word)).unwrap_or(SortField::Name),
dirs: if matches.free.is_empty() { vec![ ".".to_string() ] } else { matches.free.clone() },
view: Options::view(matches),
2014-05-25 16:14:50 +00:00
})
}
}
2014-11-23 22:36:03 +00:00
fn view(matches: &getopts::Matches) -> View {
if matches.opt_present("long") {
2014-11-23 21:29:11 +00:00
View::Details(Options::columns(matches))
}
else if matches.opt_present("oneline") {
2014-11-23 21:29:11 +00:00
View::Lines
}
else {
2014-11-23 21:29:11 +00:00
match dimensions() {
None => View::Lines,
Some((width, _)) => View::Grid(matches.opt_present("across"), width),
}
}
}
2014-11-23 22:36:03 +00:00
fn columns(matches: &getopts::Matches) -> Vec<Column> {
2014-06-22 06:44:00 +00:00
let mut columns = vec![];
if matches.opt_present("inode") {
columns.push(Inode);
}
columns.push(Permissions);
if matches.opt_present("links") {
columns.push(HardLinks);
}
columns.push(FileSize(matches.opt_present("binary")));
2014-06-22 07:09:16 +00:00
if matches.opt_present("blocks") {
columns.push(Blocks);
}
columns.push(User);
2014-05-26 17:08:58 +00:00
if matches.opt_present("group") {
columns.push(Group);
}
columns.push(FileName);
return columns;
}
2014-05-26 19:24:51 +00:00
fn should_display(&self, f: &File) -> bool {
if self.show_invisibles {
true
} else {
!f.name.as_slice().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()
2014-05-26 19:24:51 +00:00
.filter(|&f| self.should_display(f))
.collect();
match self.sort_field {
2014-11-23 21:29:11 +00:00
SortField::Unsorted => {},
SortField::Name => files.sort_by(|a, b| a.parts.cmp(&b.parts)),
SortField::Size => files.sort_by(|a, b| a.stat.size.cmp(&b.stat.size)),
SortField::FileInode => files.sort_by(|a, b| a.stat.unstable.inode.cmp(&b.stat.unstable.inode)),
SortField::Extension => files.sort_by(|a, b| {
let exts = a.ext.clone().map(|e| e.to_ascii_lower()).cmp(&b.ext.clone().map(|e| e.to_ascii_lower()));
let names = a.name.to_ascii_lower().cmp(&b.name.to_ascii_lower());
exts.cmp(&names)
}),
}
if self.reverse {
files.reverse();
}
return files;
}
}