fogti/zhed - Change 7WMS7RLPXYF47WXLZXY25VCUJOGL7XIDVQK6FGT27EHPG2JICDRQC

packlist: add support for parsing of multiple premarkers per item

Created by fogti on September 20, 2021

7WMS7RLPXYF47WXLZXY25VCUJOGL7XIDVQK6FGT27EHPG2JICDRQC

Dependencies

In channels

main

Change contents

Insertion in crates/zhed-packlist/src/serial.rs at line 1 [2.34]
[2.34]
[2.35]
```
use crate::{ItemData, PackList, Section};
```
Deletion in crates/zhed-packlist/src/serial.rs at line 3 [2.34]
B:BD[2.74] → [2.74:116]
```
use crate::{PackList, Section, ItemData};
```

Replacement in crates/zhed-packlist/src/serial.rs at line 45 [2.34]

B:BD[2.1532] → [2.1532:1808]

        macro_rules! commit { () => {{
            if sections.contains_key(&section.0) {
                return Err(Error::SectionOverwritten(section.0));
            }
            sections.insert(std::mem::take(&mut section.0), std::mem::take(&mut section.1));
        }} }

[2.1532]

[2.1808]

        macro_rules! commit {
            () => {{
                if sections.contains_key(&section.0) {
                    return Err(Error::SectionOverwritten(section.0));
                }
                sections.insert(
                    std::mem::take(&mut section.0),
                    std::mem::take(&mut section.1),
                );
            }};
        }

Insertion in crates/zhed-packlist/src/serial.rs at line 82 [2.34]
[2.2548]
[2.2548]
```
    let mkerr = || Error::InvalidItem(line.to_string());
```

Replacement in crates/zhed-packlist/src/serial.rs at line 84 [2.34]

B:BD[2.2572] → [2.2572:2630]

        return Err(Error::InvalidItem(line.to_string()));

[2.2572]

[2.2630]

        return Err(mkerr());
    }
    let mut it = line.chars().peekable();
    // parse premarkers
    let mut premarkers = Vec::new();
    while it.next_if(|i| *i == '[').is_some() {
        let premarker = it.next().ok_or_else(mkerr)?;
        let _ = it.next().ok_or_else(mkerr)?;
        let c2 = it.next().ok_or_else(mkerr)?;
        if c2 != ']' {
            return Err(mkerr());
        }
        premarkers.push(premarker);
        while it.next_if(|i| i.is_whitespace()).is_some() {}

Replacement in crates/zhed-packlist/src/serial.rs at line 100 [2.34]

B:BD[2.2636] → [2.2636:2895]

    let mut it = line.chars();
    let c1 = it.next().unwrap();
    let premarker = it.next().unwrap();
    let _ = it.next().unwrap();
    let c2 = it.next().unwrap();
    if c1 != '[' || c2 != ']' {
        return Err(Error::InvalidItem(line.to_string()));

[2.2636]

[2.2895]

    if premarkers.is_empty() {
        return Err(mkerr());

Deletion in crates/zhed-packlist/src/serial.rs at line 103 [2.34]

B:BD[2.2901] → [2.2901:2990]

    let mut it = it.peekable();
    while it.next_if(|i| i.is_whitespace()).is_some() {}

Deletion in crates/zhed-packlist/src/serial.rs at line 115 [2.34]

B:BD[2.3382] → [2.3382:3475]

    }
    while it.next_if(|i| i.is_whitespace()).is_some() {}
    if multiplier.is_none() {

Insertion in crates/zhed-packlist/src/serial.rs at line 116 [2.34]

[2.3493]

    } else {
        while it.next_if(|i| i.is_whitespace()).is_some() {}

Replacement in crates/zhed-packlist/src/serial.rs at line 120 [2.34]

B:BD[2.3500] → [2.3500:3605]

    Ok((ItemData {
        premarker,
        multiplier: multiplier.unwrap_or(1),
    }, it.collect()))

[2.3500]

[2.3605]

    Ok((
        ItemData {
            premarkers,
            multiplier: multiplier.unwrap_or(1),
        },
        it.collect(),
    ))

Replacement in crates/zhed-packlist/src/serial.rs at line 138 [2.34]

B:BD[2.3937] → [2.3937:4212]

                writeln!(f)?;
                write!(f, "[{} ] ", sdata.summary.premarker)?;
                if sdata.summary.multiplier != 1 {
                    write!(f, "{}x ", sdata.summary.multiplier)?;
                }
                writeln!(f, "# {}", section)?;

[2.3937]

[2.4212]

                writeln!(f, "\n{}# {}", sdata.summary, section)?;

Replacement in crates/zhed-packlist/src/serial.rs at line 141 [2.34]

B:BD[2.4265] → [2.4265:4486]

                write!(f, "[{} ] ", item.0.premarker)?;
                if item.0.multiplier != 1 {
                    write!(f, "{}x ", item.0.multiplier)?;
                }
                writeln!(f, "{}", item.1)?;

[2.4265]

[2.4486]

                writeln!(f, "{}{}", item.0, item.1)?;

Insertion in crates/zhed-packlist/src/serial.rs at line 143 [2.34]

[2.4500]

        }
        Ok(())
    }
}
impl fmt::Display for ItemData {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        for i in &self.premarkers {
            write!(f, "[{} ] ", i)?;

Insertion in crates/zhed-packlist/src/serial.rs at line 153 [2.34]

[2.4510]

        if self.multiplier != 1 {
            write!(f, "{}x ", self.multiplier)?;
        }

Insertion in crates/zhed-packlist/src/serial.rs at line 163 [2.34]
[2.4577]
[2.4577]

Replacement in crates/zhed-packlist/src/serial.rs at line 184 [2.34]

B:BD[2.5021] → [2.5021:5587]

        sections.insert(String::new(), Section {
            summary: ItemData::default(),
            items: vec![
                (ItemData { premarker: ' ', multiplier: 1 }, "15 Ruß".to_string()),
                (ItemData { premarker: ' ', multiplier: 132 }, "Wattestäbe".to_string()),
                (ItemData { premarker: '#', multiplier: 0 }, "Handtuch".to_string()),
            ],
        });
        sections.insert("Wachsbaum ...".to_string(), Section {
            summary: ItemData {
                premarker: '-',
                multiplier: 5000,

[2.5021]

[2.5587]

        sections.insert(
            String::new(),
            Section {
                summary: ItemData::default(),
                items: vec![
                    (
                        ItemData {
                            premarkers: vec![' '],
                            multiplier: 1,
                        },
                        "15 Ruß".to_string(),
                    ),
                    (
                        ItemData {
                            premarkers: vec![' '],
                            multiplier: 132,
                        },
                        "Wattestäbe".to_string(),
                    ),
                    (
                        ItemData {
                            premarkers: vec!['#'],
                            multiplier: 0,
                        },
                        "Handtuch".to_string(),
                    ),
                ],

Replacement in crates/zhed-packlist/src/serial.rs at line 212 [2.34]

B:BD[2.5602] → [2.5602:5836]

            items: vec![
                (ItemData { premarker: ' ', multiplier: 1 }, "Ranke".to_string()),
                (ItemData { premarker: '*', multiplier: 1 }, "5 x Metrik + BNaumbnd".to_string()),
            ],
        });

[2.5602]

[2.5836]

        );
        sections.insert(
            "Wachsbaum ...".to_string(),
            Section {
                summary: ItemData {
                    premarkers: vec!['-'],
                    multiplier: 5000,
                },
                items: vec![
                    (
                        ItemData {
                            premarkers: vec![' '],
                            multiplier: 1,
                        },
                        "Ranke".to_string(),
                    ),
                    (
                        ItemData {
                            premarkers: vec!['*'],
                            multiplier: 1,
                        },
                        "5 x Metrik + BNaumbnd".to_string(),
                    ),
                ],
            },
        );

Replacement in crates/zhed-packlist/src/serial.rs at line 250 [2.34]

B:BD[2.6204] → [2.6204:6509]

        assert_eq!("Packl (xyz) ...\n".parse::<PackList>(), Err(Error::DataAfterRangeSpec));
        assert_eq!("P\n[  ] # 1\n[  ] # 1\n".parse::<PackList>(), Err(Error::SectionOverwritten("1".to_string())));
        assert_eq!("P\n[  ]".parse::<PackList>(), Err(Error::InvalidItem("[  ]".to_string())));

[2.6204]

[2.6509]

        assert_eq!(
            "Packl (xyz) ...\n".parse::<PackList>(),
            Err(Error::DataAfterRangeSpec)
        );
        assert_eq!(
            "P\n[  ] # 1\n[  ] # 1\n".parse::<PackList>(),
            Err(Error::SectionOverwritten("1".to_string()))
        );
        assert_eq!(
            "P\n[  ]".parse::<PackList>(),
            Err(Error::InvalidItem("[  ]".to_string()))
        );
    }
    #[test]
    fn ex1() {
        let inp1 = r#"Packliste Ölland:
[* ] [ _] [. ] 15 132x Ruß
[* ] [ _] [. ] 132x Ruß
"#;
        let inp2 = r#"Packliste Ölland
[* ] [  ] [. ] 15 132x Ruß
[* ] [  ] [. ] 132x Ruß
"#;
        let mut sections = BTreeMap::new();
        sections.insert(
            String::new(),
            Section {
                summary: ItemData::default(),
                items: vec![
                    (
                        ItemData {
                            premarkers: vec!['*', ' ', '.'],
                            multiplier: 1,
                        },
                        "15 132x Ruß".to_string(),
                    ),
                    (
                        ItemData {
                            premarkers: vec!['*', ' ', '.'],
                            multiplier: 132,
                        },
                        "Ruß".to_string(),
                    ),
                ],
            },
        );
        let res = PackList {
            name: "Packliste Ölland".to_string(),
            range: String::new(),
            sections,
        };
        assert_eq!(inp1.parse::<PackList>().unwrap(), res);
        assert_eq!(inp2.parse::<PackList>().unwrap(), res);
        assert_eq!(res.to_string(), inp2);

Replacement in crates/zhed-packlist/src/lib.rs at line 21 [3.73]
B:BD[3.511] → [3.511:536]
```
    pub premarker: char,
```
[3.511]
[3.536]
```
    pub premarkers: Vec<char>,
```
Replacement in crates/zhed-packlist/src/lib.rs at line 28 [3.73]
B:BD[3.634] → [3.634:662]
```
            premarker: ' ',
```
[3.634]
[3.662]
```
            premarkers: vec![' '],
```

Replacement in crates/zhed-packlist/src/lib.rs at line 36 [3.73]

B:BD[3.765] → [3.765:838]

        self.sections.values_mut().for_each(|sd| sd.reset_premarkers());

[3.765]

[3.838]

        self.sections
            .values_mut()
            .for_each(|sd| sd.reset_premarkers());

Replacement in crates/zhed-packlist/src/lib.rs at line 44 [3.73]

B:BD[3.903] → [3.903:1012]

        self.summary.premarker = ' ';
        self.items.iter_mut().for_each(|item| item.0.premarker = ' ');

[3.903]

[3.1012]

        core::iter::once(&mut self.summary)
            .chain(self.items.iter_mut().map(|item| &mut item.0))
            .flat_map(|item| item.premarkers.iter_mut())
            .for_each(|i| *i = ' ');

Replacement in crates/zhed-packlist/src/lib.rs at line 58 [3.73]

B:BD[3.1138] → [3.1138:1704]

        sections.insert(String::new(), Section {
            summary: ItemData::default(),
            items: vec![
                (ItemData { premarker: ' ', multiplier: 1 }, "15 Ruß".to_string()),
                (ItemData { premarker: ' ', multiplier: 132 }, "Wattestäbe".to_string()),
                (ItemData { premarker: '#', multiplier: 0 }, "Handtuch".to_string()),
            ],
        });
        sections.insert("Wachsbaum ...".to_string(), Section {
            summary: ItemData {
                premarker: '-',
                multiplier: 5000,

[3.1138]

[3.1704]

        sections.insert(
            String::new(),
            Section {
                summary: ItemData::default(),
                items: vec![
                    (
                        ItemData {
                            premarkers: vec![' '],
                            multiplier: 1,
                        },
                        "15 Ruß".to_string(),
                    ),
                    (
                        ItemData {
                            premarkers: vec![' '],
                            multiplier: 132,
                        },
                        "Wattestäbe".to_string(),
                    ),
                    (
                        ItemData {
                            premarkers: vec!['#'],
                            multiplier: 0,
                        },
                        "Handtuch".to_string(),
                    ),
                ],

Replacement in crates/zhed-packlist/src/lib.rs at line 86 [3.73]

B:BD[3.1719] → [3.1719:1953]

            items: vec![
                (ItemData { premarker: ' ', multiplier: 1 }, "Ranke".to_string()),
                (ItemData { premarker: '*', multiplier: 1 }, "5 x Metrik + BNaumbnd".to_string()),
            ],
        });

[3.1719]

[3.1953]

        );
        sections.insert(
            "Wachsbaum ...".to_string(),
            Section {
                summary: ItemData {
                    premarkers: vec!['-'],
                    multiplier: 5000,
                },
                items: vec![
                    (
                        ItemData {
                            premarkers: vec![' '],
                            multiplier: 1,
                        },
                        "Ranke".to_string(),
                    ),
                    (
                        ItemData {
                            premarkers: vec!['*'],
                            multiplier: 1,
                        },
                        "5 x Metrik + BNaumbnd".to_string(),
                    ),
                ],
            },
        );

Replacement in crates/zhed-packlist/src/lib.rs at line 118 [3.73]

B:BD[3.2171] → [3.2171:2739]

        sections2.insert(String::new(), Section {
            summary: ItemData::default(),
            items: vec![
                (ItemData { premarker: ' ', multiplier: 1 }, "15 Ruß".to_string()),
                (ItemData { premarker: ' ', multiplier: 132 }, "Wattestäbe".to_string()),
                (ItemData { premarker: ' ', multiplier: 0 }, "Handtuch".to_string()),
            ],
        });
        sections2.insert("Wachsbaum ...".to_string(), Section {
            summary: ItemData {
                premarker: ' ',
                multiplier: 5000,

[3.2171]

[3.2739]

        sections2.insert(
            String::new(),
            Section {
                summary: ItemData::default(),
                items: vec![
                    (
                        ItemData {
                            premarkers: vec![' '],
                            multiplier: 1,
                        },
                        "15 Ruß".to_string(),
                    ),
                    (
                        ItemData {
                            premarkers: vec![' '],
                            multiplier: 132,
                        },
                        "Wattestäbe".to_string(),
                    ),
                    (
                        ItemData {
                            premarkers: vec![' '],
                            multiplier: 0,
                        },
                        "Handtuch".to_string(),
                    ),
                ],
            },
        );
        sections2.insert(
            "Wachsbaum ...".to_string(),
            Section {
                summary: ItemData {
                    premarkers: vec![' '],
                    multiplier: 5000,
                },
                items: vec![
                    (
                        ItemData {
                            premarkers: vec![' '],
                            multiplier: 1,
                        },
                        "Ranke".to_string(),
                    ),
                    (
                        ItemData {
                            premarkers: vec![' '],
                            multiplier: 1,
                        },
                        "5 x Metrik + BNaumbnd".to_string(),
                    ),
                ],

Replacement in crates/zhed-packlist/src/lib.rs at line 171 [3.73]

B:BD[3.2754] → [3.2754:2988]

            items: vec![
                (ItemData { premarker: ' ', multiplier: 1 }, "Ranke".to_string()),
                (ItemData { premarker: ' ', multiplier: 1 }, "5 x Metrik + BNaumbnd".to_string()),
            ],
        });

[3.2754]

[3.2988]

);

Replacement in crates/zhed-packlist/Cargo.toml at line 7 [3.3276]
B:BD[3.3361] → [3.3361:3382]
```
thiserror = "1.0.26"
```
[3.3361]
```
thiserror = "1.0"
```