( )⚙ D10009 rust: Add a `ConfigValueParseError` variant to common errors

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

Revision Contents
Changeset List

Diff 25646

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 {