( )⚙ D10140 rhg: Add support for environment variables in config include paths

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10140

rhg: Add support for environment variables in config include paths
ClosedPublic

Authored by SimonSapin on Mar 9 2021, 4:40 AM.

Details

Reviewers
marmoute
Alphare
Group Reviewers
hg-reviewers
Commits
rHG91ab5190a3de: rhg: Add support for environment variables in config include paths
Summary

Some tests rely on this.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Mar 9 2021, 4:40 AM
baymax updated this revision to Diff 26199.Mar 9 2021, 8:40 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

marmoute accepted this revision.Mar 9 2021, 1:24 PM
Alphare accepted this revision.Mar 10 2021, 4:07 AM
SimonSapin edited the summary of this revision. (Show Details)Mar 12 2021, 5:07 PM
baymax updated this revision to Diff 26346.Mar 15 2021, 9:10 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

SimonSapin added a commit: rHG91ab5190a3de: rhg: Add support for environment variables in config include paths.Mar 16 2021, 5:47 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG91ab5190a3de: rhg: Add support for environment variables in config include paths (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 26346

rust/hg-core/src/config/layer.rs

let mut lines_iter = let mut lines_iter =
data.split(|b| *b == b'\n').enumerate().peekable(); data.split(|b| *b == b'\n').enumerate().peekable();
let mut section = b"".to_vec(); let mut section = b"".to_vec();
while let Some((index, bytes)) = lines_iter.next() { while let Some((index, bytes)) = lines_iter.next() {
let line = Some(index + 1); let line = Some(index + 1);
if let Some(m) = INCLUDE_RE.captures(&bytes) { if let Some(m) = INCLUDE_RE.captures(&bytes) {
let filename_bytes = &m[1]; let filename_bytes = &m[1];
let filename_bytes = crate::utils::expand_vars(filename_bytes);
// `Path::parent` only fails for the root directory, // `Path::parent` only fails for the root directory,
// which `src` can’t be since we’ve managed to open it as a // which `src` can’t be since we’ve managed to open it as a
// file. // file.
let dir = src let dir = src
.parent() .parent()
.expect("Path::parent fail on a file we’ve read"); .expect("Path::parent fail on a file we’ve read");
// `Path::join` with an absolute argument correctly ignores the // `Path::join` with an absolute argument correctly ignores the
// base path // base path

rust/hg-core/src/utils.rs

pub fn current_exe() -> Result<std::path::PathBuf, HgError> { pub fn current_exe() -> Result<std::path::PathBuf, HgError> {
std::env::current_exe().map_err(|error| HgError::IoError { std::env::current_exe().map_err(|error| HgError::IoError {
error, error,
context: IoErrorContext::CurrentExe, context: IoErrorContext::CurrentExe,
}) })
} }
/// Expand `$FOO` and `${FOO}` environment variables in the given byte string
pub fn expand_vars(s: &[u8]) -> std::borrow::Cow<[u8]> {
lazy_static::lazy_static! {
/// https://github.com/python/cpython/blob/3.9/Lib/posixpath.py#L301
/// The `x` makes whitespace ignored.
/// `-u` disables the Unicode flag, which makes `\w` like Python with the ASCII flag.
static ref VAR_RE: regex::bytes::Regex =
regex::bytes::Regex::new(r"(?x-u)
\$
(?:
(\w+)
|
\{
([^}]*)
\}
)
").unwrap();
}
VAR_RE.replace_all(s, |captures: &regex::bytes::Captures| {
let var_name = files::get_os_str_from_bytes(
captures
.get(1)
.or_else(|| captures.get(2))
.expect("either side of `|` must participate in match")
.as_bytes(),
);
std::env::var_os(var_name)
.map(files::get_bytes_from_os_str)
.unwrap_or_else(|| {
// Referencing an environment variable that does not exist.
// Leave the $FOO reference as-is.
captures[0].to_owned()
})
})
}
#[test]
fn test_expand_vars() {
// Modifying process-global state in a test isn’t great,
// but hopefully this won’t collide with anything.
std::env::set_var("TEST_EXPAND_VAR", "1");
assert_eq!(
expand_vars(b"before/$TEST_EXPAND_VAR/after"),
&b"before/1/after"[..]
);
assert_eq!(
expand_vars(b"before${TEST_EXPAND_VAR}${TEST_EXPAND_VAR}${TEST_EXPAND_VAR}after"),
&b"before111after"[..]
);
let s = b"before $SOME_LONG_NAME_THAT_WE_ASSUME_IS_NOT_AN_ACTUAL_ENV_VAR after";
assert_eq!(expand_vars(s), &s[..]);
}
pub(crate) enum MergeResult<V> { pub(crate) enum MergeResult<V> {
UseLeftValue, UseLeftValue,
UseRightValue, UseRightValue,
UseNewValue(V), UseNewValue(V),
} }
/// Return the union of the two given maps, /// Return the union of the two given maps,
/// calling `merge(key, left_value, right_value)` to resolve keys that exist in /// calling `merge(key, left_value, right_value)` to resolve keys that exist in

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

use same_file::is_same_file; use same_file::is_same_file;
use std::borrow::{Cow, ToOwned}; use std::borrow::{Cow, ToOwned};
use std::ffi::OsStr; use std::ffi::OsStr;
use std::fs::Metadata; use std::fs::Metadata;
use std::iter::FusedIterator; use std::iter::FusedIterator;
use std::ops::Deref; use std::ops::Deref;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
pub fn get_path_from_bytes(bytes: &[u8]) -> &Path { pub fn get_os_str_from_bytes(bytes: &[u8]) -> &OsStr {
let os_str; let os_str;
#[cfg(unix)] #[cfg(unix)]
{ {
use std::os::unix::ffi::OsStrExt; use std::os::unix::ffi::OsStrExt;
os_str = std::ffi::OsStr::from_bytes(bytes); os_str = std::ffi::OsStr::from_bytes(bytes);
} }
// TODO Handle other platforms // TODO Handle other platforms
// TODO: convert from WTF8 to Windows MBCS (ANSI encoding). // TODO: convert from WTF8 to Windows MBCS (ANSI encoding).
// Perhaps, the return type would have to be Result<PathBuf>. // Perhaps, the return type would have to be Result<PathBuf>.
os_str
}
Path::new(os_str) pub fn get_path_from_bytes(bytes: &[u8]) -> &Path {
Path::new(get_os_str_from_bytes(bytes))
} }
// TODO: need to convert from WTF8 to MBCS bytes on Windows. // TODO: need to convert from WTF8 to MBCS bytes on Windows.
// that's why Vec<u8> is returned. // that's why Vec<u8> is returned.
#[cfg(unix)] #[cfg(unix)]
pub fn get_bytes_from_path(path: impl AsRef<Path>) -> Vec<u8> { pub fn get_bytes_from_path(path: impl AsRef<Path>) -> Vec<u8> {
get_bytes_from_os_str(path.as_ref()) get_bytes_from_os_str(path.as_ref())
} }