This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9938

rust: use HgError in ConfigError
ClosedPublic

Authored by SimonSapin on Feb 1 2021, 6:59 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG0cb1b02228a6: rust: use HgError in ConfigError

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Feb 1 2021, 6:59 AM
Alphare added a subscriber: Alphare.Feb 1 2021, 7:58 AM
Alphare added inline comments.
rust/hg-core/src/config/layer.rs
105

Should read_include be instead using the VFS?

SimonSapin added a commit: rHG0cb1b02228a6: rust: use HgError in ConfigError.Feb 1 2021, 12:39 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG0cb1b02228a6: rust: use HgError in ConfigError (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25420

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::{ConfigError, ConfigLayer, ConfigValue}; use crate::config::layer::{
ConfigError, ConfigLayer, ConfigParseError, ConfigValue,
};
use std::path::PathBuf; use std::path::PathBuf;
use crate::repo::Repo; use crate::repo::Repo;
use crate::utils::files::read_whole_file; use crate::utils::files::read_whole_file;
/// Holds the config values for the current repository /// Holds the config values for the current repository
/// TODO update this docstring once we support more sources /// TODO update this docstring once we support more sources
pub struct Config { pub struct Config {
/// 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>, ConfigError> { ) -> Result<Option<bool>, ConfigParseError> {
match self.get_inner(&section, &item) { match self.get_inner(&section, &item) {
Some((layer, v)) => match parse_bool(&v.bytes) { Some((layer, v)) => match parse_bool(&v.bytes) {
Some(b) => Ok(Some(b)), Some(b) => Ok(Some(b)),
None => Err(ConfigError::Parse { None => Err(ConfigParseError {
origin: layer.origin.to_owned(), origin: layer.origin.to_owned(),
line: v.line, line: v.line,
bytes: v.bytes.to_owned(), bytes: v.bytes.to_owned(),
}), }),
}, },
None => Ok(None), None => Ok(None),
} }
} }

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::utils::files::{ use crate::utils::files::{
get_bytes_from_path, get_path_from_bytes, read_whole_file, get_bytes_from_path, get_path_from_bytes, read_whole_file,
}; };
use format_bytes::format_bytes; use format_bytes::format_bytes;
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::io; use std::io;
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() {
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];
let filename_to_include = get_path_from_bytes(&filename_bytes); let filename_to_include = get_path_from_bytes(&filename_bytes);
match read_include(&src, &filename_to_include) { let (include_src, result) =
(include_src, Ok(data)) => { read_include(&src, &filename_to_include);
let data = result.for_file(filename_to_include)?;
AlphareUnsubmitted
Not Done

Should read_include be instead using the VFS?

Alphare: Should `read_include` be instead using the VFS?
layers.push(current_layer); layers.push(current_layer);
layers.extend(Self::parse(&include_src, &data)?); layers.extend(Self::parse(&include_src, &data)?);
current_layer = current_layer = Self::new(ConfigOrigin::File(src.to_owned()));
Self::new(ConfigOrigin::File(src.to_owned()));
}
(_, Err(e)) => {
return Err(ConfigError::IncludeError {
path: filename_to_include.to_owned(),
io_error: e,
})
}
}
} 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() {
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 {
return Err(ConfigError::Parse { 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(), bytes: bytes.to_owned(),
}); }
.into());
} }
} }
if !current_layer.is_empty() { if !current_layer.is_empty() {
layers.push(current_layer); layers.push(current_layer);
} }
Ok(layers) Ok(layers)
} }
} }
pub fn to_bytes(&self) -> Vec<u8> { pub fn to_bytes(&self) -> Vec<u8> {
match self { match self {
ConfigOrigin::File(p) => get_bytes_from_path(p), ConfigOrigin::File(p) => get_bytes_from_path(p),
ConfigOrigin::Environment(e) => e.to_owned(), ConfigOrigin::Environment(e) => e.to_owned(),
} }
} }
} }
#[derive(Debug)]
pub struct ConfigParseError {
pub origin: ConfigOrigin,
pub line: Option<usize>,
pub bytes: Vec<u8>,
}
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum ConfigError { pub enum ConfigError {
Parse { Parse(ConfigParseError),
origin: ConfigOrigin, Other(HgError),
line: Option<usize>,
bytes: Vec<u8>,
},
/// Failed to include a sub config file
IncludeError {
path: PathBuf,
io_error: std::io::Error,
},
/// Any IO error that isn't expected
#[from]
IO(std::io::Error),
} }
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")
} }
/// Includes are relative to the file they're defined in, unless they're /// Includes are relative to the file they're defined in, unless they're
/// absolute. /// absolute.