comparison rust/hg-core/src/config/layer.rs @ 46447:0cb1b02228a6

rust: use HgError in ConfigError

Differential Revision: https://phab.mercurial-scm.org/D9938

46446:1dcd9c9975ed

//      Raphaël Gomès <[e-mail]>
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.

use crate::utils::files::{
    get_bytes_from_path, get_path_from_bytes, read_whole_file,
};
use format_bytes::format_bytes;
use lazy_static::lazy_static;

        while let Some((index, bytes)) = lines_iter.next() {
            if let Some(m) = INCLUDE_RE.captures(&bytes) {
                let filename_bytes = &m[1];
                let filename_to_include = get_path_from_bytes(&filename_bytes);
                match read_include(&src, &filename_to_include) {
                    (include_src, Ok(data)) => {
                        layers.push(current_layer);
                        layers.extend(Self::parse(&include_src, &data)?);
                        current_layer =
                            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(m) = SECTION_RE.captures(&bytes) {
                section = m[1].to_vec();
            } else if let Some(m) = ITEM_RE.captures(&bytes) {
                let item = m[1].to_vec();

            } else if let Some(m) = UNSET_RE.captures(&bytes) {
                if let Some(map) = current_layer.sections.get_mut(&section) {
                    map.remove(&m[1]);
                }
            } else {
                return Err(ConfigError::Parse {
                    origin: ConfigOrigin::File(src.to_owned()),
                    line: Some(index + 1),
                    bytes: bytes.to_owned(),
                });
            }
        }
        if !current_layer.is_empty() {
            layers.push(current_layer);
        }

            ConfigOrigin::Environment(e) => e.to_owned(),
        }
    }
}

#[derive(Debug, derive_more::From)]
pub enum ConfigError {
    Parse {
        origin: ConfigOrigin,
        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 {
    Regex::new(pattern).expect("expected a valid regex")
}

46447:0cb1b02228a6

//      Raphaël Gomès <[e-mail]>
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.

use crate::errors::{HgError, IoResultExt};
use crate::utils::files::{
    get_bytes_from_path, get_path_from_bytes, read_whole_file,
};
use format_bytes::format_bytes;
use lazy_static::lazy_static;

        while let Some((index, bytes)) = lines_iter.next() {
            if let Some(m) = INCLUDE_RE.captures(&bytes) {
                let filename_bytes = &m[1];
                let filename_to_include = get_path_from_bytes(&filename_bytes);
                let (include_src, result) =
                    read_include(&src, &filename_to_include);
                let data = result.for_file(filename_to_include)?;
                layers.push(current_layer);
                layers.extend(Self::parse(&include_src, &data)?);
                current_layer = Self::new(ConfigOrigin::File(src.to_owned()));
            } else if let Some(_) = EMPTY_RE.captures(&bytes) {
            } else if let Some(m) = SECTION_RE.captures(&bytes) {
                section = m[1].to_vec();
            } else if let Some(m) = ITEM_RE.captures(&bytes) {
                let item = m[1].to_vec();

            } else if let Some(m) = UNSET_RE.captures(&bytes) {
                if let Some(map) = current_layer.sections.get_mut(&section) {
                    map.remove(&m[1]);
                }
            } else {
                return Err(ConfigParseError {
                    origin: ConfigOrigin::File(src.to_owned()),
                    line: Some(index + 1),
                    bytes: bytes.to_owned(),
                }
                .into());
            }
        }
        if !current_layer.is_empty() {
            layers.push(current_layer);
        }

            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)]
pub enum ConfigError {
    Parse(ConfigParseError),
    Other(HgError),
}

fn make_regex(pattern: &'static str) -> Regex {
    Regex::new(pattern).expect("expected a valid regex")
}