penguin/gentoo-utils
1
0
Fork 0
forked from gentoo-utils/gentoo-utils
Code Pull Requests Activity

port to new mon parsers

Browse Source
This commit is contained in:
John Turner
2025-10-27 02:07:17 -04:00
parent 0d6ab21582
commit b1bd90dac1
4 changed files with 46 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
src/atom/parsers.rs
View File

@@ -1,6 +1,6 @@
use core::option::Option::None;
use mon::{Parser, r#if, not, numeric1, one_of, opt, tag, take_while};
use mon::{Parser, r#if, numeric1, one_of, tag};
use crate::{
atom::{
@@ -29,7 +29,7 @@ pub fn version_operator<'a>() -> impl Parser<&'a str, Output = VersionOperator>
pub fn version_number<'a>() -> impl Parser<&'a str, Output = VersionNumber> {
numeric1()
.followed_by(opt(tag("*")))
.followed_by(tag("*").opt())
.recognize()
.map(|output: &str| VersionNumber(output.to_string()))
}
@@ -45,21 +45,19 @@ pub fn version_suffix_kind<'a>() -> impl Parser<&'a str, Output = VersionSuffixK
pub fn version_suffix<'a>() -> impl Parser<&'a str, Output = VersionSuffix> {
version_suffix_kind()
.and(opt(version_number()))
.and(version_number().opt())
.map(|(kind, number)| VersionSuffix { kind, number })
}
pub fn version<'a>() -> impl Parser<&'a str, Output = Version> {
let numbers = version_number().separated_list1(tag("."));
let suffixes = version_suffix().separated_list(tag("_"));
let numbers = version_number().separated_list(tag("."), 1..);
let suffixes = version_suffix().separated_list(tag("_"), 0..);
let rev = version_number().preceded_by(tag("-r"));
numbers
.and(opt(r#if(|c: &char| {
c.is_ascii_alphabetic() && c.is_ascii_lowercase()
})))
.and(opt(suffixes.preceded_by(tag("_"))))
.and(opt(rev))
.and(r#if(|c: &char| c.is_ascii_alphabetic() && c.is_ascii_lowercase()).opt())
.and(suffixes.preceded_by(tag("_")).opt())
.and(rev.opt())
.map(|(((numbers, letter), suffixes), rev)| Version {
numbers,
letter,
@@ -70,9 +68,7 @@ pub fn version<'a>() -> impl Parser<&'a str, Output = Version> {
pub fn category<'a>() -> impl Parser<&'a str, Output = Category> {
let start = r#if(|c: &char| c.is_ascii_alphanumeric() || *c == '_');
let rest = take_while(r#if(|c: &char| {
c.is_ascii_alphanumeric() || "+_.-".contains(*c)
}));
let rest = r#if(|c: &char| c.is_ascii_alphanumeric() || "+_.-".contains(*c)).list(0..);
start
.and(rest)
@@ -82,16 +78,13 @@ pub fn category<'a>() -> impl Parser<&'a str, Output = Category> {
pub fn name<'a>() -> impl Parser<&'a str, Output = Name> {
let start = r#if(|c: &char| c.is_ascii_alphanumeric() || *c == '_');
let rest = take_while(
r#if(|c: &char| c.is_ascii_alphanumeric() || "_+".contains(*c)).or(one_of("-".chars())
.and_not(
version()
.preceded_by(tag("-"))
.followed_by(not(r#if(|c: &char| {
c.is_ascii_alphanumeric() || "_+-".contains(*c)
}))),
)),
);
let rest = r#if(|c: &char| c.is_ascii_alphanumeric() || "_+".contains(*c))
.or(one_of("-".chars()).and_not(
version().preceded_by(tag("-")).followed_by(
r#if(|c: &char| c.is_ascii_alphanumeric() || "_+-".contains(*c)).not(),
),
))
.list(0..);
start
.and(rest)
@@ -107,9 +100,7 @@ pub fn slot_operator<'a>() -> impl Parser<&'a str, Output = SlotOperator> {
pub fn slotname<'a>() -> impl Parser<&'a str, Output = SlotName> {
let start = r#if(|c: &char| c.is_ascii_alphanumeric() || *c == '_');
let rest = take_while(r#if(|c: &char| {
c.is_ascii_alphanumeric() || "+_.-".contains(*c)
}));
let rest = r#if(|c: &char| c.is_ascii_alphanumeric() || "+_.-".contains(*c)).list(0..);
start
.and(rest)
@@ -118,9 +109,10 @@ pub fn slotname<'a>() -> impl Parser<&'a str, Output = SlotName> {
}
pub fn slot<'a>() -> impl Parser<&'a str, Output = Slot> {
opt(slotname())
.and(opt(slotname().preceded_by(tag("/"))))
.and(opt(slot_operator()))
slotname()
.opt()
.and(slotname().preceded_by(tag("/")).opt())
.and(slot_operator().opt())
.map(|((slot, sub), operator)| Slot {
slot,
sub,
@@ -136,7 +128,7 @@ pub fn usedep_sign<'a>() -> impl Parser<&'a str, Output = UseDepSign> {
pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
let a = useflag()
.and(opt(usedep_sign()))
.and(usedep_sign().opt())
.preceded_by(tag("-"))
.map(|(flag, sign)| UseDep {
negate: Some(UseDepNegate::Minus),
@@ -146,7 +138,7 @@ pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
});
let b = useflag()
.and(opt(usedep_sign()))
.and(usedep_sign().opt())
.preceded_by(tag("!"))
.followed_by(tag("?"))
.map(|(flag, sign)| UseDep {
@@ -157,7 +149,7 @@ pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
});
let c = useflag()
.and(opt(usedep_sign()))
.and(usedep_sign().opt())
.followed_by(tag("?"))
.map(|(flag, sign)| UseDep {
negate: None,
@@ -167,7 +159,7 @@ pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
});
let d = useflag()
.and(opt(usedep_sign()))
.and(usedep_sign().opt())
.preceded_by(tag("!"))
.followed_by(tag("="))
.map(|(flag, sign)| UseDep {
@@ -178,7 +170,7 @@ pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
});
let e = useflag()
.and(opt(usedep_sign()))
.and(usedep_sign().opt())
.followed_by(tag("="))
.map(|(flag, sign)| UseDep {
negate: None,
@@ -188,7 +180,7 @@ pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
});
let f = useflag()
.and(opt(usedep_sign()))
.and(usedep_sign().opt())
.map(|(flag, sign)| UseDep {
negate: None,
flag,
@@ -200,15 +192,19 @@ pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
}
pub fn atom<'a>() -> impl Parser<&'a str, Output = Atom> {
opt(blocker())
.and(opt(version_operator()))
blocker()
.opt()
.and(version_operator().opt())
.and(category())
.and(name().preceded_by(tag("/")))
.and(opt(version().preceded_by(tag("-"))))
.and(opt(slot().preceded_by(tag(":"))))
.and(opt(usedep()
.separated_list(tag(","))
.delimited_by(tag("["), tag("]"))))
.and(version().preceded_by(tag("-")).opt())
.and(slot().preceded_by(tag(":")).opt())
.and(
usedep()
.separated_list(tag(","), 0..)
.delimited_by(tag("["), tag("]"))
.opt(),
)
.map(
|((((((blocker, version_operator), category), name), version), slot), usedeps)| Atom {
blocker,

8
src/depend/parsers.rs
View File

@@ -8,18 +8,18 @@ use crate::{
fn expr(it: InputIter<&str>) -> ParserResult<&str, Expr> {
let all_of = expr
.separated_list1(whitespace1())
.separated_list(whitespace1(), 1..)
.delimited_by(tag("(").followed_by(whitespace1()), tag(")"))
.map(|exprs| Expr::AllOf(exprs));
let any_of = expr
.separated_list1(whitespace1())
.separated_list(whitespace1(), 1..)
.delimited_by(tag("(").followed_by(whitespace1()), tag(")"))
.preceded_by(tag("||").followed_by(whitespace1()))
.map(|exprs| Expr::AnyOf(exprs));
let one_of = expr
.separated_list1(whitespace1())
.separated_list(whitespace1(), 1..)
.delimited_by(tag("(").followed_by(whitespace1()), tag(")"))
.preceded_by(tag("^^").followed_by(whitespace1()))
.map(|exprs| Expr::OneOf(exprs));
@@ -44,7 +44,7 @@ fn conditional<'a>() -> impl Parser<&'a str, Output = Conditional> {
}
pub fn exprs<'a>() -> impl Parser<&'a str, Output = Vec<Expr>> {
expr.separated_list1(whitespace1())
expr.separated_list(whitespace1(), 0..)
}
#[cfg(test)]

6
src/useflag/parsers.rs
View File

@@ -1,12 +1,10 @@
use mon::{Parser, r#if, take_while};
use mon::{Parser, r#if};
use crate::useflag::UseFlag;
pub fn useflag<'a>() -> impl Parser<&'a str, Output = UseFlag> {
let start = r#if(|c: &char| c.is_ascii_alphanumeric());
let rest = take_while(r#if(|c: &char| {
c.is_ascii_alphanumeric() || "+_@-".contains(*c)
}));
let rest = r#if(|c: &char| c.is_ascii_alphanumeric() || "+_@-".contains(*c)).list(0..);
start
.and(rest)

2
tests/depend.rs
View File

@@ -12,6 +12,8 @@ fn parse_md5_cache() {
for line in metadata.lines() {
if line.starts_with("DEPEND=") {
eprintln!("{line}");
eprintln!();
depend::parsers::exprs()
.ignore()
.or(eof())