exa/src/fs/file.rs

469 lines
16 KiB
Rust
Raw Normal View History

2015-05-16 15:10:58 +00:00
//! Files, and methods and fields to access their metadata.
use std::fs;
use std::io::Error as IOError;
2015-12-15 21:47:37 +00:00
use std::io::Result as IOResult;
use std::os::unix::fs::{MetadataExt, PermissionsExt, FileTypeExt};
use std::path::{Path, PathBuf};
use fs::dir::Dir;
use fs::fields as f;
2017-05-01 21:43:28 +00:00
2015-01-24 12:38:05 +00:00
/// A **File** is a wrapper around one of Rust's Path objects, along with
/// associated data about the file.
///
/// Each file is definitely going to have its filename displayed at least
2015-05-16 17:16:35 +00:00
/// once, have its file extension extracted at least once, and have its metadata
2015-01-24 12:38:05 +00:00
/// information queried at least once, so it makes sense to do all this at the
/// start and hold on to all the information.
2015-05-12 14:38:12 +00:00
pub struct File<'dir> {
2015-05-16 15:10:58 +00:00
/// The filename portion of this file's path, including the extension.
///
/// This is used to compare against certain filenames (such as checking if
/// its “Makefile” or something) and to highlight only the filename in
/// colour when displaying the path.
pub name: String,
2015-05-16 15:10:58 +00:00
/// The files names extension, if present, extracted from the name.
///
/// This is queried many times over, so its worth caching it.
pub ext: Option<String>,
2015-05-16 15:10:58 +00:00
/// The path that begat this file.
///
/// Even though the file's name is extracted, the path needs to be kept
/// around, as certain operations involve looking up the file's absolute
/// location (such as the Git status, or searching for compiled files).
pub path: PathBuf,
2015-05-16 15:10:58 +00:00
/// A cached `metadata` call for this file.
///
/// This too is queried multiple times, and is *not* cached by the OS, as
/// it could easily change between invocations - but exa is so short-lived
/// it's better to just cache it.
pub metadata: fs::Metadata,
2015-05-16 15:10:58 +00:00
/// A reference to the directory that contains this file, if present.
///
/// Filenames that get passed in on the command-line directly will have no
/// parent directory reference - although they technically have one on the
/// filesystem, we'll never need to look at it, so it'll be `None`.
/// However, *directories* that get passed in will produce files that
/// contain a reference to it, which is used in certain operations (such
/// as looking up a file's Git status).
pub dir: Option<&'dir Dir>,
}
2015-05-12 14:38:12 +00:00
impl<'dir> File<'dir> {
2015-09-03 17:48:53 +00:00
2015-05-16 15:10:58 +00:00
/// Create a new `File` object from the given `Path`, inside the given
/// `Dir`, if appropriate.
2015-01-24 12:38:05 +00:00
///
/// This uses `symlink_metadata` instead of `metadata`, which doesn't
/// follow symbolic links.
2015-12-15 21:47:37 +00:00
pub fn from_path(path: &Path, parent: Option<&'dir Dir>) -> IOResult<File<'dir>> {
fs::symlink_metadata(path).map(|metadata| File::with_metadata(metadata, path, parent))
}
2014-11-25 20:50:23 +00:00
2015-05-16 17:16:35 +00:00
/// Create a new File object from the given metadata result, and other data.
pub fn with_metadata(metadata: fs::Metadata, path: &Path, parent: Option<&'dir Dir>) -> File<'dir> {
let filename = match path.components().next_back() {
Some(comp) => comp.as_os_str().to_string_lossy().to_string(),
None => String::new(),
};
File {
2015-09-03 17:48:53 +00:00
path: path.to_path_buf(),
dir: parent,
metadata: metadata,
ext: ext(path),
name: filename,
}
}
2015-05-16 15:10:58 +00:00
/// Whether this file is a directory on the filesystem.
pub fn is_directory(&self) -> bool {
2015-05-16 17:16:35 +00:00
self.metadata.is_dir()
}
2015-09-03 17:48:53 +00:00
/// If this file is a directory on the filesystem, then clone its
/// `PathBuf` for use in one of our own `Dir` objects, and read a list of
/// its contents.
///
/// Returns an IO error upon failure, but this shouldn't be used to check
/// if a `File` is a directory or not! For that, just use `is_directory()`.
2015-12-15 21:47:37 +00:00
pub fn to_dir(&self, scan_for_git: bool) -> IOResult<Dir> {
2015-09-03 09:51:59 +00:00
Dir::read_dir(&*self.path, scan_for_git)
}
2015-05-16 15:10:58 +00:00
/// Whether this file is a regular file on the filesystem - that is, not a
/// directory, a link, or anything else treated specially.
pub fn is_file(&self) -> bool {
2015-05-16 17:16:35 +00:00
self.metadata.is_file()
}
2015-05-16 15:10:58 +00:00
/// Whether this file is both a regular file *and* executable for the
/// current user. Executable files have different semantics than
/// executable directories, and so should be highlighted differently.
pub fn is_executable_file(&self) -> bool {
let bit = modes::USER_EXECUTE;
2015-05-16 17:16:35 +00:00
self.is_file() && (self.metadata.permissions().mode() & bit) == bit
}
2015-05-16 15:10:58 +00:00
/// Whether this file is a symlink on the filesystem.
pub fn is_link(&self) -> bool {
2015-05-16 17:16:35 +00:00
self.metadata.file_type().is_symlink()
}
/// Whether this file is a named pipe on the filesystem.
pub fn is_pipe(&self) -> bool {
self.metadata.file_type().is_fifo()
}
/// Whether this file is a char device on the filesystem.
pub fn is_char_device(&self) -> bool {
self.metadata.file_type().is_char_device()
}
/// Whether this file is a block device on the filesystem.
pub fn is_block_device(&self) -> bool {
self.metadata.file_type().is_block_device()
}
/// Whether this file is a socket on the filesystem.
pub fn is_socket(&self) -> bool {
self.metadata.file_type().is_socket()
}
2015-05-16 15:10:58 +00:00
/// Whether this file is a dotfile, based on its name. In Unix, file names
/// beginning with a dot represent system or configuration files, and
/// should be hidden by default.
pub fn is_dotfile(&self) -> bool {
2017-03-31 16:10:18 +00:00
self.name.starts_with('.')
}
/// Re-prefixes the path pointed to by this file, if it's a symlink, to
/// make it an absolute path that can be accessed from whichever
/// directory exa is being run from.
fn reorient_target_path(&self, path: &Path) -> PathBuf {
if path.is_absolute() {
path.to_path_buf()
}
else if let Some(dir) = self.dir {
dir.join(&*path)
}
else if let Some(parent) = self.path.parent() {
parent.join(&*path)
}
else {
self.path.join(&*path)
}
}
/// Again assuming this file is a symlink, follows that link and returns
/// the result of following it.
///
/// For a working symlink that the user is allowed to follow,
/// this will be the `File` object at the other end, which can then have
/// its name, colour, and other details read.
///
/// For a broken symlink, returns where the file *would* be, if it
/// existed. If this file cannot be read at all, returns the error that
/// we got when we tried to read it.
pub fn link_target(&self) -> FileTarget<'dir> {
// We need to be careful to treat the path actually pointed to by
// this file -- which could be absolute or relative -- to the path
// we actually look up and turn into a `File` -- which needs to be
// absolute to be accessible from any directory.
let display_path = match fs::read_link(&self.path) {
Ok(path) => path,
Err(e) => return FileTarget::Err(e),
};
let target_path = self.reorient_target_path(&*display_path);
2014-11-25 20:50:23 +00:00
// Use plain `metadata` instead of `symlink_metadata` - we *want* to
// follow links.
if let Ok(metadata) = fs::metadata(&target_path) {
FileTarget::Ok(File::with_metadata(metadata, &*display_path, None))
}
else {
FileTarget::Broken(display_path)
}
}
2015-05-16 15:10:58 +00:00
/// This file's number of hard links.
2015-01-24 12:38:05 +00:00
///
2015-05-16 15:10:58 +00:00
/// It also reports whether this is both a regular file, and a file with
/// multiple links. 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. Thus, it should get highlighted
/// more attentively.
2015-05-12 02:33:40 +00:00
pub fn links(&self) -> f::Links {
2015-06-16 23:49:29 +00:00
let count = self.metadata.nlink();
2015-05-12 02:33:40 +00:00
f::Links {
count: count,
multiple: self.is_file() && count > 1,
}
2015-01-24 12:38:05 +00:00
}
2015-05-16 15:10:58 +00:00
/// This file's inode.
2015-05-12 02:33:40 +00:00
pub fn inode(&self) -> f::Inode {
2015-06-16 23:49:29 +00:00
f::Inode(self.metadata.ino())
2015-01-24 12:38:05 +00:00
}
2015-05-16 15:10:58 +00:00
/// This file's number of filesystem blocks.
///
/// (Not the size of each block, which we don't actually report on)
2015-05-12 02:33:40 +00:00
pub fn blocks(&self) -> f::Blocks {
if self.is_file() || self.is_link() {
2015-06-16 23:49:29 +00:00
f::Blocks::Some(self.metadata.blocks())
2015-01-24 12:38:05 +00:00
}
else {
2015-05-12 02:33:40 +00:00
f::Blocks::None
2015-01-24 12:38:05 +00:00
}
}
2015-05-16 15:10:58 +00:00
/// The ID of the user that own this file.
2015-05-12 02:33:40 +00:00
pub fn user(&self) -> f::User {
2015-06-16 23:49:29 +00:00
f::User(self.metadata.uid())
2015-01-24 12:38:05 +00:00
}
2015-05-16 15:10:58 +00:00
/// The ID of the group that owns this file.
2015-05-12 02:33:40 +00:00
pub fn group(&self) -> f::Group {
2015-06-16 23:49:29 +00:00
f::Group(self.metadata.gid())
2015-01-24 12:38:05 +00:00
}
2017-05-19 08:27:38 +00:00
/// This files size, if its a regular file.
2015-01-24 12:38:05 +00:00
///
/// For directories, no size is given. Although they do have a size on
2017-05-19 08:27:38 +00:00
/// some filesystems, Ive never looked at one of those numbers and gained
/// any information from it. So its going to be hidden instead.
///
/// Block and character devices return their device IDs, because they
/// usually just have a file size of zero.
2015-05-12 02:33:40 +00:00
pub fn size(&self) -> f::Size {
if self.is_directory() {
2015-05-12 02:33:40 +00:00
f::Size::None
2014-11-25 20:50:23 +00:00
}
else if self.is_char_device() || self.is_block_device() {
let dev = self.metadata.rdev();
f::Size::DeviceIDs(f::DeviceIDs {
major: (dev / 256) as u8,
minor: (dev % 256) as u8,
})
}
2014-11-25 20:50:23 +00:00
else {
2015-05-16 17:16:35 +00:00
f::Size::Some(self.metadata.len())
}
}
pub fn modified_time(&self) -> f::Time {
f::Time(self.metadata.mtime())
}
pub fn created_time(&self) -> f::Time {
f::Time(self.metadata.ctime())
}
pub fn accessed_time(&self) -> f::Time {
f::Time(self.metadata.mtime())
}
2015-05-16 15:10:58 +00:00
/// This file's 'type'.
2015-01-24 12:38:05 +00:00
///
2015-05-16 15:10:58 +00:00
/// This is used in the leftmost column of the permissions column.
2015-01-24 12:38:05 +00:00
/// Although the file type can usually be guessed from the colour of the
/// file, `ls` puts this character there, so people will expect it.
pub fn type_char(&self) -> f::Type {
if self.is_file() {
2015-05-12 02:33:40 +00:00
f::Type::File
}
else if self.is_directory() {
2015-05-12 02:33:40 +00:00
f::Type::Directory
}
else if self.is_pipe() {
2015-05-12 02:33:40 +00:00
f::Type::Pipe
}
else if self.is_link() {
2015-05-12 02:33:40 +00:00
f::Type::Link
}
else if self.is_char_device() {
f::Type::CharDevice
}
else if self.is_block_device() {
f::Type::BlockDevice
}
else if self.is_socket() {
f::Type::Socket
}
else {
2015-05-12 02:33:40 +00:00
f::Type::Special
}
}
/// This files permissions, with flags for each bit.
2015-05-12 02:33:40 +00:00
pub fn permissions(&self) -> f::Permissions {
2015-05-16 17:16:35 +00:00
let bits = self.metadata.permissions().mode();
let has_bit = |bit| { bits & bit == bit };
2015-05-12 02:33:40 +00:00
f::Permissions {
user_read: has_bit(modes::USER_READ),
user_write: has_bit(modes::USER_WRITE),
user_execute: has_bit(modes::USER_EXECUTE),
group_read: has_bit(modes::GROUP_READ),
group_write: has_bit(modes::GROUP_WRITE),
group_execute: has_bit(modes::GROUP_EXECUTE),
other_read: has_bit(modes::OTHER_READ),
other_write: has_bit(modes::OTHER_WRITE),
other_execute: has_bit(modes::OTHER_EXECUTE),
}
}
2015-01-24 12:38:05 +00:00
2015-05-16 15:10:58 +00:00
/// Whether this file's extension is any of the strings that get passed in.
///
/// This will always return `false` if the file has no extension.
2015-05-09 15:10:26 +00:00
pub fn extension_is_one_of(&self, choices: &[&str]) -> bool {
match self.ext {
Some(ref ext) => choices.contains(&&ext[..]),
None => false,
}
}
2015-05-16 15:10:58 +00:00
/// Whether this file's name, including extension, is any of the strings
/// that get passed in.
2015-05-09 15:10:26 +00:00
pub fn name_is_one_of(&self, choices: &[&str]) -> bool {
choices.contains(&&self.name[..])
}
2015-05-16 15:10:58 +00:00
/// This file's Git status as two flags: one for staged changes, and the
/// other for unstaged changes.
///
/// This requires looking at the `git` field of this file's parent
/// directory, so will not work if this file has just been passed in on
/// the command line.
2015-05-12 02:33:40 +00:00
pub fn git_status(&self) -> f::Git {
2017-05-01 21:43:28 +00:00
use std::env::current_dir;
match self.dir {
2015-05-12 02:33:40 +00:00
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, self.is_directory())
},
}
}
2015-01-24 12:38:05 +00:00
}
impl<'a> AsRef<File<'a>> for File<'a> {
fn as_ref(&self) -> &File<'a> {
2017-03-31 16:09:32 +00:00
self
}
}
/// Extract an extension from a file path, if one is present, in lowercase.
2015-01-24 12:38:05 +00:00
///
/// The extension is the series of characters after the last dot. This
/// deliberately counts dotfiles, so the ".git" folder has the extension "git".
///
/// ASCII lowercasing is used because these extensions are only compared
/// against a pre-compiled list of extensions which are known to only exist
/// within ASCII, so it's alright.
fn ext(path: &Path) -> Option<String> {
2017-05-01 21:43:28 +00:00
use std::ascii::AsciiExt;
let name = match path.file_name() {
Some(f) => f.to_string_lossy().to_string(),
None => return None,
};
name.rfind('.').map(|p| name[p+1..].to_ascii_lowercase())
}
2015-01-25 13:04:15 +00:00
2015-06-08 20:33:39 +00:00
/// The result of following a symlink.
pub enum FileTarget<'dir> {
/// The symlink pointed at a file that exists.
Ok(File<'dir>),
/// The symlink pointed at a file that does not exist. Holds the path
/// where the file would be, if it existed.
Broken(PathBuf),
/// There was an IO error when following the link. This can happen if the
2017-05-07 14:14:06 +00:00
/// file isnt a link to begin with, but also if, say, we dont have
/// permission to follow it.
Err(IOError),
// Err is its own variant, instead of having the whole thing be inside an
// `IOResult`, because being unable to follow a symlink is not a serious
// error -- we just display the error message and move on.
}
impl<'dir> FileTarget<'dir> {
2017-05-07 14:14:06 +00:00
/// Whether this link doesnt lead to a file, for whatever reason. This
/// gets used to determine how to highlight the link in grid views.
pub fn is_broken(&self) -> bool {
2017-05-07 16:15:22 +00:00
match *self {
FileTarget::Ok(_) => false,
FileTarget::Broken(_) | FileTarget::Err(_) => true,
}
}
}
/// More readable aliases for the permission bits exposed by libc.
#[allow(trivial_numeric_casts)]
mod modes {
use libc;
pub type Mode = u32;
// The `libc::mode_t` types actual type varies, but the value returned
// from `metadata.permissions().mode()` is always `u32`.
pub const USER_READ: Mode = libc::S_IRUSR as Mode;
pub const USER_WRITE: Mode = libc::S_IWUSR as Mode;
pub const USER_EXECUTE: Mode = libc::S_IXUSR as Mode;
pub const GROUP_READ: Mode = libc::S_IRGRP as Mode;
pub const GROUP_WRITE: Mode = libc::S_IWGRP as Mode;
pub const GROUP_EXECUTE: Mode = libc::S_IXGRP as Mode;
pub const OTHER_READ: Mode = libc::S_IROTH as Mode;
pub const OTHER_WRITE: Mode = libc::S_IWOTH as Mode;
pub const OTHER_EXECUTE: Mode = libc::S_IXOTH as Mode;
}
#[cfg(test)]
mod test {
use super::ext;
use std::path::Path;
2015-01-25 13:04:15 +00:00
2015-01-25 13:47:07 +00:00
#[test]
fn extension() {
assert_eq!(Some("dat".to_string()), ext(Path::new("fester.dat")))
2015-01-25 13:47:07 +00:00
}
#[test]
fn dotfile() {
assert_eq!(Some("vimrc".to_string()), ext(Path::new(".vimrc")))
2015-01-25 13:47:07 +00:00
}
#[test]
fn no_extension() {
assert_eq!(None, ext(Path::new("jarlsberg")))
}
2015-01-25 13:04:15 +00:00
}