This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11907

rhg: Add support for ui.ignore and ui.ignore.* config
ClosedPublic

Authored by SimonSapin on Dec 13 2021, 8:04 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG4a983b69e519: rhg: Add support for ui.ignore and ui.ignore.* config
Summary

This fixes some but not all failures in tests/test-hgignore.t when running
with rhg status enabled.

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.Dec 13 2021, 8:04 AM
SimonSapin added a comment.Dec 13 2021, 8:06 AM

This is D11890 again, with additional changes for compatibility with older rustc versions: https://phab.mercurial-scm.org/D11890?vs=31408&id=31415#toc

Alphare accepted this revision.Dec 13 2021, 8:33 AM
Alphare added a subscriber: Alphare.

Thanks

This revision is now accepted and ready to land.Dec 13 2021, 8:33 AM
SimonSapin added a commit: rHG4a983b69e519: rhg: Add support for ui.ignore and ui.ignore.* config.Dec 13 2021, 8:35 AM
Closed by commit rHG4a983b69e519: rhg: Add support for ui.ignore and ui.ignore.* config (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 31445

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

/// Returns whether any key is defined in the given section /// Returns whether any key is defined in the given section
pub fn has_non_empty_section(&self, section: &[u8]) -> bool { pub fn has_non_empty_section(&self, section: &[u8]) -> bool {
self.layers self.layers
.iter() .iter()
.any(|layer| layer.has_non_empty_section(section)) .any(|layer| layer.has_non_empty_section(section))
} }
/// Yields (key, value) pairs for everything in the given section
pub fn iter_section<'a>(
&'a self,
section: &'a [u8],
) -> impl Iterator<Item = (&[u8], &[u8])> + 'a {
// TODO: Use `Iterator`’s `.peekable()` when its `peek_mut` is
// available:
// https://doc.rust-lang.org/nightly/std/iter/struct.Peekable.html#method.peek_mut
struct Peekable<I: Iterator> {
iter: I,
/// Remember a peeked value, even if it was None.
peeked: Option<Option<I::Item>>,
}
impl<I: Iterator> Peekable<I> {
fn new(iter: I) -> Self {
Self { iter, peeked: None }
}
fn next(&mut self) {
self.peeked = None
}
fn peek_mut(&mut self) -> Option<&mut I::Item> {
let iter = &mut self.iter;
self.peeked.get_or_insert_with(|| iter.next()).as_mut()
}
}
// Deduplicate keys redefined in multiple layers
let mut keys_already_seen = HashSet::new();
let mut key_is_new =
move |&(key, _value): &(&'a [u8], &'a [u8])| -> bool {
keys_already_seen.insert(key)
};
// This is similar to `flat_map` + `filter_map`, except with a single
// closure that owns `key_is_new` (and therefore the
// `keys_already_seen` set):
let mut layer_iters = Peekable::new(
self.layers
.iter()
.rev()
.map(move |layer| layer.iter_section(section)),
);
std::iter::from_fn(move || loop {
if let Some(pair) = layer_iters.peek_mut()?.find(&mut key_is_new) {
return Some(pair);
} else {
layer_iters.next();
}
})
}
/// Get raw values bytes from all layers (even untrusted ones) in order /// Get raw values bytes from all layers (even untrusted ones) in order
/// of precedence. /// of precedence.
#[cfg(test)] #[cfg(test)]
fn get_all(&self, section: &[u8], item: &[u8]) -> Vec<&[u8]> { fn get_all(&self, section: &[u8], item: &[u8]) -> Vec<&[u8]> {
let mut res = vec![]; let mut res = vec![];
for layer in self.layers.iter().rev() { for layer in self.layers.iter().rev() {
if let Some(v) = layer.get(&section, &item) { if let Some(v) = layer.get(&section, &item) {
res.push(v.bytes.as_ref()); res.push(v.bytes.as_ref());

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

/// Returns the keys defined in the given section /// Returns the keys defined in the given section
pub fn iter_keys(&self, section: &[u8]) -> impl Iterator<Item = &[u8]> { pub fn iter_keys(&self, section: &[u8]) -> impl Iterator<Item = &[u8]> {
self.sections self.sections
.get(section) .get(section)
.into_iter() .into_iter()
.flat_map(|section| section.keys().map(|vec| &**vec)) .flat_map(|section| section.keys().map(|vec| &**vec))
} }
/// Returns the (key, value) pairs defined in the given section
pub fn iter_section<'layer>(
&'layer self,
section: &[u8],
) -> impl Iterator<Item = (&'layer [u8], &'layer [u8])> {
self.sections
.get(section)
.into_iter()
.flat_map(|section| section.iter().map(|(k, v)| (&**k, &*v.bytes)))
}
/// Returns whether any key is defined in the given section /// Returns whether any key is defined in the given section
pub fn has_non_empty_section(&self, section: &[u8]) -> bool { pub fn has_non_empty_section(&self, section: &[u8]) -> bool {
self.sections self.sections
.get(section) .get(section)
.map_or(false, |section| !section.is_empty()) .map_or(false, |section| !section.is_empty())
} }
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {

rust/rhg/src/commands/status.rs

use hg::dirstate::TruncatedTimestamp; use hg::dirstate::TruncatedTimestamp;
use hg::dirstate::RANGE_MASK_31BIT; use hg::dirstate::RANGE_MASK_31BIT;
use hg::errors::{HgError, IoResultExt}; use hg::errors::{HgError, IoResultExt};
use hg::lock::LockError; use hg::lock::LockError;
use hg::manifest::Manifest; use hg::manifest::Manifest;
use hg::matchers::AlwaysMatcher; use hg::matchers::AlwaysMatcher;
use hg::repo::Repo; use hg::repo::Repo;
use hg::utils::files::get_bytes_from_os_string; use hg::utils::files::get_bytes_from_os_string;
use hg::utils::files::get_path_from_bytes;
use hg::utils::hg_path::{hg_path_to_path_buf, HgPath}; use hg::utils::hg_path::{hg_path_to_path_buf, HgPath};
use hg::{HgPathCow, StatusOptions}; use hg::{HgPathCow, StatusOptions};
use log::{info, warn}; use log::{info, warn};
use std::io; use std::io;
use std::path::PathBuf;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Show changed files in the working directory Show changed files in the working directory
This is a pure Rust version of `hg status`. This is a pure Rust version of `hg status`.
Some options might be missing, check the list below. Some options might be missing, check the list below.
"; ";
// we're currently supporting file systems with exec flags only // we're currently supporting file systems with exec flags only
// anyway // anyway
check_exec: true, check_exec: true,
list_clean: display_states.clean, list_clean: display_states.clean,
list_unknown: display_states.unknown, list_unknown: display_states.unknown,
list_ignored: display_states.ignored, list_ignored: display_states.ignored,
collect_traversed_dirs: false, collect_traversed_dirs: false,
}; };
let ignore_file = repo.working_directory_vfs().join(".hgignore"); // TODO hardcoded
let (mut ds_status, pattern_warnings) = dmap.status( let (mut ds_status, pattern_warnings) = dmap.status(
&AlwaysMatcher, &AlwaysMatcher,
repo.working_directory_path().to_owned(), repo.working_directory_path().to_owned(),
vec![ignore_file], ignore_files(repo, config),
options, options,
)?; )?;
if !pattern_warnings.is_empty() { if !pattern_warnings.is_empty() {
warn!("Pattern warnings: {:?}", &pattern_warnings); warn!("Pattern warnings: {:?}", &pattern_warnings);
} }
if !ds_status.bad.is_empty() { if !ds_status.bad.is_empty() {
warn!("Bad matches {:?}", &(ds_status.bad)) warn!("Bad matches {:?}", &(ds_status.bad))
Err(LockError::Other(error)) => { Err(LockError::Other(error)) => {
// Report other I/O errors // Report other I/O errors
Err(error)? Err(error)?
} }
} }
Ok(()) Ok(())
} }
fn ignore_files(repo: &Repo, config: &Config) -> Vec<PathBuf> {
let mut ignore_files = Vec::new();
let repo_ignore = repo.working_directory_vfs().join(".hgignore");
if repo_ignore.exists() {
ignore_files.push(repo_ignore)
}
for (key, value) in config.iter_section(b"ui") {
if key == b"ignore" || key.starts_with(b"ignore.") {
let path = get_path_from_bytes(value);
// TODO:!expand "~/" and environment variable here, like Python
// does with `os.path.expanduser` and `os.path.expandvars`
let joined = repo.working_directory_path().join(path);
ignore_files.push(joined);
}
}
ignore_files
}
// Probably more elegant to use a Deref or Borrow trait rather than // Probably more elegant to use a Deref or Borrow trait rather than
// harcode HgPathBuf, but probably not really useful at this point // harcode HgPathBuf, but probably not really useful at this point
fn display_status_paths( fn display_status_paths(
ui: &Ui, ui: &Ui,
repo: &Repo, repo: &Repo,
config: &Config, config: &Config,
no_status: bool, no_status: bool,
paths: &mut [HgPathCow], paths: &mut [HgPathCow],