exa/src/fs/file.rs

510 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 files 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 files name is extracted, the path needs to be kept
/// around, as certain operations involve looking up the files absolute
/// location (such as searching for compiled files) or using its original
/// path (following a symlink).
pub path: PathBuf,
2015-05-16 15:10:58 +00:00
/// A cached `metadata` (`stat`) 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 any.
2015-05-16 15:10:58 +00:00
///
/// Filenames that get passed in on the command-line directly will have no
/// parent directory reference — although they technically have one on the
/// filesystem, well never need to look at it, so itll be `None`.
2015-05-16 15:10:58 +00:00
/// 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 compiled files).
pub parent_dir: Option<&'dir Dir>,
}
2014-11-25 20:50:23 +00:00
impl<'dir> File<'dir> {
2017-06-29 12:17:26 +00:00
pub fn new<PD, FN>(path: PathBuf, parent_dir: PD, filename: FN) -> IOResult<File<'dir>>
where PD: Into<Option<&'dir Dir>>,
FN: Into<Option<String>>
{
let parent_dir = parent_dir.into();
let name = filename.into().unwrap_or_else(|| File::filename(&path));
let ext = File::ext(&path);
2017-08-26 22:53:47 +00:00
debug!("Statting file {:?}", &path);
let metadata = fs::symlink_metadata(&path)?;
2017-06-29 12:17:26 +00:00
Ok(File { path, parent_dir, metadata, ext, name })
}
/// A files name is derived from its string. This needs to handle directories
/// such as `/` or `..`, which have no `file_name` component. So instead, just
/// use the last component as the name.
pub fn filename(path: &Path) -> String {
if let Some(back) = path.components().next_back() {
back.as_os_str().to_string_lossy().to_string()
}
else {
// use the path as fallback
error!("Path {:?} has no last component", path);
path.display().to_string()
}
}
/// Extract an extension from a file path, if one is present, in lowercase.
///
/// 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 its alright.
fn ext(path: &Path) -> Option<String> {
2018-02-01 06:52:01 +00:00
#[allow(unused)]
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-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` values, and read a list of
2015-09-03 17:48:53 +00:00
/// its contents.
///
/// Returns an IO error upon failure, but this shouldnt be used to check
2015-09-03 17:48:53 +00:00
/// if a `File` is a directory or not! For that, just use `is_directory()`.
pub fn to_dir(&self) -> IOResult<Dir> {
Dir::read_dir(self.path.clone())
}
/// Whether this file is a regular file on the filesystem — that is, not a
2015-05-16 15:10:58 +00:00
/// 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. An executable file has a different purpose from an
/// executable directory, so they 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()
}
/// Re-prefixes the path pointed to by this file, if its 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.parent_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.
debug!("Reading link {:?}", &self.path);
let path = match fs::read_link(&self.path) {
Ok(p) => p,
Err(e) => return FileTarget::Err(e),
};
let absolute_path = self.reorient_target_path(&path);
2014-11-25 20:50:23 +00:00
// Use plain `metadata` instead of `symlink_metadata` - we *want* to
// follow links.
2017-08-19 11:22:17 +00:00
match fs::metadata(&absolute_path) {
Ok(metadata) => {
let ext = File::ext(&path);
let name = File::filename(&path);
FileTarget::Ok(File { parent_dir: None, path, ext, metadata, name })
}
Err(e) => {
error!("Error following link {:?}: {:#?}", &path, e);
FileTarget::Broken(path)
}
}
}
/// This files 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 come across directories and other types
2015-05-16 15:10:58 +00:00
/// 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())
}
}
/// This files last modified timestamp.
pub fn modified_time(&self) -> f::Time {
f::Time {
seconds: self.metadata.mtime(),
nanoseconds: self.metadata.mtime_nsec()
}
}
/// This files created timestamp.
pub fn created_time(&self) -> f::Time {
f::Time {
seconds: self.metadata.ctime(),
nanoseconds: self.metadata.ctime_nsec()
}
}
/// This files last accessed timestamp.
pub fn accessed_time(&self) -> f::Time {
f::Time {
seconds: self.metadata.atime(),
nanoseconds: self.metadata.atime_nsec()
}
}
/// This files type.
2015-01-24 12:38:05 +00:00
///
/// This is used a the leftmost character of the permissions column.
/// The file type can usually be guessed from the colour of the file, but
/// ls puts this character there.
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 {
let bits = self.metadata.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),
sticky: has_bit(modes::STICKY),
setgid: has_bit(modes::SETGID),
setuid: has_bit(modes::SETUID),
}
}
2015-01-24 12:38:05 +00:00
/// Whether this files extension is any of the strings that get passed in.
2015-05-16 15:10:58 +00:00
///
/// 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-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
}
}
/// 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;
pub const STICKY: Mode = libc::S_ISVTX as Mode;
pub const SETGID: Mode = libc::S_ISGID as Mode;
pub const SETUID: Mode = libc::S_ISUID as Mode;
}
#[cfg(test)]
mod ext_test {
use super::File;
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()), File::ext(Path::new("fester.dat")))
2015-01-25 13:47:07 +00:00
}
#[test]
fn dotfile() {
assert_eq!(Some("vimrc".to_string()), File::ext(Path::new(".vimrc")))
2015-01-25 13:47:07 +00:00
}
#[test]
fn no_extension() {
assert_eq!(None, File::ext(Path::new("jarlsberg")))
}
}
#[cfg(test)]
mod filename_test {
use super::File;
use std::path::Path;
#[test]
fn file() {
assert_eq!("fester.dat", File::filename(Path::new("fester.dat")))
}
#[test]
fn no_path() {
assert_eq!("foo.wha", File::filename(Path::new("/var/cache/foo.wha")))
}
#[test]
fn here() {
assert_eq!(".", File::filename(Path::new(".")))
}
#[test]
fn there() {
assert_eq!("..", File::filename(Path::new("..")))
}
#[test]
fn everywhere() {
assert_eq!("..", File::filename(Path::new("./..")))
}
#[test]
fn topmost() {
assert_eq!("/", File::filename(Path::new("/")))
}
2015-01-25 13:04:15 +00:00
}