forked from gentoo-utils/gentoo-utils
126 lines
3.6 KiB
Rust
126 lines
3.6 KiB
Rust
use std::{
|
|
collections::HashMap,
|
|
io,
|
|
path::{Path, PathBuf},
|
|
};
|
|
|
|
use mon::{Parser, ParserIter, ascii_whitespace1, input::InputIter};
|
|
|
|
use crate::{
|
|
Parseable,
|
|
atom::Atom,
|
|
repo::profile::{FlagOperation, LineBasedFileExpr, Profile, read_config_files},
|
|
useflag::UseFlag,
|
|
};
|
|
|
|
mod parsers;
|
|
|
|
#[derive(Debug, thiserror::Error)]
|
|
pub enum Error {
|
|
#[error("{0}: io error: {1}")]
|
|
Io(PathBuf, io::Error),
|
|
#[error("parser error: {0}")]
|
|
Parser(String),
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct Expr(Atom, Vec<FlagOperation>);
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub(super) enum Kind {
|
|
Use,
|
|
Force,
|
|
Mask,
|
|
StableForce,
|
|
StableMask,
|
|
}
|
|
|
|
pub(super) fn evaluate<P: AsRef<Path>>(
|
|
parents: &[Profile],
|
|
kind: Kind,
|
|
path: P,
|
|
) -> Result<HashMap<Atom, Vec<UseFlag>>, Error> {
|
|
let file_path = match kind {
|
|
Kind::Use => "package.use",
|
|
Kind::Force => "package.use.force",
|
|
Kind::Mask => "package.use.mask",
|
|
Kind::StableForce => "package.use.stable.force",
|
|
Kind::StableMask => "package.use.stable.mask",
|
|
};
|
|
|
|
let parsed = match read_config_files(path.as_ref().join(file_path)) {
|
|
Ok(contents) => parse(&contents)?,
|
|
Err(e) if matches!(e.kind(), io::ErrorKind::NotFound) => HashMap::new(),
|
|
Err(e) => return Err(Error::Io(path.as_ref().to_path_buf(), e)),
|
|
};
|
|
|
|
Ok(inherit(parents, kind, parsed))
|
|
}
|
|
|
|
fn inherit(
|
|
parents: &[Profile],
|
|
kind: Kind,
|
|
vars: HashMap<Atom, Vec<FlagOperation>>,
|
|
) -> HashMap<Atom, Vec<UseFlag>> {
|
|
let mut accumulated: HashMap<Atom, Vec<UseFlag>> = HashMap::new();
|
|
|
|
for parent in parents {
|
|
let source = match kind {
|
|
Kind::Use => parent.package_use(),
|
|
Kind::Force => parent.package_use_force(),
|
|
Kind::Mask => parent.package_use_mask(),
|
|
Kind::StableForce => parent.package_use_stable_force(),
|
|
Kind::StableMask => parent.package_use_stable_mask(),
|
|
};
|
|
|
|
for (atom, flags) in source {
|
|
accumulated
|
|
.entry(atom.clone())
|
|
.and_modify(|f| f.extend(flags.iter().cloned()))
|
|
.or_insert(flags.clone());
|
|
}
|
|
}
|
|
|
|
for (atom, flags) in vars {
|
|
match accumulated.get_mut(&atom) {
|
|
Some(accumulated) => {
|
|
for flag in flags {
|
|
match flag {
|
|
FlagOperation::Add(flag) => accumulated.push(flag),
|
|
FlagOperation::Remove(flag) => accumulated.retain(|v| *v != flag),
|
|
}
|
|
}
|
|
}
|
|
None => {
|
|
accumulated.insert(
|
|
atom.clone(),
|
|
flags
|
|
.iter()
|
|
.filter_map(|flag| match flag {
|
|
FlagOperation::Add(flag) => Some(flag),
|
|
FlagOperation::Remove(_) => None,
|
|
})
|
|
.cloned()
|
|
.collect(),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
accumulated
|
|
}
|
|
|
|
fn parse(contents: &str) -> Result<HashMap<Atom, Vec<FlagOperation>>, Error> {
|
|
Ok(LineBasedFileExpr::<Expr>::parser()
|
|
.separated_by_with_opt_trailing(ascii_whitespace1())
|
|
.many()
|
|
.parse_finished(InputIter::new(contents))
|
|
.map_err(|e| Error::Parser(e.rest().to_string()))?
|
|
.into_iter()
|
|
.filter_map(|expr| match expr {
|
|
LineBasedFileExpr::Comment => None,
|
|
LineBasedFileExpr::Expr(Expr(atom, operations)) => Some((atom, operations)),
|
|
})
|
|
.collect())
|
|
}
|