mirror of
https://github.com/Llewellynvdm/exa.git
synced 2024-11-11 07:10:56 +00:00
040dbb2414
This commit adds a cache for Git repositories based on the path being queried. Its only immediate effect is that when you query the same directory twice (such as /testcases/git /testcases/git), it won’t need to check that the second one is a Git directory the second time. So, a minuscule optimisation for something you’d never do anyway? Wrong! It’s going to let us combine multiple entries over the same repository later, letting us use --tree and --recurse, because now Git scanning is behind a factory.
530 lines
17 KiB
Rust
530 lines
17 KiB
Rust
//! Files, and methods and fields to access their metadata.
|
||
|
||
use std::fs;
|
||
use std::io::Error as IOError;
|
||
use std::io::Result as IOResult;
|
||
use std::os::unix::fs::{MetadataExt, PermissionsExt, FileTypeExt};
|
||
use std::path::{Path, PathBuf};
|
||
|
||
use fs::dir::{Dir, DirOptions};
|
||
use fs::fields as f;
|
||
|
||
|
||
/// 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
|
||
/// once, have its file extension extracted at least once, and have its metadata
|
||
/// information queried at least once, so it makes sense to do all this at the
|
||
/// start and hold on to all the information.
|
||
pub struct File<'dir> {
|
||
|
||
/// The filename portion of this file's path, including the extension.
|
||
///
|
||
/// This is used to compare against certain filenames (such as checking if
|
||
/// it’s “Makefile” or something) and to highlight only the filename in
|
||
/// colour when displaying the path.
|
||
pub name: String,
|
||
|
||
/// The file’s name’s extension, if present, extracted from the name.
|
||
///
|
||
/// This is queried many times over, so it’s worth caching it.
|
||
pub ext: Option<String>,
|
||
|
||
/// 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,
|
||
|
||
/// 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,
|
||
|
||
/// 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 parent_dir: Option<&'dir Dir>,
|
||
}
|
||
|
||
impl<'dir> File<'dir> {
|
||
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);
|
||
|
||
debug!("Statting file {:?}", &path);
|
||
let metadata = fs::symlink_metadata(&path)?;
|
||
|
||
Ok(File { path, parent_dir, metadata, ext, name })
|
||
}
|
||
|
||
/// A file’s 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 it's alright.
|
||
fn ext(path: &Path) -> Option<String> {
|
||
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())
|
||
}
|
||
|
||
/// Whether this file is a directory on the filesystem.
|
||
pub fn is_directory(&self) -> bool {
|
||
self.metadata.is_dir()
|
||
}
|
||
|
||
/// 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()`.
|
||
pub fn to_dir(&self, options: DirOptions) -> IOResult<Dir> {
|
||
Dir::read_dir(self.path.clone(), options)
|
||
}
|
||
|
||
/// 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 {
|
||
self.metadata.is_file()
|
||
}
|
||
|
||
/// 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;
|
||
self.is_file() && (self.metadata.permissions().mode() & bit) == bit
|
||
}
|
||
|
||
/// Whether this file is a symlink on the filesystem.
|
||
pub fn is_link(&self) -> bool {
|
||
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 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.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);
|
||
|
||
// Use plain `metadata` instead of `symlink_metadata` - we *want* to
|
||
// follow links.
|
||
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 file's number of hard links.
|
||
///
|
||
/// 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.
|
||
pub fn links(&self) -> f::Links {
|
||
let count = self.metadata.nlink();
|
||
|
||
f::Links {
|
||
count: count,
|
||
multiple: self.is_file() && count > 1,
|
||
}
|
||
}
|
||
|
||
/// This file's inode.
|
||
pub fn inode(&self) -> f::Inode {
|
||
f::Inode(self.metadata.ino())
|
||
}
|
||
|
||
/// This file's number of filesystem blocks.
|
||
///
|
||
/// (Not the size of each block, which we don't actually report on)
|
||
pub fn blocks(&self) -> f::Blocks {
|
||
if self.is_file() || self.is_link() {
|
||
f::Blocks::Some(self.metadata.blocks())
|
||
}
|
||
else {
|
||
f::Blocks::None
|
||
}
|
||
}
|
||
|
||
/// The ID of the user that own this file.
|
||
pub fn user(&self) -> f::User {
|
||
f::User(self.metadata.uid())
|
||
}
|
||
|
||
/// The ID of the group that owns this file.
|
||
pub fn group(&self) -> f::Group {
|
||
f::Group(self.metadata.gid())
|
||
}
|
||
|
||
/// This file’s size, if it’s a regular file.
|
||
///
|
||
/// For directories, no size is given. Although they do have a size on
|
||
/// some filesystems, I’ve never looked at one of those numbers and gained
|
||
/// any information from it. So it’s going to be hidden instead.
|
||
///
|
||
/// Block and character devices return their device IDs, because they
|
||
/// usually just have a file size of zero.
|
||
pub fn size(&self) -> f::Size {
|
||
if self.is_directory() {
|
||
f::Size::None
|
||
}
|
||
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,
|
||
})
|
||
}
|
||
else {
|
||
f::Size::Some(self.metadata.len())
|
||
}
|
||
}
|
||
|
||
/// This file’s last modified timestamp.
|
||
pub fn modified_time(&self) -> f::Time {
|
||
f::Time {
|
||
seconds: self.metadata.mtime(),
|
||
nanoseconds: self.metadata.mtime_nsec()
|
||
}
|
||
}
|
||
|
||
/// This file’s created timestamp.
|
||
pub fn created_time(&self) -> f::Time {
|
||
f::Time {
|
||
seconds: self.metadata.ctime(),
|
||
nanoseconds: self.metadata.ctime_nsec()
|
||
}
|
||
}
|
||
|
||
/// This file’s last accessed timestamp.
|
||
pub fn accessed_time(&self) -> f::Time {
|
||
f::Time {
|
||
seconds: self.metadata.atime(),
|
||
nanoseconds: self.metadata.atime_nsec()
|
||
}
|
||
}
|
||
|
||
/// This file’s ‘type’.
|
||
///
|
||
/// 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() {
|
||
f::Type::File
|
||
}
|
||
else if self.is_directory() {
|
||
f::Type::Directory
|
||
}
|
||
else if self.is_pipe() {
|
||
f::Type::Pipe
|
||
}
|
||
else if self.is_link() {
|
||
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 {
|
||
f::Type::Special
|
||
}
|
||
}
|
||
|
||
/// This file’s permissions, with flags for each bit.
|
||
pub fn permissions(&self) -> f::Permissions {
|
||
let bits = self.metadata.mode();
|
||
let has_bit = |bit| { bits & bit == bit };
|
||
|
||
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),
|
||
}
|
||
}
|
||
|
||
/// 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.
|
||
pub fn extension_is_one_of(&self, choices: &[&str]) -> bool {
|
||
match self.ext {
|
||
Some(ref ext) => choices.contains(&&ext[..]),
|
||
None => false,
|
||
}
|
||
}
|
||
|
||
/// Whether this file's name, including extension, is any of the strings
|
||
/// that get passed in.
|
||
pub fn name_is_one_of(&self, choices: &[&str]) -> bool {
|
||
choices.contains(&&self.name[..])
|
||
}
|
||
|
||
/// 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.
|
||
pub fn git_status(&self) -> f::Git {
|
||
use std::env::current_dir;
|
||
|
||
match self.parent_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, self.is_directory())
|
||
},
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
impl<'a> AsRef<File<'a>> for File<'a> {
|
||
fn as_ref(&self) -> &File<'a> {
|
||
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
|
||
/// file isn’t a link to begin with, but also if, say, we don’t 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> {
|
||
|
||
/// Whether this link doesn’t 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 {
|
||
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` type’s 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;
|
||
|
||
#[test]
|
||
fn extension() {
|
||
assert_eq!(Some("dat".to_string()), File::ext(Path::new("fester.dat")))
|
||
}
|
||
|
||
#[test]
|
||
fn dotfile() {
|
||
assert_eq!(Some("vimrc".to_string()), File::ext(Path::new(".vimrc")))
|
||
}
|
||
|
||
#[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("/")))
|
||
}
|
||
}
|