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
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

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 26423

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())
} }