( )⚙ D10133 rhg: Align with Python on some more error messages

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10133

rhg: Align with Python on some more error messages
ClosedPublic

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

Details

Reviewers
marmoute
Alphare
Group Reviewers
hg-reviewers
Commits
rHG12d59eec7f1d: rhg: Align with Python on some more error messages
Summary

Differences can cause some 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 9 2021, 4:40 AM
baymax updated this revision to Diff 26192.Mar 9 2021, 8:40 AM

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

marmoute accepted this revision.Mar 9 2021, 1:09 PM
Alphare requested changes to this revision.Mar 10 2021, 3:32 AM
This revision now requires changes to proceed.Mar 10 2021, 3:32 AM
Alphare accepted this revision.Mar 11 2021, 3:52 AM
This revision now requires review to proceed.Mar 11 2021, 3:52 AM
Alphare added a comment.Mar 11 2021, 3:53 AM

(I misclicked)

baymax updated this revision to Diff 26339.Mar 15 2021, 9:10 AM

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

SimonSapin added a commit: rHG12d59eec7f1d: rhg: Align with Python on some more error messages.Mar 16 2021, 5:46 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG12d59eec7f1d: rhg: Align with Python on some more error messages (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 26294

rust/Cargo.lock

"crc32fast", "crc32fast",
"libc", "libc",
"libz-sys", "libz-sys",
"miniz_oxide", "miniz_oxide",
] ]
[[package]] [[package]]
name = "format-bytes" name = "format-bytes"
version = "0.2.1" version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8030ff4b04f0ca1c612d6fe49f2fc18caf56fb01497cb370b41cfd36d89b3b06" checksum = "1c4e89040c7fd7b4e6ba2820ac705a45def8a0c098ec78d170ae88f1ef1d5762"
dependencies = [ dependencies = [
"format-bytes-macros", "format-bytes-macros",
"proc-macro-hack", "proc-macro-hack",
] ]
[[package]] [[package]]
name = "format-bytes-macros" name = "format-bytes-macros"
version = "0.3.0" version = "0.3.0"

rust/hg-core/Cargo.toml

twox-hash = "1.5.0" twox-hash = "1.5.0"
same-file = "1.0.6" same-file = "1.0.6"
crossbeam-channel = "0.4" crossbeam-channel = "0.4"
micro-timer = "0.3.0" micro-timer = "0.3.0"
log = "0.4.8" log = "0.4.8"
memmap = "0.7.0" memmap = "0.7.0"
zstd = "0.5.3" zstd = "0.5.3"
rust-crypto = "0.2.36" rust-crypto = "0.2.36"
format-bytes = "0.2.0" format-bytes = "0.2.2"
# We don't use the `miniz-oxide` backend to not change rhg benchmarks and until # We don't use the `miniz-oxide` backend to not change rhg benchmarks and until
# we have a clearer view of which backend is the fastest. # we have a clearer view of which backend is the fastest.
[dependencies.flate2] [dependencies.flate2]
version = "1.0.16" version = "1.0.16"
features = ["zlib"] features = ["zlib"]
default-features = false default-features = false

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;
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::{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! {
let mut layer = Self::new(ConfigOrigin::CommandLine); let mut layer = Self::new(ConfigOrigin::CommandLine);
for arg in cli_config_args { for arg in cli_config_args {
let arg = arg.as_ref(); let arg = arg.as_ref();
if let Some((section, item, value)) = parse_one(arg) { if let Some((section, item, value)) = parse_one(arg) {
layer.add(section, item, value, None); layer.add(section, item, value, None);
} else { } else {
Err(HgError::abort(format!( Err(HgError::abort(format!(
"malformed --config option: '{}' \ "abort: malformed --config option: '{}' \
(use --config section.name=value)", (use --config section.name=value)",
String::from_utf8_lossy(arg), String::from_utf8_lossy(arg),
)))? )))?
} }
} }
if layer.sections.is_empty() { if layer.sections.is_empty() {
Ok(None) Ok(None)
} else { } else {
// TODO check if it's trusted // TODO check if it's trusted
let mut current_layer = Self::new(ConfigOrigin::File(src.to_owned())); let mut current_layer = Self::new(ConfigOrigin::File(src.to_owned()));
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);
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];
// `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
let filename = dir.join(&get_path_from_bytes(&filename_bytes)); let filename = dir.join(&get_path_from_bytes(&filename_bytes));
let data = let data = std::fs::read(&filename).map_err(|io_error| {
std::fs::read(&filename).when_reading_file(&filename)?; ConfigParseError {
origin: ConfigOrigin::File(src.to_owned()),
line,
message: format_bytes!(
b"cannot include {} ({})",
filename_bytes,
format_bytes::Utf8(io_error)
),
}
})?;
layers.push(current_layer); layers.push(current_layer);
layers.extend(Self::parse(&filename, &data)?); layers.extend(Self::parse(&filename, &data)?);
current_layer = Self::new(ConfigOrigin::File(src.to_owned())); current_layer = Self::new(ConfigOrigin::File(src.to_owned()));
} else if let Some(_) = EMPTY_RE.captures(&bytes) { } else if let Some(_) = EMPTY_RE.captures(&bytes) {
} else if let Some(m) = SECTION_RE.captures(&bytes) { } else if let Some(m) = SECTION_RE.captures(&bytes) {
section = m[1].to_vec(); section = m[1].to_vec();
} else if let Some(m) = ITEM_RE.captures(&bytes) { } else if let Some(m) = ITEM_RE.captures(&bytes) {
let item = m[1].to_vec(); let item = m[1].to_vec();
let mut value = m[2].to_vec(); let mut value = m[2].to_vec();
loop { loop {
match lines_iter.peek() { match lines_iter.peek() {
None => break, None => break,
Some((_, v)) => { Some((_, v)) => {
if let Some(_) = COMMENT_RE.captures(&v) { if let Some(_) = COMMENT_RE.captures(&v) {
} else if let Some(_) = CONT_RE.captures(&v) { } else if let Some(_) = CONT_RE.captures(&v) {
value.extend(b"\n"); value.extend(b"\n");
value.extend(&m[1]); value.extend(&m[1]);
} else { } else {
break; break;
} }
} }
}; };
lines_iter.next(); lines_iter.next();
} }
current_layer.add( current_layer.add(section.clone(), item, value, line);
section.clone(),
item,
value,
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" ") { let message = if bytes.starts_with(b" ") {
format_bytes!(b"unexpected leading whitespace: {}", bytes) format_bytes!(b"unexpected leading whitespace: {}", bytes)
} else { } else {
bytes.to_owned() 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,
message, message,
} }
.into()); .into());
} }
} }
if !current_layer.is_empty() { if !current_layer.is_empty() {
layers.push(current_layer); layers.push(current_layer);
} }

rust/hg-core/src/errors.rs

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, "abort: {}: {}", context, error) write!(f, "abort: {}: {}", context, error)
} }
HgError::CorruptedRepository(explanation) => { HgError::CorruptedRepository(explanation) => {
write!(f, "abort: corrupted repository: {}", explanation) write!(f, "abort: {}", 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,

rust/hg-core/src/repo.rs

store_path = shared_path.join("store"); store_path = shared_path.join("store");
let source_is_share_safe = let source_is_share_safe =
requirements::load(Vfs { base: &shared_path })? requirements::load(Vfs { base: &shared_path })?
.contains(requirements::SHARESAFE_REQUIREMENT); .contains(requirements::SHARESAFE_REQUIREMENT);
if share_safe && !source_is_share_safe { if share_safe && !source_is_share_safe {
return Err(match config return Err(match config
.get(b"safe-mismatch", b"source-not-safe") .get(b"share", b"safe-mismatch.source-not-safe")
{ {
Some(b"abort") | None => HgError::abort( Some(b"abort") | None => HgError::abort(
"share source does not support share-safe requirement", "abort: share source does not support share-safe requirement\n\
(see `hg help config.format.use-share-safe` for more information)",
), ),
_ => HgError::unsupported("share-safe downgrade"), _ => HgError::unsupported("share-safe downgrade"),
} }
.into()); .into());
} else if source_is_share_safe && !share_safe { } else if source_is_share_safe && !share_safe {
return Err( return Err(
match config.get(b"safe-mismatch", b"source-safe") { match config.get(b"share", b"safe-mismatch.source-safe") {
Some(b"abort") | None => HgError::abort( Some(b"abort") | None => HgError::abort(
"version mismatch: source uses share-safe \ "abort: version mismatch: source uses share-safe \
functionality while the current share does not", functionality while the current share does not\n\
(see `hg help config.format.use-share-safe` for more information)",
), ),
_ => HgError::unsupported("share-safe upgrade"), _ => HgError::unsupported("share-safe upgrade"),
} }
.into(), .into(),
); );
} }
if share_safe { if share_safe {

rust/rhg/src/error.rs

} }
} }
impl From<RepoError> for CommandError { impl From<RepoError> for CommandError {
fn from(error: RepoError) -> Self { fn from(error: RepoError) -> Self {
match error { match error {
RepoError::NotFound { at } => CommandError::Abort { RepoError::NotFound { at } => CommandError::Abort {
message: format_bytes!( message: format_bytes!(
b"repository {} not found", b"abort: repository {} not found",
get_bytes_from_path(at) get_bytes_from_path(at)
), ),
}, },
RepoError::ConfigParseError(error) => error.into(), RepoError::ConfigParseError(error) => error.into(),
RepoError::Other(error) => error.into(), RepoError::Other(error) => error.into(),
} }
} }
} }

tests/test-rhg.t

[252] [252]
$ $NO_FALLBACK rhg debugrequirements $ $NO_FALLBACK rhg debugrequirements
unsupported feature: repository requires feature unknown to this Mercurial: indoor-pool unsupported feature: repository requires feature unknown to this Mercurial: indoor-pool
[252] [252]
$ echo -e '\xFF' >> .hg/requires $ echo -e '\xFF' >> .hg/requires
$ $NO_FALLBACK rhg debugrequirements $ $NO_FALLBACK rhg debugrequirements
abort: corrupted repository: parse error in 'requires' file abort: parse error in 'requires' file
[255] [255]
Persistent nodemap Persistent nodemap
$ cd $TESTTMP $ cd $TESTTMP
$ rm -rf repository $ rm -rf repository
$ hg init repository $ hg init repository
$ cd repository $ cd repository
$ $NO_FALLBACK rhg debugrequirements | grep nodemap $ $NO_FALLBACK rhg debugrequirements | grep nodemap