fogti/zhed - Change VHLGEBT74I5RXLGUWMVCXM64BYG7HOOFT7SURJ5TCTB3AAOQHIKQC

packlist: less normalization to support proper roundtrips (which only truncate trailing spaces)

Created by fogti on September 21, 2021

VHLGEBT74I5RXLGUWMVCXM64BYG7HOOFT7SURJ5TCTB3AAOQHIKQC

Dependencies

In channels

main

Change contents

Replacement in crates/zhed-packlist/src/serial.rs at line 1 [4.34]

B:BD[4.34] → [5.0:42]

∅:D[5.42] → [4.35:74]

B:BD[4.34] → [4.35:74]

use crate::{ItemData, PackList, Section};
use std::{collections::BTreeMap, fmt};

[4.34]

[4.116]

use crate::{Item, ItemDetails, PackList, Spaced};
use alloc::{string::ToString, vec::Vec};
use core::fmt;

Replacement in crates/zhed-packlist/src/serial.rs at line 5 [4.34]

B:BD[4.117] → [4.117:167]

#[derive(thiserror::Error, Debug, PartialEq, Eq)]

[4.117]

[4.167]

#[derive(Debug, PartialEq, Eq)]
#[cfg_attr(feature = "std", derive(thiserror::Error))]

Replacement in crates/zhed-packlist/src/serial.rs at line 8 [4.34]

B:BD[4.184] → [4.184:417]

B:BD[4.417] → [2.0:31]

    #[error("unexpected data after range specification in header")]
    DataAfterRangeSpec,
    #[error("section is defined multiple times")]
    SectionOverwritten(String),
    #[error("invalid item: {0}")]
    InvalidItem(String),
    #[error("unexpected EOF")]

[4.184]

[2.31]

    /// ```
    /// use zhed_packlist::{PackList, ParseError};
    /// assert_eq!("".parse::<PackList>(), Err(ParseError::UnexpectedEof));
    /// ```
    #[cfg_attr(feature = "std", error("unexpected EOF"))]

Replacement in crates/zhed-packlist/src/serial.rs at line 16 [4.34]
B:BD[4.420] → [4.420:458]
```
impl std::str::FromStr for PackList {
```
[4.420]
[4.458]
```
impl core::str::FromStr for PackList {
```
Replacement in crates/zhed-packlist/src/serial.rs at line 20 [4.34]
B:BD[4.531] → [4.531:563]
```
        let mut it = s.lines();
```
[4.531]
[4.563]
```
        let mut it = s.lines().map(|i| i.trim_end());
```

Replacement in crates/zhed-packlist/src/serial.rs at line 22 [4.34]

B:BD[4.564] → [4.564:609]

B:BD[4.609] → [2.51:131]

∅:D[2.131] → [4.658:1399]

B:BD[4.658] → [4.658:1399]

        // 1st line: packlist name and range
        let mut fst = it.next().map(|x| x.trim()).ok_or(Error::UnexpectedEof)?;
        if let Some(x) = fst.strip_suffix(':') {
            fst = x;
        }
        let (name, range) = {
            let (rstart, rend) = (fst.find('('), fst.rfind(')'));
            if rstart.is_some() && rend.is_some() && rstart.unwrap() < rend.unwrap() {
                let (rstart, rend) = (rstart.unwrap(), rend.unwrap());
                if rend != (fst.len() - 1) {
                    return Err(Error::DataAfterRangeSpec);
                }
                let mut name = fst[..rstart].trim();
                if let Some(x) = name.strip_suffix(':') {
                    name = x.trim();
                }
                (name, &fst[rstart + 1..rend])
            } else {
                (fst, "")
            }
        };

[4.564]

[4.1399]

        // 1st line: packlist name
        let name = it.next().ok_or(Error::UnexpectedEof)?;

Replacement in crates/zhed-packlist/src/serial.rs at line 26 [4.34]

B:BD[4.1425] → [4.1425:1532]

B:BD[4.1532] → [5.43:419]

∅:D[5.419] → [4.1808:2344]

B:BD[4.1808] → [4.1808:2344]

        let mut sections = BTreeMap::new();
        let mut section = (String::new(), Section::default());
        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),
                );
            }};
        }
        for line in it {
            if line.trim().is_empty() {
                continue;
            }
            let (itemdata, desc) = parse_item(line)?;
            if let Some(x) = desc.strip_prefix('#') {
                commit!();
                section.0 = x.trim().to_string();
                section.1.summary = itemdata;
            } else {
                section.1.items.push((itemdata, desc));
            }
        }
        if !section.0.is_empty() || !section.1.items.is_empty() {
            commit!();
        }

[4.1425]

[4.2344]

        let items = it
            .map(|line| match line.parse() {
                Ok(x) => x,
                Err(x) => match x {},
            })
            .collect();

Replacement in crates/zhed-packlist/src/serial.rs at line 35 [4.34]

B:BD[4.2403] → [4.2403:2463]

            range: range.to_string(),
            sections,

[4.2403]

[4.2463]

            items,
        })
    }
}
impl core::str::FromStr for Item {
    type Err = core::convert::Infallible;
    fn from_str(line: &str) -> Result<Self, core::convert::Infallible> {
        let (det, text) = parse_itemdet(line)
            .map(|(det, rest)| (Some(det), rest))
            .unwrap_or((None, line));
        Ok(Self {
            det,
            text: text.to_string(),

Replacement in crates/zhed-packlist/src/serial.rs at line 54 [4.34]

B:BD[4.2483] → [4.2483:2548]

B:BD[4.2548] → [5.420:477]

fn parse_item(line: &str) -> Result<(ItemData, String), Error> {
    let mkerr = || Error::InvalidItem(line.to_string());

[4.2483]

[4.2548]

fn parse_itemdet(mut line: &str) -> Option<(ItemDetails, &str)> {

Replacement in crates/zhed-packlist/src/serial.rs at line 56 [4.34]
B:BD[4.2572] → [5.478:507]
```
        return Err(mkerr());
```
[4.2572]
[5.507]
```
        return None;
```

Replacement in crates/zhed-packlist/src/serial.rs at line 58 [4.34]

B:BD[5.513] → [5.513:555]

    let mut it = line.chars().peekable();

[5.513]

[5.555]

    let mut ret = ItemDetails {
        markers: Vec::new(),
        multiplier: None,
    };

Replacement in crates/zhed-packlist/src/serial.rs at line 63 [4.34]

B:BD[5.556] → [5.556:868]

    // 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());

[5.556]

[5.868]

    // parse markers
    while let Some(x) = line.strip_prefix('[') {
        let mut it = x.chars();
        let a = it.next()?;
        let b = it.next()?;
        if ']' != it.next()? {
            return None;

Replacement in crates/zhed-packlist/src/serial.rs at line 71 [4.34]

B:BD[5.878] → [5.878:975]

        premarkers.push(premarker);
        while it.next_if(|i| i.is_whitespace()).is_some() {}

[5.878]

[4.2630]

        line = it.as_str();
        let wsl = it
            .take_while(|i| i.is_whitespace())
            .map(|i| i.len_utf8())
            .sum::<usize>();
        let (space, rest) = line.split_at(wsl);
        ret.markers.push(Spaced {
            val: [a, b],
            space: space.to_string(),
        });
        line = rest;

Replacement in crates/zhed-packlist/src/serial.rs at line 83 [4.34]

B:BD[4.2636] → [5.976:1036]

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

[4.2636]

[4.2895]

    if ret.markers.is_empty() {
        return None;

Replacement in crates/zhed-packlist/src/serial.rs at line 87 [4.34]

B:BD[4.2991] → [4.2991:3382]

B:BD[4.3475] → [4.3475:3493]

B:BD[4.3493] → [5.1037:1111]

    // check for multiplier
    // btp : backtrack point if no valid multiplier is found
    let btp = it.clone();
    let mut multiplier = None;
    while let Some(x) = it.next_if(|i| i.is_ascii_digit()) {
        let m = multiplier.get_or_insert(0);
        *m *= 10;
        *m += u32::from((x as u8) - b'0');
    }
    if it.next_if(|&i| i == 'x').is_none() {
        multiplier = None;
        it = btp;
    } else {
        while it.next_if(|i| i.is_whitespace()).is_some() {}

[4.2991]

[4.3493]

    if let Some((val, space, rest)) = parse_multiplier(line) {
        ret.multiplier = Some(Spaced {
            val,
            space: space.to_string(),
        });
        line = rest;

Replacement in crates/zhed-packlist/src/serial.rs at line 95 [4.34]

B:BD[4.3500] → [5.1112:1253]

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

[4.3500]

[4.3605]

    Some((ret, line))

Replacement in crates/zhed-packlist/src/serial.rs at line 98 [4.34]

B:BD[4.3608] → [4.3608:3937]

B:BD[4.3937] → [5.1254:1320]

impl fmt::Display for PackList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&self.name)?;
        if !self.range.is_empty() {
            write!(f, " ({})", self.range)?;
        }
        writeln!(f)?;
        for (section, sdata) in &self.sections {
            if !section.is_empty() {
                writeln!(f, "\n{}# {}", sdata.summary, section)?;

[4.3608]

[4.4212]

fn parse_multiplier(line: &str) -> Option<(u32, &str, &str)> {
    if !line.starts_with(|i: char| i.is_ascii_digit()) {
        return None;
    }
    let mut multiplier = 0;
    let mut it = line.chars();
    loop {
        match it.next() {
            Some('x') => {
                let tmp = it.as_str();
                let wsl = it
                    .take_while(|i| i.is_whitespace())
                    .map(|i| i.len_utf8())
                    .sum::<usize>();
                let (a, b) = tmp.split_at(wsl);
                return Some((multiplier, a, b));

Replacement in crates/zhed-packlist/src/serial.rs at line 115 [4.34]

B:BD[4.4226] → [4.4226:4265]

B:BD[4.4265] → [5.1321:1375]

            for item in &sdata.items {
                writeln!(f, "{}{}", item.0, item.1)?;

[4.4226]

[4.4486]

            Some(i) if i.is_ascii_digit() => {
                multiplier *= 10;
                multiplier += u32::from((i as u8) - b'0');

Insertion in crates/zhed-packlist/src/serial.rs at line 119 [4.34]

[4.4500]

[5.1376]

            _ => return None,
        }
    }
}
impl fmt::Display for PackList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        writeln!(f, "{}", self.name.trim_end())?;
        for item in &self.items {
            writeln!(f, "{}", item)?;

Replacement in crates/zhed-packlist/src/serial.rs at line 134 [4.34]
B:BD[5.1410] → [5.1410:1443]
```
impl fmt::Display for ItemData {
```
[5.1410]
[5.1443]
```
impl fmt::Display for Item {
```

Replacement in crates/zhed-packlist/src/serial.rs at line 136 [4.34]

B:BD[5.1506] → [5.1506:1579]

        for i in &self.premarkers {
            write!(f, "[{} ] ", i)?;

[5.1506]

[4.4500]

        if let Some(x) = &self.det {
            fmt::Display::fmt(x, f)?;

Replacement in crates/zhed-packlist/src/serial.rs at line 139 [4.34]

B:BD[4.4510] → [5.1580:1663]

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

[4.4510]

[5.1663]

        f.write_str(self.text.trim_end())
    }
}
impl fmt::Display for ItemDetails {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        for m in &self.markers {
            write!(f, "[{}{}]{}", m.val[0], m.val[1], m.space)?;
        }
        if let Some(x) = &self.multiplier {
            write!(f, "{}x{}", x.val, x.space)?;

Insertion in crates/zhed-packlist/src/serial.rs at line 158 [4.34]
[4.4577]
[2.132]
```
    use alloc::{string::String, vec};
```

Deletion in crates/zhed-packlist/src/serial.rs at line 160 [4.34]

∅:D[2.162] → [5.1674:1675]

B:BD[4.4577] → [5.1674:1675]

∅:D[5.1675] → [4.4577:5021]

B:BD[4.4577] → [4.4577:5021]

B:BD[4.5021] → [5.1676:2595]

∅:D[5.2595] → [4.5587:5602]

B:BD[4.5587] → [4.5587:5602]

B:BD[4.5602] → [5.2596:3413]

∅:D[5.3413] → [4.5836:6204]

B:BD[4.5836] → [4.5836:6204]

B:BD[4.6204] → [5.3414:3827]


    #[test]
    fn ex0() {
        let inp1 = r#"Packliste Ölland (80 Tage, 50 Nächtsle):
[  ] 15 Ruß
[  ] 132x Wattestäbe
[# ] 0x Handtuch
[- ] 5000x # Wachsbaum ... 
[  ] Ranke
[* ] 5 x Metrik + BNaumbnd
"#;
        let inp2 = r#"Packliste Ölland (80 Tage, 50 Nächtsle)
[  ] 15 Ruß
[  ] 132x Wattestäbe
[# ] 0x Handtuch
[- ] 5000x # Wachsbaum ...
[  ] Ranke
[* ] 5 x Metrik + BNaumbnd
"#;
        let mut sections = BTreeMap::new();
        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(),
                    ),
                ],
            },
        );
        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(),
                    ),
                ],
            },
        );
        let res = PackList {
            name: "Packliste Ölland".to_string(),
            range: "80 Tage, 50 Nächtsle".to_string(),
            sections,
        };
        assert_eq!(inp1.parse::<PackList>().unwrap(), res);
        assert_eq!(inp2.parse::<PackList>().unwrap(), res);
        assert_eq!(res.to_string(), inp2);
    }
    #[test]
    fn fail0() {
        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()))
        );
    }

Deletion in crates/zhed-packlist/src/serial.rs at line 162 [4.34]

B:BD[5.3840] → [2.163:270]

    fn fail1() {
        assert_eq!("".parse::<PackList>(), Err(Error::UnexpectedEof));
    }
    #[test]

Replacement in crates/zhed-packlist/src/serial.rs at line 163 [4.34]

B:BD[5.3855] → [5.3855:3924]

        let inp1 = r#"Packliste Ölland:
[* ] [ _] [. ] 15 132x Ruß

[5.3855]

[5.3924]

        let inp = r#"Packliste Ölland:

Replacement in crates/zhed-packlist/src/serial.rs at line 166 [4.34]

B:BD[5.3953] → [5.3953:4404]

        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,

[5.3953]

[5.4404]

        let res = PackList {
            name: "Packliste Ölland:".to_string(),
            items: vec![Item {
                det: Some(ItemDetails {
                    markers: vec![
                        Spaced {
                            val: ['*', ' '],
                            space: " ".to_string(),

Replacement in crates/zhed-packlist/src/serial.rs at line 175 [4.34]

B:BD[5.4431] → [5.4431:4669]

                        "15 132x Ruß".to_string(),
                    ),
                    (
                        ItemData {
                            premarkers: vec!['*', ' ', '.'],
                            multiplier: 132,

[5.4431]

[5.4669]

                        Spaced {
                            val: [' ', '_'],
                            space: " ".to_string(),

Replacement in crates/zhed-packlist/src/serial.rs at line 179 [4.34]

B:BD[5.4696] → [5.4696:4944]

                        "Ruß".to_string(),
                    ),
                ],
            },
        );
        let res = PackList {
            name: "Packliste Ölland".to_string(),
            range: String::new(),
            sections,

[5.4696]

[5.4944]

                        Spaced {
                            val: ['.', ' '],
                            space: " ".to_string(),
                        },
                    ],
                    multiplier: Some(Spaced {
                        val: 132,
                        space: " ".to_string(),
                    }),
                }),
                text: "Ruß".to_string(),
            }],

Replacement in crates/zhed-packlist/src/serial.rs at line 192 [4.34]

B:BD[5.4955] → [5.4955:5118]

        assert_eq!(inp1.parse::<PackList>().unwrap(), res);
        assert_eq!(inp2.parse::<PackList>().unwrap(), res);
        assert_eq!(res.to_string(), inp2);

[5.4955]

[2.271]

        assert_eq!(inp.parse::<PackList>().unwrap(), res);
        assert_eq!(res.to_string(), inp);

Insertion in crates/zhed-packlist/src/serial.rs at line 201 [4.34]

[2.403]

[4.6509]


        #[test]
        fn correctly_trimmed(s in "(?s:.+)") {
            let s2: String = s.lines().flat_map(|i| i.trim_end().chars().chain(core::iter::once('\n'))).collect();
            let x1 = s.parse::<PackList>().unwrap();
            let x2 = s2.parse::<PackList>().unwrap();
            assert_eq!(x1, x2);
        }
        #[test]
        fn roundtrip(s in "(?s:[^\r]+\n)".prop_filter("line ends are trimmed", |v| v.lines().all(|l| l == l.trim_end()))) {
            assert_eq!(s, s.parse::<PackList>().unwrap().to_string());
        }

Replacement in crates/zhed-packlist/src/lib.rs at line 1 [6.73]

B:BD[6.73] → [6.74:106]

use std::collections::BTreeMap;

[6.73]

[6.106]

#![cfg_attr(not(feature = "std"), no_std)]
#![forbid(
    unsafe_code,
    clippy::as_conversions,
    clippy::cast_ptr_alignment,
    trivial_casts,
    unconditional_recursion
)]
extern crate alloc;
use alloc::{string::String, vec, vec::Vec};

Replacement in crates/zhed-packlist/src/lib.rs at line 19 [6.73]

B:BD[6.240] → [6.240:308]

    pub range: String,
    pub sections: BTreeMap<String, Section>,

[6.240]

[6.308]

    pub items: Vec<Item>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Item {
    pub det: Option<ItemDetails>,
    pub text: String,

Replacement in crates/zhed-packlist/src/lib.rs at line 28 [6.73]

B:BD[6.311] → [6.311:447]

#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Section {
    pub summary: ItemData,
    pub items: Vec<(ItemData, String)>,

[6.311]

[6.447]

/// packlist item details
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ItemDetails {
    pub markers: Vec<Spaced<[char; 2]>>,
    pub multiplier: Option<Spaced<u32>>,

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

B:BD[6.489] → [6.489:511]

B:BD[6.511] → [5.5119:5150]

∅:D[5.5150] → [6.536:561]

B:BD[6.536] → [6.536:561]

pub struct ItemData {
    pub premarkers: Vec<char>,
    pub multiplier: u32,

[6.489]

[6.561]

pub struct Spaced<T> {
    pub val: T,
    // white space folloing the value
    pub space: String,

Replacement in crates/zhed-packlist/src/lib.rs at line 42 [6.73]
B:BD[6.564] → [6.564:592]
```
impl Default for ItemData {
```
[6.564]
[6.592]
```
impl Default for ItemDetails {
```

Replacement in crates/zhed-packlist/src/lib.rs at line 45 [6.73]

B:BD[6.634] → [5.5151:5186]

∅:D[5.5186] → [6.662:689]

B:BD[6.662] → [6.662:689]

            premarkers: vec![' '],
            multiplier: 1,

[6.634]

[6.689]

            markers: vec![Spaced {
                val: [' ', ' '],
                space: String::new(),
            }],
            multiplier: None,

Replacement in crates/zhed-packlist/src/lib.rs at line 54 [6.73]

B:BD[6.708] → [6.708:765]

B:BD[6.765] → [5.5187:5286]

∅:D[5.5286] → [6.838:844]

B:BD[6.838] → [6.838:844]

impl PackList {
    pub fn reset_premarkers(&mut self) {
        self.sections
            .values_mut()
            .for_each(|sd| sd.reset_premarkers());
    }

[6.708]

[6.844]

pub trait Commands {
    fn reset_markers(&mut self);
}
pub mod prelude {
    pub use crate::Commands as _;

Replacement in crates/zhed-packlist/src/lib.rs at line 62 [6.73]

B:BD[6.847] → [6.847:903]

B:BD[6.903] → [5.5287:5491]

impl Section {
    pub fn reset_premarkers(&mut self) {
        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 = ' ');

[6.847]

[6.1012]

impl Commands for PackList {
    fn reset_markers(&mut self) {
        self.items.iter_mut().for_each(|i| i.reset_markers());

Replacement in crates/zhed-packlist/src/lib.rs at line 68 [6.73]

B:BD[6.1021] → [6.1021:1064]

#[cfg(test)]
mod tests {
    use super::*;

[6.1021]

[6.1064]

impl Commands for Item {
    fn reset_markers(&mut self) {
        if let Some(x) = &mut self.det {
            x.reset_markers();
        }
    }
}

Replacement in crates/zhed-packlist/src/lib.rs at line 76 [6.73]

B:BD[6.1065] → [6.1065:1138]

B:BD[6.1138] → [5.5492:6411]

∅:D[5.6411] → [6.1704:1719]

B:BD[6.1704] → [6.1704:1719]

B:BD[6.1719] → [5.6412:7229]

∅:D[5.7229] → [6.1953:2171]

B:BD[6.1953] → [6.1953:2171]

B:BD[6.2171] → [5.7230:8957]

∅:D[5.8957] → [6.2739:2754]

B:BD[6.2739] → [6.2739:2754]

B:BD[6.2754] → [5.8958:8969]

∅:D[5.8969] → [6.2988:3232]

B:BD[6.2988] → [6.2988:3232]

    #[test]
    fn ex0rs() {
        let mut sections = BTreeMap::new();
        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(),
                    ),
                ],
            },
        );
        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(),
                    ),
                ],
            },
        );
        let mut res = PackList {
            name: "Packliste Ölland".to_string(),
            range: "80 Tage, 50 Nächtsle".to_string(),
            sections,
        };
        let mut sections2 = BTreeMap::new();
        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(),
                    ),
                ],
            },
        );
        let res2 = PackList {
            name: "Packliste Ölland".to_string(),
            range: "80 Tage, 50 Nächtsle".to_string(),
            sections: sections2,
        };
        res.reset_premarkers();
        assert_eq!(res, res2);

[6.1065]

[6.3232]

impl Commands for ItemDetails {
    fn reset_markers(&mut self) {
        self.markers.iter_mut().for_each(|i| i.val = [' ', ' ']);

Insertion in crates/zhed-packlist/src/bin/zhed-packlist-reset.rs at line 2 [3.63]
[3.83]
[3.83]
```
use zhed_packlist::prelude::*;
```

Replacement in crates/zhed-packlist/src/bin/zhed-packlist-reset.rs at line 8 [3.63]

B:BD[3.178] → [3.178:277]

    std::io::stdin().lock().read_to_string(&mut inp).expect("unable to read packlist from stdin");

[3.178]

[3.277]

    std::io::stdin()
        .lock()
        .read_to_string(&mut inp)
        .expect("unable to read packlist from stdin");

Replacement in crates/zhed-packlist/src/bin/zhed-packlist-reset.rs at line 13 [3.63]
B:BD[3.367] → [3.367:394]
```
    pl.reset_premarkers();
```
[3.367]
[3.394]
```
    pl.reset_markers();
```
Replacement in crates/zhed-packlist/Cargo.toml at line 7 [6.3276]
B:BD[6.3361] → [5.8970:8988]
```
thiserror = "1.0"
```
[6.3361]
[2.404]
```
[dependencies.thiserror]
version = "1.0"
optional = true
```
Insertion in crates/zhed-packlist/Cargo.toml at line 14 [6.3276]
[2.441]
```
[features]
std = [ "thiserror" ]
```