Llewellyn/exa
1
0
Fork 0
mirror of https://github.com/Llewellynvdm/exa.git synced 2024-12-28 02:35:03 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'restructuring'

Browse Source
This commit is contained in:
Ben S 2015-05-12 03:41:07 +01:00
commit c938c699ec
10 changed files with 485 additions and 405 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/colours.rs
View File

@ -28,19 +28,19 @@ pub struct Colours {
pub struct FileTypes {
pub normal: Style,
pub directory: Style,
pub symlink: Style,
pub special: Style,
pub executable: Style,
pub image: Style,
pub video: Style,
pub music: Style,
pub lossless: Style,
pub crypto: Style,
pub document: Style,
pub compressed: Style,
pub temp: Style,
pub immediate: Style,
pub compiled: Style,
pub symlink: Style,
pub special: Style,
pub executable: Style,
pub image: Style,
pub video: Style,
pub music: Style,
pub lossless: Style,
pub crypto: Style,
pub document: Style,
pub compressed: Style,
pub temp: Style,
pub immediate: Style,
pub compiled: Style,
}
#[derive(Clone, Copy, Debug, Default, PartialEq)]

20
src/column.rs
View File

@ -11,7 +11,7 @@ use unicode_width::UnicodeWidthStr;
pub enum Column {
Permissions,
FileSize(SizeFormat),
Timestamp(TimeType, i64),
Timestamp(TimeType),
Blocks,
User,
Group,
@ -46,15 +46,15 @@ impl Column {
/// to have a header row printed.
pub fn header(&self) -> &'static str {
match *self {
Column::Permissions => "Permissions",
Column::FileSize(_) => "Size",
Column::Timestamp(t, _) => t.header(),
Column::Blocks => "Blocks",
Column::User => "User",
Column::Group => "Group",
Column::HardLinks => "Links",
Column::Inode => "inode",
Column::GitStatus => "Git",
Column::Permissions => "Permissions",
Column::FileSize(_) => "Size",
Column::Timestamp(t) => t.header(),
Column::Blocks => "Blocks",
Column::User => "User",
Column::Group => "Group",
Column::HardLinks => "Links",
Column::Inode => "inode",
Column::GitStatus => "Git",
}
}
}

11
src/dir.rs
View File

@ -1,6 +1,5 @@
use colours::Colours;
use feature::Git;
use file::File;
use file::{File, fields};
use std::io;
use std::fs;
@ -65,11 +64,11 @@ impl Dir {
}
/// Get a string describing the Git status of the given file.
pub fn git_status(&self, path: &Path, colours: &Colours, prefix_lookup: bool) -> String {
pub fn git_status(&self, path: &Path, prefix_lookup: bool) -> fields::Git {
match (&self.git, prefix_lookup) {
(&Some(ref git), false) => git.status(colours, path),
(&Some(ref git), true) => git.dir_status(colours, path),
(&None, _) => colours.punctuation.paint("--").to_string(),
(&Some(ref git), false) => git.status(path),
(&Some(ref git), true) => git.dir_status(path),
(&None, _) => fields::Git::empty()
}
}
}

62
src/feature/git.rs
View File

@ -1,9 +1,8 @@
use std::path::{Path, PathBuf};
use ansi_term::{ANSIString, ANSIStrings};
use git2;
use colours::Colours;
use file::fields;
/// Container of Git statuses for all the files in this folder's Git repository.
pub struct Git {
@ -29,49 +28,48 @@ impl Git {
}
/// Get the status for the file at the given path, if present.
pub fn status(&self, c: &Colours, path: &Path) -> String {
pub fn status(&self, path: &Path) -> fields::Git {
let status = self.statuses.iter()
.find(|p| p.0.as_path() == path);
match status {
Some(&(_, s)) => ANSIStrings( &[Git::index_status(c, s), Git::working_tree_status(c, s) ]).to_string(),
None => c.punctuation.paint("--").to_string(),
Some(&(_, s)) => fields::Git { staged: index_status(s), unstaged: working_tree_status(s) },
None => fields::Git { staged: fields::GitStatus::NotModified, unstaged: fields::GitStatus::NotModified }
}
}
/// Get the combined status for all the files whose paths begin with the
/// path that gets passed in. This is used for getting the status of
/// directories, which don't really have an 'official' status.
pub fn dir_status(&self, c: &Colours, dir: &Path) -> String {
pub fn dir_status(&self, dir: &Path) -> fields::Git {
let s = self.statuses.iter()
.filter(|p| p.0.starts_with(dir))
.fold(git2::Status::empty(), |a, b| a | b.1);
ANSIStrings( &[Git::index_status(c, s), Git::working_tree_status(c, s)] ).to_string()
}
/// The character to display if the file has been modified, but not staged.
fn working_tree_status(colours: &Colours, status: git2::Status) -> ANSIString<'static> {
match status {
s if s.contains(git2::STATUS_WT_NEW) => colours.git.new.paint("A"),
s if s.contains(git2::STATUS_WT_MODIFIED) => colours.git.modified.paint("M"),
s if s.contains(git2::STATUS_WT_DELETED) => colours.git.deleted.paint("D"),
s if s.contains(git2::STATUS_WT_RENAMED) => colours.git.renamed.paint("R"),
s if s.contains(git2::STATUS_WT_TYPECHANGE) => colours.git.typechange.paint("T"),
_ => colours.punctuation.paint("-"),
}
}
/// The character to display if the file has been modified, and the change
/// has been staged.
fn index_status(colours: &Colours, status: git2::Status) -> ANSIString<'static> {
match status {
s if s.contains(git2::STATUS_INDEX_NEW) => colours.git.new.paint("A"),
s if s.contains(git2::STATUS_INDEX_MODIFIED) => colours.git.modified.paint("M"),
s if s.contains(git2::STATUS_INDEX_DELETED) => colours.git.deleted.paint("D"),
s if s.contains(git2::STATUS_INDEX_RENAMED) => colours.git.renamed.paint("R"),
s if s.contains(git2::STATUS_INDEX_TYPECHANGE) => colours.git.typechange.paint("T"),
_ => colours.punctuation.paint("-"),
}
fields::Git { staged: index_status(s), unstaged: working_tree_status(s) }
}
}
/// The character to display if the file has been modified, but not staged.
fn working_tree_status(status: git2::Status) -> fields::GitStatus {
match status {
s if s.contains(git2::STATUS_WT_NEW) => fields::GitStatus::New,
s if s.contains(git2::STATUS_WT_MODIFIED) => fields::GitStatus::Modified,
s if s.contains(git2::STATUS_WT_DELETED) => fields::GitStatus::Deleted,
s if s.contains(git2::STATUS_WT_RENAMED) => fields::GitStatus::Renamed,
s if s.contains(git2::STATUS_WT_TYPECHANGE) => fields::GitStatus::TypeChange,
_ => fields::GitStatus::NotModified,
}
}
/// The character to display if the file has been modified, and the change
/// has been staged.
fn index_status(status: git2::Status) -> fields::GitStatus {
match status {
s if s.contains(git2::STATUS_INDEX_NEW) => fields::GitStatus::New,
s if s.contains(git2::STATUS_INDEX_MODIFIED) => fields::GitStatus::Modified,
s if s.contains(git2::STATUS_INDEX_DELETED) => fields::GitStatus::Deleted,
s if s.contains(git2::STATUS_INDEX_RENAMED) => fields::GitStatus::Renamed,
s if s.contains(git2::STATUS_INDEX_TYPECHANGE) => fields::GitStatus::TypeChange,
_ => fields::GitStatus::NotModified,
}
}

390
src/file.rs
View File

@ -3,34 +3,17 @@ use std::env::current_dir;
use std::fs;
use std::io;
use std::os::unix;
use std::os::unix::raw::mode_t;
use std::os::unix::fs::{MetadataExt, PermissionsExt};
use std::path::{Component, Path, PathBuf};
use ansi_term::{ANSIString, ANSIStrings, Style};
use ansi_term::Style::Plain;
use ansi_term::Colour::Fixed;
use users::Users;
use locale;
use unicode_width::UnicodeWidthStr;
use number_prefix::{binary_prefix, decimal_prefix, Prefixed, Standalone, PrefixNames};
use datetime::local::{LocalDateTime, DatePiece};
use datetime::format::{DateFormat};
use colours::Colours;
use column::{Column, Cell};
use column::Column::*;
use dir::Dir;
use filetype::file_colour;
use options::{SizeFormat, TimeType};
use output::details::UserLocale;
use options::TimeType;
use feature::Attribute;
use self::fields as f;
/// A **File** is a wrapper around one of Rust's Path objects, along with
/// associated data about the file.
///
@ -109,91 +92,24 @@ impl<'a> File<'a> {
self.name.starts_with(".")
}
/// Get the data for a column, formatted as a coloured string.
pub fn display<U: Users>(&self, column: &Column, colours: &Colours, users_cache: &mut U, locale: &UserLocale) -> Cell {
match *column {
Permissions => self.permissions_string(colours),
FileSize(f) => self.file_size(colours, f, &locale.numeric),
Timestamp(t, y) => self.timestamp(colours, t, y, &locale.time),
HardLinks => self.hard_links(colours, &locale.numeric),
Inode => self.inode(colours),
Blocks => self.blocks(colours, &locale.numeric),
User => self.user(colours, users_cache),
Group => self.group(colours, users_cache),
GitStatus => self.git_status(colours),
}
}
pub fn path_prefix(&self) -> String {
let path_bytes: Vec<Component> = self.path.components().collect();
let mut path_prefix = String::new();
/// The "file name view" is what's displayed in the column and lines
/// views, but *not* in the grid view.
///
/// It consists of the file name coloured in the appropriate style,
/// with special formatting for a symlink.
pub fn file_name_view(&self, colours: &Colours) -> String {
if self.is_link() {
self.symlink_file_name_view(colours)
}
else {
file_colour(colours, self).paint(&*self.name).to_string()
}
}
if !path_bytes.is_empty() {
// Use init() to add all but the last component of the
// path to the prefix. init() panics when given an
// empty list, hence the check.
for component in path_bytes.init().iter() {
path_prefix.push_str(&*component.as_os_str().to_string_lossy());
/// If this file is a symlink, returns a string displaying its name,
/// and an arrow pointing to the file it links to, which is also
/// coloured in the appropriate style.
///
/// If the symlink target doesn't exist, then instead of displaying
/// an error, highlight the target and arrow in red. The error would
/// be shown out of context, and it's almost always because the
/// target doesn't exist.
fn symlink_file_name_view(&self, colours: &Colours) -> String {
let name = &*self.name;
let style = file_colour(colours, self);
if let Ok(path) = fs::read_link(&self.path) {
let target_path = match self.dir {
Some(dir) => dir.join(&*path),
None => path,
};
match self.target_file(&target_path) {
Ok(file) => {
// Generate a preview for the path this symlink links to.
// The preview should consist of the directory of the file
// (if present) in cyan, an extra slash if necessary, then
// the target file, colourised in the appropriate style.
let mut path_prefix = String::new();
let path_bytes: Vec<Component> = file.path.components().collect();
if !path_bytes.is_empty() {
// Use init() to add all but the last component of the
// path to the prefix. init() panics when given an
// empty list, hence the check.
for component in path_bytes.init().iter() {
path_prefix.push_str(&*component.as_os_str().to_string_lossy());
if component != &Component::RootDir {
path_prefix.push_str("/");
}
}
}
format!("{} {} {}",
style.paint(name),
colours.punctuation.paint("=>"),
ANSIStrings(&[ colours.symlink_path.paint(&path_prefix),
file_colour(colours, &file).paint(&file.name) ]))
},
Err(filename) => format!("{} {} {}",
style.paint(name),
colours.broken_arrow.paint("=>"),
colours.broken_filename.paint(&filename)),
if component != &Component::RootDir {
path_prefix.push_str("/");
}
}
}
else {
style.paint(name).to_string()
}
path_prefix
}
/// The Unicode 'display width' of the filename.
@ -211,17 +127,27 @@ impl<'a> File<'a> {
/// If statting the file fails (usually because the file on the
/// other end doesn't exist), returns the *filename* of the file
/// that should be there.
fn target_file(&self, target_path: &Path) -> Result<File, String> {
let filename = path_filename(target_path);
pub fn link_target(&self) -> Result<File, String> {
let path = match fs::read_link(&self.path) {
Ok(path) => path,
Err(_) => return Err(self.name.clone()),
};
let target_path = match self.dir {
Some(dir) => dir.join(&*path),
None => path
};
let filename = path_filename(&target_path);
// Use plain `metadata` instead of `symlink_metadata` - we *want* to follow links.
if let Ok(stat) = fs::metadata(target_path) {
if let Ok(stat) = fs::metadata(&target_path) {
Ok(File {
path: target_path.to_path_buf(),
dir: self.dir,
stat: stat,
ext: ext(&filename),
xattrs: Attribute::list(target_path).unwrap_or(Vec::new()),
xattrs: Attribute::list(&target_path).unwrap_or(Vec::new()),
name: filename.to_string(),
this: None,
})
@ -232,76 +158,38 @@ impl<'a> File<'a> {
}
/// This file's number of hard links as a coloured string.
fn hard_links(&self, colours: &Colours, locale: &locale::Numeric) -> Cell {
let style = if self.has_multiple_links() { colours.links.multi_link_file }
else { colours.links.normal };
Cell::paint(style, &locale.format_int(self.stat.as_raw().nlink())[..])
}
/// Whether this is a regular file with more than one link.
///
/// This is important, because a file with multiple links is uncommon,
/// while you can come across directories and other types with multiple
/// links much more often.
fn has_multiple_links(&self) -> bool {
self.is_file() && self.stat.as_raw().nlink() > 1
pub fn links(&self) -> f::Links {
let count = self.stat.as_raw().nlink();
f::Links {
count: count,
multiple: self.is_file() && count > 1,
}
}
/// This file's inode as a coloured string.
fn inode(&self, colours: &Colours) -> Cell {
let inode = self.stat.as_raw().ino();
Cell::paint(colours.inode, &inode.to_string()[..])
pub fn inode(&self) -> f::Inode {
f::Inode(self.stat.as_raw().ino())
}
/// This file's number of filesystem blocks (if available) as a coloured string.
fn blocks(&self, colours: &Colours, locale: &locale::Numeric) -> Cell {
pub fn blocks(&self) -> f::Blocks {
if self.is_file() || self.is_link() {
Cell::paint(colours.blocks, &locale.format_int(self.stat.as_raw().blocks())[..])
f::Blocks::Some(self.stat.as_raw().blocks())
}
else {
Cell { text: colours.punctuation.paint("-").to_string(), length: 1 }
f::Blocks::None
}
}
/// This file's owner's username as a coloured string.
///
/// If the user is not present, then it formats the uid as a number
/// instead. This usually happens when a user is deleted, but still owns
/// files.
fn user<U: Users>(&self, colours: &Colours, users_cache: &mut U) -> Cell {
let uid = self.stat.as_raw().uid();
let user_name = match users_cache.get_user_by_uid(uid) {
Some(user) => user.name,
None => uid.to_string(),
};
let style = if users_cache.get_current_uid() == uid { colours.users.user_you } else { colours.users.user_someone_else };
Cell::paint(style, &*user_name)
pub fn user(&self) -> f::User {
f::User(self.stat.as_raw().uid())
}
/// This file's group name as a coloured string.
///
/// As above, if not present, it formats the gid as a number instead.
fn group<U: Users>(&self, colours: &Colours, users_cache: &mut U) -> Cell {
let gid = self.stat.as_raw().gid();
let mut style = colours.users.group_not_yours;
let group_name = match users_cache.get_group_by_gid(gid as u32) {
Some(group) => {
let current_uid = users_cache.get_current_uid();
if let Some(current_user) = users_cache.get_user_by_uid(current_uid) {
if current_user.primary_group == group.gid || group.members.contains(&current_user.name) {
style = colours.users.group_yours;
}
}
group.name
},
None => gid.to_string(),
};
Cell::paint(style, &*group_name)
pub fn group(&self) -> f::Group {
f::Group(self.stat.as_raw().gid())
}
/// This file's size, formatted using the given way, as a coloured string.
@ -310,118 +198,63 @@ impl<'a> File<'a> {
/// some filesystems, I've never looked at one of those numbers and gained
/// any information from it, so by emitting "-" instead, the table is less
/// cluttered with numbers.
fn file_size(&self, colours: &Colours, size_format: SizeFormat, locale: &locale::Numeric) -> Cell {
pub fn size(&self) -> f::Size {
if self.is_directory() {
Cell { text: colours.punctuation.paint("-").to_string(), length: 1 }
f::Size::None
}
else {
let result = match size_format {
SizeFormat::DecimalBytes => decimal_prefix(self.stat.len() as f64),
SizeFormat::BinaryBytes => binary_prefix(self.stat.len() as f64),
SizeFormat::JustBytes => return Cell::paint(colours.size.numbers, &locale.format_int(self.stat.len())[..]),
};
match result {
Standalone(bytes) => Cell::paint(colours.size.numbers, &*bytes.to_string()),
Prefixed(prefix, n) => {
let number = if n < 10f64 { locale.format_float(n, 1) } else { locale.format_int(n as isize) };
let symbol = prefix.symbol();
Cell {
text: ANSIStrings( &[ colours.size.unit.paint(&number[..]), colours.size.unit.paint(symbol) ]).to_string(),
length: number.len() + symbol.len(),
}
}
}
f::Size::Some(self.stat.len())
}
}
fn timestamp(&self, colours: &Colours, time_type: TimeType, current_year: i64, locale: &locale::Time) -> Cell {
pub fn timestamp(&self, time_type: TimeType) -> f::Time {
let time_in_seconds = match time_type {
TimeType::FileAccessed => self.stat.as_raw().atime(),
TimeType::FileModified => self.stat.as_raw().mtime(),
TimeType::FileCreated => self.stat.as_raw().ctime(),
} as i64;
};
let date = LocalDateTime::at(time_in_seconds);
let format = if date.year() == current_year {
DateFormat::parse("{2>:D} {:M} {2>:h}:{02>:m}").unwrap()
}
else {
DateFormat::parse("{2>:D} {:M} {5>:Y}").unwrap()
};
Cell::paint(colours.date, &format.format(date, locale))
f::Time(time_in_seconds)
}
/// This file's type, represented by a coloured character.
///
/// Although the file type can usually be guessed from the colour of the
/// file, `ls` puts this character there, so people will expect it.
fn type_char(&self, colours: &Colours) -> ANSIString {
fn type_char(&self) -> f::Type {
if self.is_file() {
colours.filetypes.normal.paint(".")
f::Type::File
}
else if self.is_directory() {
colours.filetypes.directory.paint("d")
f::Type::Directory
}
else if self.is_pipe() {
colours.filetypes.special.paint("|")
f::Type::Pipe
}
else if self.is_link() {
colours.filetypes.symlink.paint("l")
f::Type::Link
}
else {
colours.filetypes.special.paint("?")
f::Type::Special
}
}
/// Marker indicating that the file contains extended attributes
///
/// Returns "@" or " " depending on wheter the file contains an extented
/// attribute or not. Also returns " " in case the attributes cannot be read
/// for some reason.
fn attribute_marker(&self, colours: &Colours) -> ANSIString {
if self.xattrs.len() > 0 { colours.perms.attribute.paint("@") } else { Plain.paint(" ") }
}
/// Generate the "rwxrwxrwx" permissions string, like how ls does it.
///
/// Each character is given its own colour. The first three permission
/// bits are bold because they're the ones used most often, and executable
/// files are underlined to make them stand out more.
fn permissions_string(&self, colours: &Colours) -> Cell {
pub fn permissions(&self) -> f::Permissions {
let bits = self.stat.permissions().mode();
let executable_colour = if self.is_file() { colours.perms.user_execute_file }
else { colours.perms.user_execute_other };
let has_bit = |bit| { bits & bit == bit };
let string = ANSIStrings(&[
self.type_char(colours),
File::permission_bit(bits, unix::fs::USER_READ, "r", colours.perms.user_read),
File::permission_bit(bits, unix::fs::USER_WRITE, "w", colours.perms.user_write),
File::permission_bit(bits, unix::fs::USER_EXECUTE, "x", executable_colour),
File::permission_bit(bits, unix::fs::GROUP_READ, "r", colours.perms.group_read),
File::permission_bit(bits, unix::fs::GROUP_WRITE, "w", colours.perms.group_write),
File::permission_bit(bits, unix::fs::GROUP_EXECUTE, "x", colours.perms.group_execute),
File::permission_bit(bits, unix::fs::OTHER_READ, "r", colours.perms.other_read),
File::permission_bit(bits, unix::fs::OTHER_WRITE, "w", colours.perms.other_write),
File::permission_bit(bits, unix::fs::OTHER_EXECUTE, "x", colours.perms.other_execute),
self.attribute_marker(colours)
]).to_string();
Cell { text: string, length: 11 }
}
/// Helper method for the permissions string.
fn permission_bit(bits: mode_t, bit: mode_t, character: &'static str, style: Style) -> ANSIString<'static> {
if bits & bit == bit {
style.paint(character)
}
else {
Fixed(244).paint("-")
f::Permissions {
file_type: self.type_char(),
user_read: has_bit(unix::fs::USER_READ),
user_write: has_bit(unix::fs::USER_WRITE),
user_execute: has_bit(unix::fs::USER_EXECUTE),
group_read: has_bit(unix::fs::GROUP_READ),
group_write: has_bit(unix::fs::GROUP_WRITE),
group_execute: has_bit(unix::fs::GROUP_EXECUTE),
other_read: has_bit(unix::fs::OTHER_READ),
other_write: has_bit(unix::fs::OTHER_WRITE),
other_execute: has_bit(unix::fs::OTHER_EXECUTE),
attribute: !self.xattrs.is_empty()
}
}
@ -471,20 +304,18 @@ impl<'a> File<'a> {
choices.contains(&&self.name[..])
}
fn git_status(&self, colours: &Colours) -> Cell {
let status = match self.dir {
None => colours.punctuation.paint("--").to_string(),
pub fn git_status(&self) -> f::Git {
match self.dir {
None => f::Git { staged: f::GitStatus::NotModified, unstaged: f::GitStatus::NotModified },
Some(d) => {
let cwd = match current_dir() {
Err(_) => Path::new(".").join(&self.path),
Ok(dir) => dir.join(&self.path),
};
d.git_status(&cwd, colours, self.is_directory())
d.git_status(&cwd, self.is_directory())
},
};
Cell { text: status, length: 2 }
}
}
}
@ -513,6 +344,71 @@ fn ext<'a>(name: &'a str) -> Option<String> {
name.rfind('.').map(|p| name[p+1..].to_ascii_lowercase())
}
pub mod fields {
use std::os::unix::raw::{blkcnt_t, gid_t, ino_t, nlink_t, time_t, uid_t};
pub enum Type {
File, Directory, Pipe, Link, Special,
}
pub struct Permissions {
pub file_type: Type,
pub user_read: bool,
pub user_write: bool,
pub user_execute: bool,
pub group_read: bool,
pub group_write: bool,
pub group_execute: bool,
pub other_read: bool,
pub other_write: bool,
pub other_execute: bool,
pub attribute: bool,
}
pub struct Links {
pub count: nlink_t,
pub multiple: bool,
}
pub struct Inode(pub ino_t);
pub enum Blocks {
Some(blkcnt_t),
None,
}
pub struct User(pub uid_t);
pub struct Group(pub gid_t);
pub enum Size {
Some(u64),
None,
}
pub struct Time(pub time_t);
pub enum GitStatus {
NotModified,
New,
Modified,
Deleted,
Renamed,
TypeChange,
}
pub struct Git {
pub staged: GitStatus,
pub unstaged: GitStatus,
}
impl Git {
pub fn empty() -> Git {
Git { staged: GitStatus::NotModified, unstaged: GitStatus::NotModified }
}
}
}
#[cfg(broken_test)]
pub mod test {
pub use super::*;

20
src/filetype.rs
View File

@ -43,7 +43,7 @@ impl<'_> FileTypes for File<'_> {
"build.gradle", "Rakefile", "Gruntfile.js",
"Gruntfile.coffee",
])
}
}
fn is_image(&self) -> bool {
self.extension_is_one_of( &[
@ -52,33 +52,33 @@ impl<'_> FileTypes for File<'_> {
"svg", "stl", "eps", "dvi", "ps", "cbr",
"cbz", "xpm", "ico",
])
}
}
fn is_video(&self) -> bool {
self.extension_is_one_of( &[
"avi", "flv", "m2v", "mkv", "mov", "mp4", "mpeg",
"mpg", "ogm", "ogv", "vob", "wmv",
])
}
}
fn is_music(&self) -> bool {
self.extension_is_one_of( &[
"aac", "m4a", "mp3", "ogg", "wma",
])
}
}
fn is_lossless(&self) -> bool {
self.extension_is_one_of( &[
"alac", "ape", "flac", "wav",
])
}
}
fn is_crypto(&self) -> bool {
self.extension_is_one_of( &[
"zip", "tar", "Z", "gz", "bz2", "a", "ar", "7z",
"iso", "dmg", "tc", "rar", "par",
])
}
}
fn is_document(&self) -> bool {
self.extension_is_one_of( &[
@ -86,20 +86,20 @@ impl<'_> FileTypes for File<'_> {
"odp", "odt", "pdf", "ppt", "pptx", "rtf",
"xls", "xlsx",
])
}
}
fn is_compressed(&self) -> bool {
self.extension_is_one_of( &[
"zip", "tar", "Z", "gz", "bz2", "a", "ar", "7z",
"iso", "dmg", "tc", "rar", "par"
])
}
}
fn is_temp(&self) -> bool {
self.name.ends_with("~")
|| (self.name.starts_with("#") && self.name.ends_with("#"))
|| self.extension_is_one_of( &[ "tmp", "swp", "swo", "swn", "bak" ])
}
}
fn is_compiled(&self) -> bool {
if self.extension_is_one_of( &[ "class", "elc", "hi", "o", "pyc" ]) {
@ -111,7 +111,7 @@ impl<'_> FileTypes for File<'_> {
else {
false
}
}
}
}
#[cfg(broken_test)]

90
src/options.rs
View File

@ -15,8 +15,6 @@ use std::os::unix::fs::MetadataExt;
use getopts;
use natord;
use datetime::local::{LocalDateTime, DatePiece};
use self::Misfire::*;
/// The *Options* struct represents a parsed version of the user's
@ -137,17 +135,17 @@ impl FileFilter {
}
match self.sort_field {
SortField::Unsorted => {},
SortField::Name => files.sort_by(|a, b| natord::compare(&*a.name, &*b.name)),
SortField::Size => files.sort_by(|a, b| a.stat.len().cmp(&b.stat.len())),
SortField::FileInode => files.sort_by(|a, b| a.stat.as_raw().ino().cmp(&b.stat.as_raw().ino())),
SortField::Extension => files.sort_by(|a, b| match a.ext.cmp(&b.ext) {
Ordering::Equal => natord::compare(&*a.name, &*b.name),
order => order
SortField::Unsorted => {},
SortField::Name => files.sort_by(|a, b| natord::compare(&*a.name, &*b.name)),
SortField::Size => files.sort_by(|a, b| a.stat.len().cmp(&b.stat.len())),
SortField::FileInode => files.sort_by(|a, b| a.stat.as_raw().ino().cmp(&b.stat.as_raw().ino())),
SortField::ModifiedDate => files.sort_by(|a, b| a.stat.as_raw().mtime().cmp(&b.stat.as_raw().mtime())),
SortField::AccessedDate => files.sort_by(|a, b| a.stat.as_raw().atime().cmp(&b.stat.as_raw().atime())),
SortField::CreatedDate => files.sort_by(|a, b| a.stat.as_raw().ctime().cmp(&b.stat.as_raw().ctime())),
SortField::Extension => files.sort_by(|a, b| match a.ext.cmp(&b.ext) {
Ordering::Equal => natord::compare(&*a.name, &*b.name),
order => order,
}),
SortField::ModifiedDate => files.sort_by(|a, b| a.stat.as_raw().mtime().cmp(&b.stat.as_raw().mtime())),
SortField::AccessedDate => files.sort_by(|a, b| a.stat.as_raw().atime().cmp(&b.stat.as_raw().atime())),
SortField::CreatedDate => files.sort_by(|a, b| a.stat.as_raw().ctime().cmp(&b.stat.as_raw().ctime())),
}
if self.reverse {
@ -173,15 +171,15 @@ impl SortField {
/// Find which field to use based on a user-supplied word.
fn from_word(word: String) -> Result<SortField, Misfire> {
match &word[..] {
"name" | "filename" => Ok(SortField::Name),
"size" | "filesize" => Ok(SortField::Size),
"ext" | "extension" => Ok(SortField::Extension),
"mod" | "modified" => Ok(SortField::ModifiedDate),
"acc" | "accessed" => Ok(SortField::AccessedDate),
"cr" | "created" => Ok(SortField::CreatedDate),
"none" => Ok(SortField::Unsorted),
"inode" => Ok(SortField::FileInode),
field => Err(SortField::none(field))
"name" | "filename" => Ok(SortField::Name),
"size" | "filesize" => Ok(SortField::Size),
"ext" | "extension" => Ok(SortField::Extension),
"mod" | "modified" => Ok(SortField::ModifiedDate),
"acc" | "accessed" => Ok(SortField::AccessedDate),
"cr" | "created" => Ok(SortField::CreatedDate),
"none" => Ok(SortField::Unsorted),
"inode" => Ok(SortField::FileInode),
field => Err(SortField::none(field))
}
}
@ -231,14 +229,14 @@ impl Misfire {
impl fmt::Display for Misfire {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
InvalidOptions(ref e) => write!(f, "{}", e),
Help(ref text) => write!(f, "{}", text),
Version => write!(f, "exa {}", env!("CARGO_PKG_VERSION")),
Conflict(a, b) => write!(f, "Option --{} conflicts with option {}.", a, b),
Useless(a, false, b) => write!(f, "Option --{} is useless without option --{}.", a, b),
Useless(a, true, b) => write!(f, "Option --{} is useless given option --{}.", a, b),
Useless2(a, b1, b2) => write!(f, "Option --{} is useless without options --{} or --{}.", a, b1, b2),
FailedParse(ref e) => write!(f, "Failed to parse number: {}", e),
InvalidOptions(ref e) => write!(f, "{}", e),
Help(ref text) => write!(f, "{}", text),
Version => write!(f, "exa {}", env!("CARGO_PKG_VERSION")),
Conflict(a, b) => write!(f, "Option --{} conflicts with option {}.", a, b),
Useless(a, false, b) => write!(f, "Option --{} is useless without option --{}.", a, b),
Useless(a, true, b) => write!(f, "Option --{} is useless given option --{}.", a, b),
Useless2(a, b1, b2) => write!(f, "Option --{} is useless without options --{} or --{}.", a, b1, b2),
FailedParse(ref e) => write!(f, "Failed to parse number: {}", e),
}
}
}
@ -351,10 +349,10 @@ impl SizeFormat {
let bytes = matches.opt_present("bytes");
match (binary, bytes) {
(true, true ) => Err(Misfire::Conflict("binary", "bytes")),
(true, false) => Ok(SizeFormat::BinaryBytes),
(false, true ) => Ok(SizeFormat::JustBytes),
(false, false) => Ok(SizeFormat::DecimalBytes),
(true, true ) => Err(Misfire::Conflict("binary", "bytes")),
(true, false) => Ok(SizeFormat::BinaryBytes),
(false, true ) => Ok(SizeFormat::JustBytes),
(false, false) => Ok(SizeFormat::DecimalBytes),
}
}
}
@ -369,9 +367,9 @@ pub enum TimeType {
impl TimeType {
pub fn header(&self) -> &'static str {
match *self {
TimeType::FileAccessed => "Date Accessed",
TimeType::FileModified => "Date Modified",
TimeType::FileCreated => "Date Created",
TimeType::FileAccessed => "Date Accessed",
TimeType::FileModified => "Date Modified",
TimeType::FileCreated => "Date Created",
}
}
}
@ -441,12 +439,12 @@ impl DirAction {
let tree = matches.opt_present("tree");
match (recurse, list, tree) {
(true, true, _ ) => Err(Misfire::Conflict("recurse", "list-dirs")),
(_, true, true ) => Err(Misfire::Conflict("tree", "list-dirs")),
(true, false, false) => Ok(DirAction::Recurse(try!(RecurseOptions::deduce(matches, false)))),
(_ , _, true ) => Ok(DirAction::Recurse(try!(RecurseOptions::deduce(matches, true)))),
(false, true, _ ) => Ok(DirAction::AsFile),
(false, false, _ ) => Ok(DirAction::List),
(true, true, _ ) => Err(Misfire::Conflict("recurse", "list-dirs")),
(_, true, true ) => Err(Misfire::Conflict("tree", "list-dirs")),
(true, false, false) => Ok(DirAction::Recurse(try!(RecurseOptions::deduce(matches, false)))),
(_ , _, true ) => Ok(DirAction::Recurse(try!(RecurseOptions::deduce(matches, true)))),
(false, true, _ ) => Ok(DirAction::AsFile),
(false, false, _ ) => Ok(DirAction::List),
}
}
@ -555,18 +553,16 @@ impl Columns {
columns.push(Group);
}
let current_year = LocalDateTime::now().year();
if self.time_types.modified {
columns.push(Timestamp(TimeType::FileModified, current_year));
columns.push(Timestamp(TimeType::FileModified));
}
if self.time_types.created {
columns.push(Timestamp(TimeType::FileCreated, current_year));
columns.push(Timestamp(TimeType::FileCreated));
}
if self.time_types.accessed {
columns.push(Timestamp(TimeType::FileAccessed, current_year));
columns.push(Timestamp(TimeType::FileAccessed));
}
if cfg!(feature="git") {

238
src/output/details.rs
View File

@ -3,11 +3,22 @@ use column::{Alignment, Column, Cell};
use feature::Attribute;
use dir::Dir;
use file::File;
use options::{Columns, FileFilter, RecurseOptions};
use users::OSUsers;
use file::fields as f;
use options::{Columns, FileFilter, RecurseOptions, SizeFormat};
use users::{OSUsers, Users};
use super::filename;
use ansi_term::{ANSIString, ANSIStrings, Style};
use ansi_term::Style::Plain;
use locale;
use number_prefix::{binary_prefix, decimal_prefix, Prefixed, Standalone, PrefixNames};
use datetime::local::{LocalDateTime, DatePiece};
use datetime::format::{DateFormat};
/// With the **Details** view, the output gets formatted into columns, with
/// each `Column` object showing some piece of information about the file,
/// such as its size, or its permissions.
@ -109,11 +120,14 @@ struct Row {
/// A **Table** object gets built up by the view as it lists files and
/// directories.
struct Table {
columns: Vec<Column>,
users: OSUsers,
locale: UserLocale,
rows: Vec<Row>,
colours: Colours,
columns: Vec<Column>,
rows: Vec<Row>,
time: locale::Time,
numeric: locale::Numeric,
users: OSUsers,
colours: Colours,
current_year: i64,
}
impl Table {
@ -122,10 +136,13 @@ impl Table {
fn with_options(colours: Colours, columns: Vec<Column>) -> Table {
Table {
columns: columns,
users: OSUsers::empty_cache(),
locale: UserLocale::new(),
rows: Vec::new(),
colours: colours,
rows: Vec::new(),
time: locale::Time::load_user_locale().unwrap_or_else(|_| locale::Time::english()),
numeric: locale::Numeric::load_user_locale().unwrap_or_else(|_| locale::Numeric::english()),
users: OSUsers::empty_cache(),
colours: colours,
current_year: LocalDateTime::now().year(),
}
}
@ -145,26 +162,183 @@ impl Table {
self.rows.push(row);
}
/// Use the list of columns to find which cells should be produced for
/// this file, per-column.
fn cells_for_file(&mut self, file: &File) -> Vec<Cell> {
self.columns.clone().iter()
.map(|c| file.display(c, &self.colours, &mut self.users, &self.locale))
.collect()
}
/// Get the cells for the given file, and add the result to the table.
fn add_file(&mut self, file: &File, depth: usize, last: bool) {
let row = Row {
depth: depth,
cells: self.cells_for_file(file),
name: file.file_name_view(&self.colours),
name: filename(file, &self.colours),
last: last,
attrs: file.xattrs.clone(),
children: file.this.is_some(),
};
self.rows.push(row)
self.rows.push(row);
}
/// Use the list of columns to find which cells should be produced for
/// this file, per-column.
fn cells_for_file(&mut self, file: &File) -> Vec<Cell> {
self.columns.clone().iter()
.map(|c| self.display(file, c))
.collect()
}
fn display(&mut self, file: &File, column: &Column) -> Cell {
match *column {
Column::Permissions => self.render_permissions(file.permissions()),
Column::FileSize(fmt) => self.render_size(file.size(), fmt),
Column::Timestamp(t) => self.render_time(file.timestamp(t)),
Column::HardLinks => self.render_links(file.links()),
Column::Inode => self.render_inode(file.inode()),
Column::Blocks => self.render_blocks(file.blocks()),
Column::User => self.render_user(file.user()),
Column::Group => self.render_group(file.group()),
Column::GitStatus => self.render_git_status(file.git_status()),
}
}
fn render_permissions(&self, permissions: f::Permissions) -> Cell {
let c = self.colours.perms;
let bit = |bit, chr: &'static str, style: Style| {
if bit { style.paint(chr) } else { self.colours.punctuation.paint("-") }
};
let file_type = match permissions.file_type {
f::Type::File => self.colours.filetypes.normal.paint("."),
f::Type::Directory => self.colours.filetypes.directory.paint("d"),
f::Type::Pipe => self.colours.filetypes.special.paint("|"),
f::Type::Link => self.colours.filetypes.symlink.paint("l"),
f::Type::Special => self.colours.filetypes.special.paint("?"),
};
let x_colour = if let f::Type::File = permissions.file_type { c.user_execute_file }
else { c.user_execute_other };
let string = ANSIStrings( &[
file_type,
bit(permissions.user_read, "r", c.user_read),
bit(permissions.user_write, "w", c.user_write),
bit(permissions.user_execute, "x", x_colour),
bit(permissions.group_read, "r", c.group_read),
bit(permissions.group_write, "w", c.group_write),
bit(permissions.group_execute, "x", c.group_execute),
bit(permissions.other_read, "r", c.other_read),
bit(permissions.other_write, "w", c.other_write),
bit(permissions.other_execute, "x", c.other_execute),
if permissions.attribute { c.attribute.paint("@") } else { Plain.paint(" ") },
]).to_string();
Cell {
text: string,
length: 11,
}
}
fn render_links(&self, links: f::Links) -> Cell {
let style = if links.multiple { self.colours.links.multi_link_file }
else { self.colours.links.normal };
Cell::paint(style, &self.numeric.format_int(links.count))
}
fn render_blocks(&self, blocks: f::Blocks) -> Cell {
match blocks {
f::Blocks::Some(blocks) => Cell::paint(self.colours.blocks, &blocks.to_string()),
f::Blocks::None => Cell::paint(self.colours.punctuation, "-"),
}
}
fn render_inode(&self, inode: f::Inode) -> Cell {
Cell::paint(self.colours.inode, &inode.0.to_string())
}
fn render_size(&self, size: f::Size, size_format: SizeFormat) -> Cell {
if let f::Size::Some(offset) = size {
let result = match size_format {
SizeFormat::DecimalBytes => decimal_prefix(offset as f64),
SizeFormat::BinaryBytes => binary_prefix(offset as f64),
SizeFormat::JustBytes => return Cell::paint(self.colours.size.numbers, &self.numeric.format_int(offset)),
};
match result {
Standalone(bytes) => Cell::paint(self.colours.size.numbers, &*bytes.to_string()),
Prefixed(prefix, n) => {
let number = if n < 10f64 { self.numeric.format_float(n, 1) } else { self.numeric.format_int(n as isize) };
let symbol = prefix.symbol();
Cell {
text: ANSIStrings( &[ self.colours.size.numbers.paint(&number[..]), self.colours.size.unit.paint(symbol) ]).to_string(),
length: number.len() + symbol.len(),
}
}
}
}
else {
Cell::paint(self.colours.punctuation, "-")
}
}
fn render_time(&self, timestamp: f::Time) -> Cell {
let date = LocalDateTime::at(timestamp.0);
let format = if date.year() == self.current_year {
DateFormat::parse("{2>:D} {:M} {2>:h}:{02>:m}").unwrap()
}
else {
DateFormat::parse("{2>:D} {:M} {5>:Y}").unwrap()
};
Cell::paint(self.colours.date, &format.format(date, &self.time))
}
fn render_git_status(&self, git: f::Git) -> Cell {
Cell {
text: ANSIStrings(&[ self.render_git_char(git.staged),
self.render_git_char(git.unstaged) ]).to_string(),
length: 2,
}
}
fn render_git_char(&self, status: f::GitStatus) -> ANSIString {
match status {
f::GitStatus::NotModified => self.colours.punctuation.paint("-"),
f::GitStatus::New => self.colours.git.new.paint("N"),
f::GitStatus::Modified => self.colours.git.modified.paint("M"),
f::GitStatus::Deleted => self.colours.git.deleted.paint("D"),
f::GitStatus::Renamed => self.colours.git.renamed.paint("R"),
f::GitStatus::TypeChange => self.colours.git.typechange.paint("T"),
}
}
fn render_user(&mut self, user: f::User) -> Cell {
let user_name = match self.users.get_user_by_uid(user.0) {
Some(user) => user.name,
None => user.0.to_string(),
};
let style = if self.users.get_current_uid() == user.0 { self.colours.users.user_you }
else { self.colours.users.user_someone_else };
Cell::paint(style, &*user_name)
}
fn render_group(&mut self, group: f::Group) -> Cell {
let mut style = self.colours.users.group_not_yours;
let group_name = match self.users.get_group_by_gid(group.0) {
Some(group) => {
let current_uid = self.users.get_current_uid();
if let Some(current_user) = self.users.get_user_by_uid(current_uid) {
if current_user.primary_group == group.gid || group.members.contains(&current_user.name) {
style = self.colours.users.group_yours;
}
}
group.name
},
None => group.0.to_string(),
};
Cell::paint(style, &*group_name)
}
/// Print the table to standard output, consuming it in the process.
@ -243,24 +417,10 @@ enum TreePart {
impl TreePart {
fn ascii_art(&self) -> &'static str {
match *self {
TreePart::Edge => "├──",
TreePart::Line => "│ ",
TreePart::Corner => "└──",
TreePart::Blank => " ",
}
}
}
pub struct UserLocale {
pub time: locale::Time,
pub numeric: locale::Numeric,
}
impl UserLocale {
pub fn new() -> UserLocale {
UserLocale {
time: locale::Time::load_user_locale().unwrap_or_else(|_| locale::Time::english()),
numeric: locale::Numeric::load_user_locale().unwrap_or_else(|_| locale::Numeric::english()),
TreePart::Edge => "├──",
TreePart::Line => "│ ",
TreePart::Corner => "└──",
TreePart::Blank => " ",
}
}
}

3
src/output/lines.rs
View File

@ -1,5 +1,6 @@
use colours::Colours;
use file::File;
use super::filename;
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Lines {
@ -10,7 +11,7 @@ pub struct Lines {
impl Lines {
pub fn view(&self, files: &[File]) {
for file in files {
println!("{}", file.file_name_view(&self.colours));
println!("{}", filename(file, &self.colours));
}
}
}

30
src/output/mod.rs
View File

@ -2,6 +2,36 @@ mod grid;
pub mod details;
mod lines;
use colours::Colours;
use file::File;
use filetype::file_colour;
use ansi_term::ANSIStrings;
pub use self::grid::Grid;
pub use self::details::Details;
pub use self::lines::Lines;
pub fn filename(file: &File, colours: &Colours) -> String {
if file.is_link() {
symlink_filename(file, colours)
}
else {
let style = file_colour(colours, file);
style.paint(&file.name).to_string()
}
}
fn symlink_filename(file: &File, colours: &Colours) -> String {
match file.link_target() {
Ok(target) => format!("{} {} {}",
file_colour(colours, file).paint(&file.name),
colours.punctuation.paint("=>"),
ANSIStrings(&[ colours.symlink_path.paint(&target.path_prefix()),
file_colour(colours, &target).paint(&target.name) ])),
Err(filename) => format!("{} {} {}",
file_colour(colours, file).paint(&file.name),
colours.broken_arrow.paint("=>"),
colours.broken_filename.paint(&filename)),
}
}