( )⚙ D10110 rhg: Align config file parse error formatting with Python

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10110

rhg: Align config file parse error formatting with Python
ClosedPublic

Authored by SimonSapin on Mar 4 2021, 6:11 AM.

Details

Reviewers
Alphare
marmoute
Group Reviewers
hg-reviewers
Commits
rHG3d692e724d06: rhg: Align config file parse error formatting with Python
Summary

Differences can cause tests to fail

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 4 2021, 6:11 AM
baymax updated this revision to Diff 26077.Mar 4 2021, 8:00 AM

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

Alphare accepted this revision.Mar 5 2021, 4:03 AM
SimonSapin updated this revision to Diff 26169.Mar 9 2021, 4:39 AM
baymax updated this revision to Diff 26188.Mar 9 2021, 8:39 AM

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

marmoute accepted this revision.Mar 9 2021, 1:07 PM
SimonSapin edited the summary of this revision. (Show Details)Mar 12 2021, 5:06 PM
SimonSapin updated this revision to Diff 26290.
SimonSapin added a commit: rHG3d692e724d06: rhg: Align config file parse error formatting with Python.Mar 16 2021, 5:45 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG3d692e724d06: rhg: Align config file parse error formatting with Python (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 26412

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

// layer.rs // layer.rs
// //
// Copyright 2020 // Copyright 2020
// Valentin Gatien-Baron, // Valentin Gatien-Baron,
// Raphaël Gomès <rgomes@octobus.net> // Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::errors::{HgError, IoResultExt}; use crate::errors::{HgError, IoResultExt};
use crate::utils::files::{get_bytes_from_path, get_path_from_bytes}; use crate::utils::files::{get_bytes_from_path, get_path_from_bytes};
use format_bytes::{write_bytes, DisplayBytes}; use format_bytes::{format_bytes, write_bytes, DisplayBytes};
use lazy_static::lazy_static; use lazy_static::lazy_static;
use regex::bytes::Regex; use regex::bytes::Regex;
use std::collections::HashMap; use std::collections::HashMap;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
lazy_static! { lazy_static! {
static ref SECTION_RE: Regex = make_regex(r"^\[([^\[]+)\]"); static ref SECTION_RE: Regex = make_regex(r"^\[([^\[]+)\]");
static ref ITEM_RE: Regex = make_regex(r"^([^=\s][^=]*?)\s*=\s*((.*\S)?)"); static ref ITEM_RE: Regex = make_regex(r"^([^=\s][^=]*?)\s*=\s*((.*\S)?)");
value, value,
Some(index + 1), Some(index + 1),
); );
} else if let Some(m) = UNSET_RE.captures(&bytes) { } else if let Some(m) = UNSET_RE.captures(&bytes) {
if let Some(map) = current_layer.sections.get_mut(&section) { if let Some(map) = current_layer.sections.get_mut(&section) {
map.remove(&m[1]); map.remove(&m[1]);
} }
} else { } else {
let message = if bytes.starts_with(b" ") {
format_bytes!(b"unexpected leading whitespace: {}", bytes)
} else {
bytes.to_owned()
};
return Err(ConfigParseError { return Err(ConfigParseError {
origin: ConfigOrigin::File(src.to_owned()), origin: ConfigOrigin::File(src.to_owned()),
line: Some(index + 1), line: Some(index + 1),
bytes: bytes.to_owned(), message,
} }
.into()); .into());
} }
} }
if !current_layer.is_empty() { if !current_layer.is_empty() {
layers.push(current_layer); layers.push(current_layer);
} }
Ok(layers) Ok(layers)
} }
} }
} }
#[derive(Debug)] #[derive(Debug)]
pub struct ConfigParseError { pub struct ConfigParseError {
pub origin: ConfigOrigin, pub origin: ConfigOrigin,
pub line: Option<usize>, pub line: Option<usize>,
pub bytes: Vec<u8>, pub message: Vec<u8>,
} }
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum ConfigError { pub enum ConfigError {
Parse(ConfigParseError), Parse(ConfigParseError),
Other(HgError), Other(HgError),
} }
fn make_regex(pattern: &'static str) -> Regex { fn make_regex(pattern: &'static str) -> Regex {
Regex::new(pattern).expect("expected a valid regex") Regex::new(pattern).expect("expected a valid regex")
} }

rust/hg-core/src/errors.rs

} }
// TODO: use `DisplayBytes` instead to show non-Unicode filenames losslessly? // TODO: use `DisplayBytes` instead to show non-Unicode filenames losslessly?
impl fmt::Display for HgError { impl fmt::Display for HgError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
HgError::Abort(explanation) => write!(f, "{}", explanation), HgError::Abort(explanation) => write!(f, "{}", explanation),
HgError::IoError { error, context } => { HgError::IoError { error, context } => {
write!(f, "{}: {}", error, context) write!(f, "abort: {}: {}", context, error)
} }
HgError::CorruptedRepository(explanation) => { HgError::CorruptedRepository(explanation) => {
write!(f, "corrupted repository: {}", explanation) write!(f, "abort: corrupted repository: {}", explanation)
} }
HgError::UnsupportedFeature(explanation) => { HgError::UnsupportedFeature(explanation) => {
write!(f, "unsupported feature: {}", explanation) write!(f, "unsupported feature: {}", explanation)
} }
HgError::ConfigValueParseError(ConfigValueParseError { HgError::ConfigValueParseError(ConfigValueParseError {
origin: _, origin: _,
line: _, line: _,
section, section,
write!(f, "when removing {}", path.display()) write!(f, "when removing {}", path.display())
} }
IoErrorContext::RenamingFile { from, to } => write!( IoErrorContext::RenamingFile { from, to } => write!(
f, f,
"when renaming {} to {}", "when renaming {} to {}",
from.display(), from.display(),
to.display() to.display()
), ),
IoErrorContext::CurrentDir => write!(f, "current directory"), IoErrorContext::CurrentDir => {
IoErrorContext::CurrentExe => write!(f, "current executable"), write!(f, "error getting current working directory")
}
IoErrorContext::CurrentExe => {
write!(f, "error getting current executable")
}
} }
} }
} }
pub trait IoResultExt<T> { pub trait IoResultExt<T> {
/// Annotate a possible I/O error as related to a reading a file at the /// Annotate a possible I/O error as related to a reading a file at the
/// given path. /// given path.
/// ///

rust/rhg/src/error.rs

} }
} }
impl<'a> From<&'a NoRepoInCwdError> for CommandError { impl<'a> From<&'a NoRepoInCwdError> for CommandError {
fn from(error: &'a NoRepoInCwdError) -> Self { fn from(error: &'a NoRepoInCwdError) -> Self {
let NoRepoInCwdError { cwd } = error; let NoRepoInCwdError { cwd } = error;
CommandError::Abort { CommandError::Abort {
message: format_bytes!( message: format_bytes!(
b"no repository found in '{}' (.hg not found)!", b"abort: no repository found in '{}' (.hg not found)!",
get_bytes_from_path(cwd) get_bytes_from_path(cwd)
), ),
} }
} }
} }
impl From<ConfigError> for CommandError { impl From<ConfigError> for CommandError {
fn from(error: ConfigError) -> Self { fn from(error: ConfigError) -> Self {
match error { match error {
ConfigError::Parse(error) => error.into(), ConfigError::Parse(error) => error.into(),
ConfigError::Other(error) => error.into(), ConfigError::Other(error) => error.into(),
} }
} }
} }
impl From<ConfigParseError> for CommandError { impl From<ConfigParseError> for CommandError {
fn from(error: ConfigParseError) -> Self { fn from(error: ConfigParseError) -> Self {
let ConfigParseError { let ConfigParseError {
origin, origin,
line, line,
bytes, message,
} = error; } = error;
let line_message = if let Some(line_number) = line { let line_message = if let Some(line_number) = line {
format_bytes!(b" at line {}", line_number.to_string().into_bytes()) format_bytes!(b":{}", line_number.to_string().into_bytes())
} else { } else {
Vec::new() Vec::new()
}; };
CommandError::Abort { CommandError::Abort {
message: format_bytes!( message: format_bytes!(
b"config parse error in {}{}: '{}'", b"config error at {}{}: {}",
origin, origin,
line_message, line_message,
bytes message
), ),
} }
} }
} }
impl From<(RevlogError, &str)> for CommandError { impl From<(RevlogError, &str)> for CommandError {
fn from((err, rev): (RevlogError, &str)) -> CommandError { fn from((err, rev): (RevlogError, &str)) -> CommandError {
match err { match err {
RevlogError::InvalidRevision => CommandError::abort(format!( RevlogError::InvalidRevision => CommandError::abort(format!(
"invalid revision identifier {}", "abort: invalid revision identifier: {}",
rev rev
)), )),
RevlogError::AmbiguousPrefix => CommandError::abort(format!( RevlogError::AmbiguousPrefix => CommandError::abort(format!(
"ambiguous revision identifier {}", "abort: ambiguous revision identifier: {}",
rev rev
)), )),
RevlogError::Other(error) => error.into(), RevlogError::Other(error) => error.into(),
} }
} }
} }

rust/rhg/src/main.rs

} }
} }
match &result { match &result {
Ok(_) => {} Ok(_) => {}
Err(CommandError::Abort { message }) => { Err(CommandError::Abort { message }) => {
if !message.is_empty() { if !message.is_empty() {
// Ignore errors when writing to stderr, we’re already exiting // Ignore errors when writing to stderr, we’re already exiting
// with failure code so there’s not much more we can do. // with failure code so there’s not much more we can do.
let _ = let _ = ui.write_stderr(&format_bytes!(b"{}\n", message));
ui.write_stderr(&format_bytes!(b"abort: {}\n", message));
} }
} }
Err(CommandError::UnsupportedFeature { message }) => { Err(CommandError::UnsupportedFeature { message }) => {
match on_unsupported { match on_unsupported {
OnUnsupported::Abort => { OnUnsupported::Abort => {
let _ = ui.write_stderr(&format_bytes!( let _ = ui.write_stderr(&format_bytes!(
b"unsupported feature: {}\n", b"unsupported feature: {}\n",
message message

tests/test-rhg.t

Unwritable file descriptor Unwritable file descriptor
$ $NO_FALLBACK rhg root > /dev/full $ $NO_FALLBACK rhg root > /dev/full
abort: No space left on device (os error 28) abort: No space left on device (os error 28)
[255] [255]
Deleted repository Deleted repository
$ rm -rf `pwd` $ rm -rf `pwd`
$ $NO_FALLBACK rhg root $ $NO_FALLBACK rhg root
abort: $ENOENT$: current directory abort: error getting current working directory: $ENOENT$
[255] [255]
Listing tracked files Listing tracked files
$ cd $TESTTMP $ cd $TESTTMP
$ hg init repository $ hg init repository
$ cd repository $ cd repository
$ for i in 1 2 3; do $ for i in 1 2 3; do
> echo $i >> file$i > echo $i >> file$i
6ae9681c6d30389694d8701faf24b583cf3ccafe 6ae9681c6d30389694d8701faf24b583cf3ccafe
$ $NO_FALLBACK rhg files -r cf8b83 $ $NO_FALLBACK rhg files -r cf8b83
file-1 file-1
file-2 file-2
file-3 file-3
$ $NO_FALLBACK rhg cat -r cf8b83 file-2 $ $NO_FALLBACK rhg cat -r cf8b83 file-2
2 2
$ $NO_FALLBACK rhg cat -r c file-2 $ $NO_FALLBACK rhg cat -r c file-2
abort: ambiguous revision identifier c abort: ambiguous revision identifier: c
[255] [255]
$ $NO_FALLBACK rhg cat -r d file-2 $ $NO_FALLBACK rhg cat -r d file-2
2 2
Cat files Cat files
$ cd $TESTTMP $ cd $TESTTMP
$ rm -rf repository $ rm -rf repository
$ hg init repository $ hg init repository