use std::path::Path;
#[derive(Debug)]
pub struct FileId(same_file::Handle);
impl FileId {
fn len(&self) -> Option<u64> {
self.0.as_file().metadata().ok().map(|m| m.len())
}
}
impl PartialEq for FileId {
fn eq(&self, other: &FileId) -> bool {
let len = self.len();
self.0 == other.0 && len.is_some() && len == other.len()
}
}
impl FileId {
#[must_use]
pub fn of(path: &Path) -> Option<FileId> {
let meta = std::fs::metadata(path).ok()?;
if !meta.is_file() && !meta.is_dir() {
return None;
}
same_file::Handle::from_path(path).ok().map(FileId)
}
}
impl FileId {
#[must_use]
pub fn stdout() -> Option<FileId> {
#[cfg(any(unix, windows))]
{
#[cfg(unix)]
let owned = {
use std::os::fd::AsFd;
std::io::stdout().as_fd().try_clone_to_owned().ok()?
};
#[cfg(windows)]
let owned = {
use std::os::windows::io::AsHandle;
std::io::stdout().as_handle().try_clone_to_owned().ok()?
};
let file = std::fs::File::from(owned);
if !file.metadata().ok()?.is_file() {
return None;
}
same_file::Handle::from_file(file).ok().map(FileId)
}
#[cfg(not(any(unix, windows)))]
{
None
}
}
}
#[must_use]
pub fn is_same_file(a: &Path, b: &Path) -> bool {
match (FileId::of(a), FileId::of(b)) {
(Some(a), Some(b)) => a == b,
_ => false,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn same_and_different_files() {
let dir = tempfile::tempdir().unwrap();
let a = dir.path().join("a");
let b = dir.path().join("b");
std::fs::write(&a, "x").unwrap();
std::fs::write(&b, "x").unwrap();
assert!(is_same_file(&a, &a));
assert!(is_same_file(&a, &dir.path().join(".").join("a")));
assert!(!is_same_file(&a, &b));
}
#[test]
fn a_missing_file_is_never_the_same() {
let dir = tempfile::tempdir().unwrap();
let a = dir.path().join("a");
let gone = dir.path().join("gone");
std::fs::write(&a, "x").unwrap();
assert!(FileId::of(&gone).is_none());
assert!(!is_same_file(&a, &gone));
assert!(!is_same_file(&gone, &gone));
}
#[test]
fn different_files_of_different_length_never_match() {
let dir = tempfile::tempdir().unwrap();
let a = dir.path().join("a");
let b = dir.path().join("b");
std::fs::write(&a, "x").unwrap();
std::fs::write(&b, "xyz").unwrap();
assert!(!is_same_file(&a, &b));
let before = FileId::of(&a).unwrap();
std::fs::write(&a, "longer").unwrap();
assert_eq!(before, FileId::of(&a).unwrap());
}
#[test]
fn stdout_identity_leaves_stdout_open() {
let _ = FileId::stdout();
let _ = FileId::stdout();
#[cfg(unix)]
{
use std::os::fd::AsFd;
assert!(std::io::stdout().as_fd().try_clone_to_owned().is_ok());
}
std::io::Write::flush(&mut std::io::stdout()).unwrap();
}
#[cfg(unix)]
#[test]
fn hard_links_and_symlinks_are_the_same_file() {
let dir = tempfile::tempdir().unwrap();
let a = dir.path().join("a");
std::fs::write(&a, "x").unwrap();
std::fs::hard_link(&a, dir.path().join("h")).unwrap();
std::os::unix::fs::symlink("a", dir.path().join("s")).unwrap();
assert!(is_same_file(&a, &dir.path().join("h")));
assert!(is_same_file(&a, &dir.path().join("s")));
}
}