exa/src/exa.rs

182 lines
5.1 KiB
Rust
Raw Normal View History

2014-11-23 21:29:11 +00:00
#![feature(phase, globs)]
extern crate regex;
#[phase(plugin)] extern crate regex_macros;
extern crate ansi_term;
extern crate unicode;
2014-05-03 10:30:37 +00:00
use std::os;
use std::io::fs;
use std::io::FileType::TypeDirectory;
use file::File;
use dir::Dir;
2014-11-23 21:29:11 +00:00
use column::Column;
use column::Alignment::Left;
use options::{Options, View};
use unix::Unix;
2014-05-03 10:30:37 +00:00
2014-07-04 08:54:14 +00:00
use ansi_term::{Paint, Plain, strip_formatting};
pub mod column;
pub mod dir;
pub mod format;
pub mod file;
pub mod filetype;
pub mod unix;
pub mod options;
2014-06-01 10:54:31 +00:00
pub mod sort;
pub mod term;
2014-05-03 10:30:37 +00:00
fn main() {
2014-11-23 21:29:11 +00:00
let args: Vec<String> = os::args();
2014-05-25 16:14:50 +00:00
match Options::getopts(args) {
Err(err) => println!("Invalid options:\n{}", err),
Ok(opts) => exa(&opts),
};
2014-05-03 10:30:37 +00:00
}
fn exa(opts: &Options) {
// It's only worth printing out directory names if the user supplied
// more than one of them.
let print_dir_names = opts.path_strs.len() > 1;
let (dir_strs, file_strs) = opts.path_strs.clone().partition(|n| fs::stat(&Path::new(n)).unwrap().kind == TypeDirectory);
let mut first = file_strs.is_empty();
let mut files = vec![];
for f in file_strs.iter() {
match File::from_path(Path::new(f), None) {
Ok(file) => files.push(file),
Err(e) => println!("{}: {}", f, e),
}
}
view(opts, files);
for dir_name in dir_strs.into_iter() {
if first {
first = false;
}
else {
print!("\n");
}
match Dir::readdir(Path::new(dir_name.clone())) {
Ok(dir) => {
let unsorted_files = dir.files();
let files: Vec<File> = opts.transform_files(unsorted_files);
if print_dir_names {
println!("{}:", dir_name);
}
view(opts, files);
}
Err(e) => {
println!("{}: {}", dir_name, e);
return;
}
};
}
}
fn view(options: &Options, files: Vec<File>) {
match options.view {
View::Details(ref cols) => details_view(options, cols, files),
View::Lines => lines_view(files),
View::Grid(across, width) => grid_view(across, width, files),
}
}
fn lines_view(files: Vec<File>) {
for file in files.iter() {
println!("{}", file.file_name());
}
}
fn grid_view(across: bool, console_width: uint, files: Vec<File>) {
2014-11-24 01:24:45 +00:00
let max_column_length = files.iter().map(|f| f.file_name_width()).max().unwrap_or(0);
2014-07-07 17:42:09 +00:00
let num_columns = (console_width + 1) / (max_column_length + 1);
2014-07-07 18:18:09 +00:00
let count = files.len();
2014-07-07 17:42:09 +00:00
2014-07-07 18:18:09 +00:00
let mut num_rows = count / num_columns;
if count % num_columns != 0 {
2014-07-07 17:42:09 +00:00
num_rows += 1;
}
2014-07-07 17:42:09 +00:00
for y in range(0, num_rows) {
for x in range(0, num_columns) {
2014-07-07 18:18:09 +00:00
let num = if across {
y * num_columns + x
}
else {
y + num_rows * x
};
if num >= count {
2014-07-07 17:42:09 +00:00
continue;
}
let ref file = files[num];
2014-07-06 17:00:27 +00:00
let file_name = file.name.clone();
let styled_name = file.file_colour().paint(file_name.as_slice());
2014-07-07 19:11:30 +00:00
if x == num_columns - 1 {
print!("{}", styled_name);
}
else {
print!("{}", Left.pad_string(&styled_name, max_column_length - file_name.len() + 1));
}
}
print!("\n");
}
}
fn details_view(options: &Options, columns: &Vec<Column>, files: Vec<File>) {
2014-05-26 19:24:51 +00:00
// The output gets formatted into columns, which looks nicer. To
// do this, we have to write the results into a table, instead of
// displaying each file immediately, then calculating the maximum
// width of each column based on the length of the results and
// padding the fields during output.
let mut cache = Unix::empty_cache();
2014-06-23 17:26:35 +00:00
let mut table: Vec<Vec<String>> = files.iter()
.map(|f| columns.iter().map(|c| f.display(c, &mut cache)).collect())
.collect();
2014-05-03 13:26:49 +00:00
2014-06-23 17:26:35 +00:00
if options.header {
table.insert(0, columns.iter().map(|c| Plain.underline().paint(c.header())).collect());
2014-06-23 17:26:35 +00:00
}
2014-05-26 19:24:51 +00:00
// Each column needs to have its invisible colour-formatting
// characters stripped before it has its width calculated, or the
// width will be incorrect and the columns won't line up properly.
// This is fairly expensive to do (it uses a regex), so the
// results are cached.
let lengths: Vec<Vec<uint>> = table.iter()
2014-07-02 20:47:43 +00:00
.map(|row| row.iter().map(|col| strip_formatting(col.clone()).len()).collect())
.collect();
let column_widths: Vec<uint> = range(0, columns.len())
2014-11-24 01:24:45 +00:00
.map(|n| lengths.iter().map(|row| row[n]).max().unwrap_or(0))
.collect();
2014-05-03 10:30:37 +00:00
2014-06-28 14:40:12 +00:00
for (field_widths, row) in lengths.iter().zip(table.iter()) {
for (num, column) in columns.iter().enumerate() {
if num != 0 {
2014-05-03 11:15:35 +00:00
print!(" ");
}
if num == columns.len() - 1 {
print!("{}", row[num]);
}
else {
let padding = column_widths[num] - field_widths[num];
2014-11-23 21:29:11 +00:00
print!("{}", column.alignment().pad_string(&row[num], padding));
}
2014-05-03 11:15:35 +00:00
}
print!("\n");
2014-05-03 10:30:37 +00:00
}
}