This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10009

rust: Add a `ConfigValueParseError` variant to common errors
ClosedPublic

Authored by SimonSapin on Feb 17 2021, 7:58 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGbc08c2331f99: rust: Add a `ConfigValueParseError` variant to common errors
rHGd6eb4fb10a86: rust: Add a `ConfigValueParseError` variant to common errors
Summary

Configuration files are parsed into sections of key/value pairs when
they are read, but at that point values are still arbitrary bytes.
Only when a value is accessed by various parts of the code do we know
its expected type and syntax, so values are parsed at that point.

Let’s make a new error type for this latter kind of parsing error,
and add a variant to the common HgError so that most code can propagate it
without much boilerplate.

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.

Revision Contents
Changeset List

Diff 25876

rust/hg-core/src/config.rs

// config.rs // config.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.
//! Mercurial config parsing and interfaces. //! Mercurial config parsing and interfaces.
mod config; mod config;
mod layer; mod layer;
pub use config::Config; pub use config::{Config, ConfigValueParseError};
pub use layer::{ConfigError, ConfigParseError}; pub use layer::{ConfigError, ConfigParseError};

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

// config.rs // config.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 super::layer; use super::layer;
use crate::config::layer::{ use crate::config::layer::{
ConfigError, ConfigLayer, ConfigParseError, ConfigValue, ConfigError, ConfigLayer, ConfigOrigin, ConfigValue,
}; };
use crate::utils::files::get_bytes_from_os_str; use crate::utils::files::get_bytes_from_os_str;
use format_bytes::{write_bytes, DisplayBytes}; use format_bytes::{write_bytes, DisplayBytes};
use std::env; use std::env;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use std::str; use std::str;
use crate::errors::{HgResultExt, IoResultExt}; use crate::errors::{HgResultExt, IoResultExt};
pub enum ConfigSource { pub enum ConfigSource {
/// Absolute path to a config file /// Absolute path to a config file
AbsPath(PathBuf), AbsPath(PathBuf),
/// Already parsed (from the CLI, env, Python resources, etc.) /// Already parsed (from the CLI, env, Python resources, etc.)
Parsed(layer::ConfigLayer), Parsed(layer::ConfigLayer),
} }
#[derive(Debug)]
pub struct ConfigValueParseError {
pub origin: ConfigOrigin,
pub line: Option<usize>,
pub section: Vec<u8>,
pub item: Vec<u8>,
pub value: Vec<u8>,
pub expected_type: &'static str,
}
pub fn parse_bool(v: &[u8]) -> Option<bool> { pub fn parse_bool(v: &[u8]) -> Option<bool> {
match v.to_ascii_lowercase().as_slice() { match v.to_ascii_lowercase().as_slice() {
b"1" | b"yes" | b"true" | b"on" | b"always" => Some(true), b"1" | b"yes" | b"true" | b"on" | b"always" => Some(true),
b"0" | b"no" | b"false" | b"off" | b"never" => Some(false), b"0" | b"no" | b"false" | b"off" | b"never" => Some(false),
_ => None, _ => None,
} }
} }
repo_config.layers.extend(cli_layers); repo_config.layers.extend(cli_layers);
Ok(repo_config) Ok(repo_config)
} }
fn get_parse<'config, T: 'config>( fn get_parse<'config, T: 'config>(
&'config self, &'config self,
section: &[u8], section: &[u8],
item: &[u8], item: &[u8],
expected_type: &'static str,
parse: impl Fn(&'config [u8]) -> Option<T>, parse: impl Fn(&'config [u8]) -> Option<T>,
) -> Result<Option<T>, ConfigParseError> { ) -> Result<Option<T>, ConfigValueParseError> {
match self.get_inner(&section, &item) { match self.get_inner(&section, &item) {
Some((layer, v)) => match parse(&v.bytes) { Some((layer, v)) => match parse(&v.bytes) {
Some(b) => Ok(Some(b)), Some(b) => Ok(Some(b)),
None => Err(ConfigParseError { None => Err(ConfigValueParseError {
origin: layer.origin.to_owned(), origin: layer.origin.to_owned(),
line: v.line, line: v.line,
bytes: v.bytes.to_owned(), value: v.bytes.to_owned(),
section: section.to_owned(),
item: item.to_owned(),
expected_type,
}), }),
}, },
None => Ok(None), None => Ok(None),
} }
} }
/// Returns an `Err` if the first value found is not a valid UTF-8 string. /// Returns an `Err` if the first value found is not a valid UTF-8 string.
/// Otherwise, returns an `Ok(value)` if found, or `None`. /// Otherwise, returns an `Ok(value)` if found, or `None`.
pub fn get_str( pub fn get_str(
&self, &self,
section: &[u8], section: &[u8],
item: &[u8], item: &[u8],
) -> Result<Option<&str>, ConfigParseError> { ) -> Result<Option<&str>, ConfigValueParseError> {
self.get_parse(section, item, |value| str::from_utf8(value).ok()) self.get_parse(section, item, "ASCII or UTF-8 string", |value| {
str::from_utf8(value).ok()
})
} }
/// Returns an `Err` if the first value found is not a valid unsigned /// Returns an `Err` if the first value found is not a valid unsigned
/// integer. Otherwise, returns an `Ok(value)` if found, or `None`. /// integer. Otherwise, returns an `Ok(value)` if found, or `None`.
pub fn get_u32( pub fn get_u32(
&self, &self,
section: &[u8], section: &[u8],
item: &[u8], item: &[u8],
) -> Result<Option<u32>, ConfigParseError> { ) -> Result<Option<u32>, ConfigValueParseError> {
self.get_parse(section, item, |value| { self.get_parse(section, item, "valid integer", |value| {
str::from_utf8(value).ok()?.parse().ok() str::from_utf8(value).ok()?.parse().ok()
}) })
} }
/// Returns an `Err` if the first value found is not a valid file size /// Returns an `Err` if the first value found is not a valid file size
/// value such as `30` (default unit is bytes), `7 MB`, or `42.5 kb`. /// value such as `30` (default unit is bytes), `7 MB`, or `42.5 kb`.
/// Otherwise, returns an `Ok(value_in_bytes)` if found, or `None`. /// Otherwise, returns an `Ok(value_in_bytes)` if found, or `None`.
pub fn get_byte_size( pub fn get_byte_size(
&self, &self,
section: &[u8], section: &[u8],
item: &[u8], item: &[u8],
) -> Result<Option<u64>, ConfigParseError> { ) -> Result<Option<u64>, ConfigValueParseError> {
self.get_parse(section, item, parse_byte_size) self.get_parse(section, item, "byte quantity", parse_byte_size)
} }
/// Returns an `Err` if the first value found is not a valid boolean. /// Returns an `Err` if the first value found is not a valid boolean.
/// Otherwise, returns an `Ok(option)`, where `option` is the boolean if /// Otherwise, returns an `Ok(option)`, where `option` is the boolean if
/// found, or `None`. /// found, or `None`.
pub fn get_option( pub fn get_option(
&self, &self,
section: &[u8], section: &[u8],
item: &[u8], item: &[u8],
) -> Result<Option<bool>, ConfigParseError> { ) -> Result<Option<bool>, ConfigValueParseError> {
self.get_parse(section, item, parse_bool) self.get_parse(section, item, "boolean", parse_bool)
} }
/// Returns the corresponding boolean in the config. Returns `Ok(false)` /// Returns the corresponding boolean in the config. Returns `Ok(false)`
/// if the value is not found, an `Err` if it's not a valid boolean. /// if the value is not found, an `Err` if it's not a valid boolean.
pub fn get_bool( pub fn get_bool(
&self, &self,
section: &[u8], section: &[u8],
item: &[u8], item: &[u8],
) -> Result<bool, ConfigError> { ) -> Result<bool, ConfigValueParseError> {
Ok(self.get_option(section, item)?.unwrap_or(false)) Ok(self.get_option(section, item)?.unwrap_or(false))
} }
/// Returns the raw value bytes of the first one found, or `None`. /// Returns the raw value bytes of the first one found, or `None`.
pub fn get(&self, section: &[u8], item: &[u8]) -> Option<&[u8]> { pub fn get(&self, section: &[u8], item: &[u8]) -> Option<&[u8]> {
self.get_inner(section, item) self.get_inner(section, item)
.map(|(_, value)| value.bytes.as_ref()) .map(|(_, value)| value.bytes.as_ref())
} }

rust/hg-core/src/errors.rs

use crate::config::ConfigValueParseError;
use std::fmt; use std::fmt;
/// Common error cases that can happen in many different APIs /// Common error cases that can happen in many different APIs
#[derive(Debug)] #[derive(Debug, derive_more::From)]
pub enum HgError { pub enum HgError {
IoError { IoError {
error: std::io::Error, error: std::io::Error,
context: IoErrorContext, context: IoErrorContext,
}, },
/// A file under `.hg/` normally only written by Mercurial is not in the /// A file under `.hg/` normally only written by Mercurial is not in the
/// expected format. This indicates a bug in Mercurial, filesystem /// expected format. This indicates a bug in Mercurial, filesystem
/// machine-readable. /// machine-readable.
UnsupportedFeature(String), UnsupportedFeature(String),
/// Operation cannot proceed for some other reason. /// Operation cannot proceed for some other reason.
/// ///
/// The given string is a short explanation for users, not intended to be /// The given string is a short explanation for users, not intended to be
/// machine-readable. /// machine-readable.
Abort(String), Abort(String),
/// A configuration value is not in the expected syntax.
///
/// These errors can happen in many places in the code because values are
/// parsed lazily as the file-level parser does not know the expected type
/// and syntax of each value.
#[from]
ConfigValueParseError(ConfigValueParseError),
} }
/// Details about where an I/O error happened /// Details about where an I/O error happened
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum IoErrorContext { pub enum IoErrorContext {
/// A filesystem operation for the given file /// A filesystem operation for the given file
#[from] #[from]
File(std::path::PathBuf), File(std::path::PathBuf),
HgError::Abort(explanation.into()) HgError::Abort(explanation.into())
} }
} }
// 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::IoError { error, context } => { HgError::IoError { error, context } => {
write!(f, "{}: {}", error, context) write!(f, "{}: {}", error, context)
} }
HgError::CorruptedRepository(explanation) => { HgError::CorruptedRepository(explanation) => {
write!(f, "corrupted repository: {}", explanation) write!(f, "corrupted repository: {}", explanation)
} }
HgError::UnsupportedFeature(explanation) => { HgError::UnsupportedFeature(explanation) => {
write!(f, "unsupported feature: {}", explanation) write!(f, "unsupported feature: {}", explanation)
} }
HgError::Abort(explanation) => explanation.fmt(f), HgError::ConfigValueParseError(ConfigValueParseError {
origin: _,
line: _,
section,
item,
value,
expected_type,
}) => {
// TODO: add origin and line number information, here and in
// corresponding python code
write!(
f,
"config error: {}.{} is not a {} ('{}')",
String::from_utf8_lossy(section),
String::from_utf8_lossy(item),
expected_type,
String::from_utf8_lossy(value)
)
}
} }
} }
} }
// TODO: use `DisplayBytes` instead to show non-Unicode filenames losslessly? // TODO: use `DisplayBytes` instead to show non-Unicode filenames losslessly?
impl fmt::Display for IoErrorContext { impl fmt::Display for IoErrorContext {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {