( )⚙ 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
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 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 26416

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