This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10890

rust: remove dead utils module
ClosedPublic

Authored by Alphare on Jun 21 2021, 11:29 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG69910b3686fa: rust: remove dead utils module
Summary

This was introduced a while back while not being imported anywhere in the
module system. How pertinent this Facebook module was to the codebase was
debatable at the time, nowadays with the Rust VFS layer having laid its
foundations, it is clear that we should drop it.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

Alphare created this revision.Jun 21 2021, 11:29 AM
pulkit accepted this revision.Jun 23 2021, 10:00 AM
This revision is now accepted and ready to land.Jun 23 2021, 10:00 AM
Alphare added a commit: rHG69910b3686fa: rust: remove dead utils module.Jun 24 2021, 4:18 AM
Closed by commit rHG69910b3686fa: rust: remove dead utils module (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
DMrust/hg-core/src/utils/path.rs (314 lines)

Diff 28666

rust/hg-core/src/utils/path.rs

  • This file was deleted.
/*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This software may be used and distributed according to the terms of the
* GNU General Public License version 2.
*/
//! Path-related utilities.
use std::env;
#[cfg(not(unix))]
use std::fs::rename;
use std::fs::{self, remove_file as fs_remove_file};
use std::io::{self, ErrorKind};
use std::path::{Component, Path, PathBuf};
use anyhow::Result;
#[cfg(not(unix))]
use tempfile::Builder;
/// Normalize a canonicalized Path for display.
///
/// This removes the UNC prefix `\\?\` on Windows.
pub fn normalize_for_display(path: &str) -> &str {
if cfg!(windows) && path.starts_with(r"\\?\") {
&path[4..]
} else {
path
}
}
/// Similar to [`normalize_for_display`]. But work on bytes.
pub fn normalize_for_display_bytes(path: &[u8]) -> &[u8] {
if cfg!(windows) && path.starts_with(br"\\?\") {
&path[4..]
} else {
path
}
}
/// Return the absolute and normalized path without accessing the filesystem.
///
/// Unlike [`fs::canonicalize`], do not follow symlinks.
///
/// This function does not access the filesystem. Therefore it can behave
/// differently from the kernel or other library functions in corner cases.
/// For example:
///
/// - On some systems with symlink support, `foo/bar/..` and `foo` can be
/// different as seen by the kernel, if `foo/bar` is a symlink. This function
/// always returns `foo` in this case.
/// - On Windows, the official normalization rules are much more complicated.
/// See https://github.com/rust-lang/rust/pull/47363#issuecomment-357069527.
/// For example, this function cannot translate "drive relative" path like
/// "X:foo" to an absolute path.
///
/// Return an error if `std::env::current_dir()` fails or if this function
/// fails to produce an absolute path.
pub fn absolute(path: impl AsRef<Path>) -> io::Result<PathBuf> {
let path = path.as_ref();
let path = if path.is_absolute() {
path.to_path_buf()
} else {
std::env::current_dir()?.join(path)
};
if !path.is_absolute() {
return Err(io::Error::new(
io::ErrorKind::Other,
format!("cannot get absoltue path from {:?}", path),
));
}
let mut result = PathBuf::new();
for component in path.components() {
match component {
Component::Normal(_)
| Component::RootDir
| Component::Prefix(_) => {
result.push(component);
}
Component::ParentDir => {
result.pop();
}
Component::CurDir => (),
}
}
Ok(result)
}
/// Remove the file pointed by `path`.
#[cfg(unix)]
pub fn remove_file<P: AsRef<Path>>(path: P) -> Result<()> {
fs_remove_file(path)?;
Ok(())
}
/// Remove the file pointed by `path`.
///
/// On Windows, removing a file can fail for various reasons, including if the
/// file is memory mapped. This can happen when the repository is accessed
/// concurrently while a background task is trying to remove a packfile. To
/// solve this, we can rename the file before trying to remove it.
/// If the remove operation fails, a future repack will clean it up.
#[cfg(not(unix))]
pub fn remove_file<P: AsRef<Path>>(path: P) -> Result<()> {
let path = path.as_ref();
let extension = path
.extension()
.and_then(|ext| ext.to_str())
.map_or(".to-delete".to_owned(), |ext| ".".to_owned() + ext + "-tmp");
let dest_path = Builder::new()
.prefix("")
.suffix(&extension)
.rand_bytes(8)
.tempfile_in(path.parent().unwrap())?
.into_temp_path();
rename(path, &dest_path)?;
// Ignore errors when removing the file, it will be cleaned up at a later
// time.
let _ = fs_remove_file(dest_path);
Ok(())
}
/// Create the directory and ignore failures when a directory of the same name
/// already exists.
pub fn create_dir(path: impl AsRef<Path>) -> io::Result<()> {
match fs::create_dir(path.as_ref()) {
Ok(()) => Ok(()),
Err(e) => {
if e.kind() == ErrorKind::AlreadyExists && path.as_ref().is_dir() {
Ok(())
} else {
Err(e)
}
}
}
}
/// Expand the user's home directory and any environment variables references
/// in the given path.
///
/// This function is designed to emulate the behavior of Mercurial's
/// `util.expandpath` function, which in turn uses Python's
/// `os.path.expand{user,vars}` functions. This results in behavior that is
/// notably different from the default expansion behavior of the `shellexpand`
/// crate. In particular:
///
/// - If a reference to an environment variable is missing or invalid, the
/// reference is left unchanged in the resulting path rather than emitting an
/// error.
///
/// - Home directory expansion explicitly happens after environment variable
/// expansion, meaning that if an environment variable is expanded into a
/// string starting with a tilde (`~`), the tilde will be expanded into the
/// user's home directory.
pub fn expand_path(path: impl AsRef<str>) -> PathBuf {
expand_path_impl(path.as_ref(), |k| env::var(k).ok(), dirs::home_dir)
}
/// Same as `expand_path` but explicitly takes closures for environment
/// variable and home directory lookup for the sake of testability.
fn expand_path_impl<E, H>(path: &str, getenv: E, homedir: H) -> PathBuf
where
E: FnMut(&str) -> Option<String>,
H: FnOnce() -> Option<PathBuf>,
{
// The shellexpand crate does not expand Windows environment variables
// like `%PROGRAMDATA%`. We'd like to expand them too. So let's do some
// pre-processing.
//
// XXX: Doing this preprocessing has the unfortunate side-effect that
// if an environment variable fails to expand on Windows, the resulting
// string will contain a UNIX-style environment variable reference.
//
// e.g., "/foo/%MISSING%/bar" will expand to "/foo/${MISSING}/bar"
//
// The current approach is good enough for now, but likely needs to
// be improved later for correctness.
let path = {
let mut new_path = String::new();
let mut is_starting = true;
for ch in path.chars() {
if ch == '%' {
if is_starting {
new_path.push_str("${");
} else {
new_path.push('}');
}
is_starting = !is_starting;
} else if cfg!(windows) && ch == '/' {
// Only on Windows, change "/" to "\" automatically.
// This makes sure "%include /foo" works as expected.
new_path.push('\\')
} else {
new_path.push(ch);
}
}
new_path
};
let path = shellexpand::env_with_context_no_errors(&path, getenv);
shellexpand::tilde_with_context(&path, homedir)
.as_ref()
.into()
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs::File;
use tempfile::TempDir;
#[cfg(windows)]
mod windows {
use super::*;
#[test]
fn test_absolute_fullpath() {
assert_eq!(absolute("C:/foo").unwrap(), Path::new("C:\\foo"));
assert_eq!(
absolute("x:\\a/b\\./.\\c").unwrap(),
Path::new("x:\\a\\b\\c")
);
assert_eq!(
absolute("y:/a/b\\../..\\c\\../d\\./.").unwrap(),
Path::new("y:\\d")
);
assert_eq!(
absolute("z:/a/b\\../..\\../..\\..").unwrap(),
Path::new("z:\\")
);
}
}
#[cfg(unix)]
mod unix {
use super::*;
#[test]
fn test_absolute_fullpath() {
assert_eq!(
absolute("/a/./b\\c/../d/.").unwrap(),
Path::new("/a/d")
);
assert_eq!(absolute("/a/../../../../b").unwrap(), Path::new("/b"));
assert_eq!(absolute("/../../..").unwrap(), Path::new("/"));
assert_eq!(absolute("/../../../").unwrap(), Path::new("/"));
assert_eq!(
absolute("//foo///bar//baz").unwrap(),
Path::new("/foo/bar/baz")
);
assert_eq!(absolute("//").unwrap(), Path::new("/"));
}
}
#[test]
fn test_create_dir_non_exist() -> Result<()> {
let tempdir = TempDir::new()?;
let mut path = tempdir.path().to_path_buf();
path.push("dir");
create_dir(&path)?;
assert!(path.is_dir());
Ok(())
}
#[test]
fn test_create_dir_exist() -> Result<()> {
let tempdir = TempDir::new()?;
let mut path = tempdir.path().to_path_buf();
path.push("dir");
create_dir(&path)?;
assert!(&path.is_dir());
create_dir(&path)?;
assert!(&path.is_dir());
Ok(())
}
#[test]
fn test_create_dir_file_exist() -> Result<()> {
let tempdir = TempDir::new()?;
let mut path = tempdir.path().to_path_buf();
path.push("dir");
File::create(&path)?;
let err = create_dir(&path).unwrap_err();
assert_eq!(err.kind(), ErrorKind::AlreadyExists);
Ok(())
}
#[test]
fn test_path_expansion() {
fn getenv(key: &str) -> Option<String> {
match key {
"foo" => Some("~/a".into()),
"bar" => Some("b".into()),
_ => None,
}
}
fn homedir() -> Option<PathBuf> {
Some(PathBuf::from("/home/user"))
}
let path = "$foo/${bar}/$baz";
let expected = PathBuf::from("/home/user/a/b/$baz");
assert_eq!(expand_path_impl(&path, getenv, homedir), expected);
}
}