kanit

grouping.rs (7798B)

---

 // grouping
 
 // @<mtime>
 // :sysboot
 // procfs,modules,devfs
 // run,clock,sysfs
 // hostname,hwdrivers,mdev,rootfs
 // swap
 // localmount
 // syslog,seed
 // :boot
 // :default
 // getty@tty1
 
 use std::collections::HashMap;
 use std::fmt;
 use std::fmt::Formatter;
 use std::str::FromStr;
 
 use base64::Engine;
 use base64::prelude::BASE64_STANDARD;
 use nom::branch::alt;
 use nom::bytes::complete::is_a;
 use nom::character::complete::{alpha1, alphanumeric1, char, newline, not_line_ending};
 use nom::combinator::{all_consuming, map, map_res, opt, recognize};
 use nom::error::Error;
 use nom::multi::{many0, separated_list0, separated_list1};
 use nom::sequence::{delimited, pair, preceded, terminated};
 use nom::{Finish, IResult};
 
 use crate::UnitName;
 
 type Sha256Hash = [u8; 32];
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct DependencyGrouping {
     pub hash: Sha256Hash,
     pub groups: HashMap<Box<str>, Vec<Vec<UnitName>>>,
 }
 
 impl fmt::Display for DependencyGrouping {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         writeln!(f, "@{}", BASE64_STANDARD.encode(self.hash))?;
 
         for (name, levels) in self.groups.iter() {
             writeln!(f, ":{name}")?;
 
             for level in levels.iter() {
                 writeln!(f, "{}", level.join(","))?;
             }
         }
 
         Ok(())
     }
 }
 
 impl FromStr for DependencyGrouping {
     type Err = Error<String>;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match grouping(s).finish() {
             Ok((_remaining, grouping)) => Ok(grouping),
             Err(e) => Err(Error {
                 input: e.input.to_string(),
                 code: e.code,
             }),
         }
     }
 }
 
 fn grouping(input: &str) -> IResult<&str, DependencyGrouping> {
     all_consuming(map(
         pair(header, separated_list1(newline, group)),
         |(hash, groups)| DependencyGrouping {
             hash,
             groups: groups.into_iter().collect(),
         },
     ))(input)
 }
 
 fn header(input: &str) -> IResult<&str, Sha256Hash> {
     delimited(char('@'), map_res(not_line_ending, hash), newline)(input)
 }
 
 fn hash(input: &str) -> Result<Sha256Hash, base64::DecodeSliceError> {
     let mut buff: Sha256Hash = [0; 32];
 
     BASE64_STANDARD.decode_slice(input, &mut buff)?;
 
     Ok(buff)
 }
 
 fn group(input: &str) -> IResult<&str, (Box<str>, Vec<Vec<UnitName>>)> {
     pair(
         terminated(group_name, opt(newline)),
         separated_list0(newline, level),
     )(input)
 }
 
 fn group_name(input: &str) -> IResult<&str, Box<str>> {
     preceded(
         char(':'),
         map(
             recognize(pair(alpha1, many0(alt((alphanumeric1, is_a("-_")))))),
             Box::from,
         ),
     )(input)
 }
 
 fn level(input: &str) -> IResult<&str, Vec<UnitName>> {
     separated_list1(char(','), unit_name)(input)
 }
 
 fn unit_name(input: &str) -> IResult<&str, UnitName> {
     map(
         recognize(pair(alpha1, many0(alt((alphanumeric1, is_a("-_.@")))))),
         UnitName::from,
     )(input)
 }
 
 #[cfg(test)]
 mod tests {
     use crate::parser_test;
 
     use super::*;
 
     // TODO; we should have negative tests
     #[test]
     fn parse_unit_name() -> Result<(), Error<&'static str>> {
         parser_test!(
             unit_name,
             [
                 "foo" => UnitName::from("foo"),
                 "foo2" => UnitName::from("foo2"),
                 "foo_bar" => UnitName::from("foo_bar"),
                 "foo-bar" => UnitName::from("foo-bar"),
                 "foo@bar" => UnitName::from("foo@bar")
             ]
         );
 
         Ok(())
     }
 
     #[test]
     fn parse_level() -> Result<(), Error<&'static str>> {
         parser_test!(
             level,
             [
                 "foo,bar,baz" => vec![
                     UnitName::from("foo"),
                     UnitName::from("bar"),
                     UnitName::from("baz"),
                 ],
                 "foo" => vec![
                     UnitName::from("foo")
                 ]
             ]
         );
 
         Ok(())
     }
 
     #[test]
     fn parse_group_name() -> Result<(), Error<&'static str>> {
         parser_test!(
             group_name,
             [
                 ":foo" => Box::from("foo"),
                 ":foo2" => Box::from("foo2"),
                 ":foo_bar" => Box::from("foo_bar"),
                 ":foo-bar" => Box::from("foo-bar")
             ]
         );
 
         Ok(())
     }
 
     #[test]
     fn parse_group() -> Result<(), Error<&'static str>> {
         parser_test!(
             group,
             [
                 ":foo" => (Box::from("foo"), vec![]),
                 ":foo\nbar,baz" => (
                     Box::from("foo"),
                     vec![vec![UnitName::from("bar"), UnitName::from("baz")]]
                 )
             ]
         );
 
         Ok(())
     }
 
     #[test]
     fn parse_header() -> Result<(), Error<&'static str>> {
         parser_test!(
             header,
             [
                 "@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\n" => [0; 32],
                 "@AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=\n" => [1; 32]
             ]
         );
 
         Ok(())
     }
 
     #[test]
     fn parse_grouping() -> Result<(), Error<&'static str>> {
         parser_test!(
             grouping,
             [
                 "@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\n:sysboot\nprocfs,modules\nrun" => DependencyGrouping {
                     hash: [0; 32],
                     groups: HashMap::from([
                         (
                             Box::from("sysboot"),
                             vec![
                                 vec![UnitName::from("procfs"), UnitName::from("modules")],
                                 vec![UnitName::from("run")]
                             ]
                         )
                     ])
                 },
                 "@AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=\n:sysboot\nprocfs,modules\nrun\n:default\ngetty@tty1" => DependencyGrouping {
                     hash: [1; 32],
                     groups: HashMap::from([
                         (
                             Box::from("sysboot"),
                             vec![
                                 vec![UnitName::from("procfs"), UnitName::from("modules")],
                                 vec![UnitName::from("run")]
                             ]
                         ),
                         (
                             Box::from("default"),
                             vec![
                                 vec![UnitName::from("getty@tty1")]
                             ]
                         )
                     ])
                 }
             ]
         );
 
         Ok(())
     }
 
     #[test]
     fn display_grouping() {
         let grouping = DependencyGrouping {
             hash: [2; 32],
             groups: HashMap::from([
                 (
                     Box::from("sysboot"),
                     vec![
                         vec![UnitName::from("procfs"), UnitName::from("modules")],
                         vec![UnitName::from("run")],
                     ],
                 ),
                 (
                     Box::from("default"),
                     vec![
                         vec![UnitName::from("syslog")],
                         vec![UnitName::from("getty@tty1")],
                     ],
                 ),
             ]),
         };
 
         // hashmap ordering leads to 2 possible orderings
         let output = grouping.to_string();
 
         match output.as_str() {
             "@AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI=\n:default\nsyslog\ngetty@tty1\n:sysboot\nprocfs,modules\nrun\n"
             | "@AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI=\n:sysboot\nprocfs,modules\nrun\n:default\nsyslog\ngetty@tty1\n" =>
                 {}
             s => panic!("did not expect {s}"),
         }
     }
 }