( )⚙ 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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 26077

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
$ rhg $NO_FALLBACK root > /dev/full $ rhg $NO_FALLBACK 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`
$ rhg $NO_FALLBACK root $ rhg $NO_FALLBACK 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
$ rhg $NO_FALLBACK files -r cf8b83 $ rhg $NO_FALLBACK files -r cf8b83
file-1 file-1
file-2 file-2
file-3 file-3
$ rhg $NO_FALLBACK cat -r cf8b83 file-2 $ rhg $NO_FALLBACK cat -r cf8b83 file-2
2 2
$ rhg $NO_FALLBACK cat -r c file-2 $ rhg $NO_FALLBACK cat -r c file-2
abort: ambiguous revision identifier c abort: ambiguous revision identifier: c
[255] [255]
$ rhg $NO_FALLBACK cat -r d file-2 $ rhg $NO_FALLBACK 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