sayit 0.3.0

String replacements using regex
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::intensity::Intensity;

use std::{borrow::Cow, error::Error, fmt};

/// Replaces patterns in text according to rules
#[derive(Debug)]
#[cfg_attr(test, derive(PartialEq))]
pub struct Accent {
    // a set of rules for each intensity level, sorted from lowest to highest
    pub(crate) intensities: Vec<Intensity>,
}

#[derive(Debug, PartialEq)]
pub enum CreationError {
    IntensityZeroMissing,
    FirstIntensityNotZero,
    UnsortedOrDuplicatedIntensities(u64),
}

impl fmt::Display for CreationError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CreationError::IntensityZeroMissing => {
                write!(f, "expected at least a base intensity 0")
            }
            CreationError::FirstIntensityNotZero => {
                write!(f, "first intensity must have level 0")
            }
            CreationError::UnsortedOrDuplicatedIntensities(level) => {
                write!(f, "duplicated or out of order intensity level {level}")
            }
        }
    }
}

impl Error for CreationError {}

impl Accent {
    /// Returns all registered intensities in ascending order. Note that there may be gaps
    pub fn intensities(&self) -> Vec<u64> {
        self.intensities.iter().rev().map(|i| i.level).collect()
    }

    /// Walks rules for given intensity from top to bottom and applies them
    #[must_use]
    pub fn say_it<'a>(&self, text: &'a str, intensity: u64) -> Cow<'a, str> {
        // Go from the end and pick first intensity that is less or eaual to requested. This is
        // guaranteed to return something because base intensity 0 is always present at the bottom
        // and 0 <= x is true for any u64
        let intensity = &self
            .intensities
            .iter()
            .find(|i| i.level <= intensity)
            .expect("intensity 0 is always present");

        intensity.apply(text)
    }
}

impl TryFrom<Vec<Intensity>> for Accent {
    type Error = CreationError;

    fn try_from(intensities: Vec<Intensity>) -> Result<Self, Self::Error> {
        if intensities.is_empty() {
            return Err(CreationError::IntensityZeroMissing);
        }

        if intensities[0].level != 0 {
            return Err(CreationError::FirstIntensityNotZero);
        }

        let mut seen = Vec::with_capacity(intensities.len());
        seen.push(0);

        for (i, intensity) in intensities[1..].iter().enumerate() {
            if intensity.level <= seen[i] {
                return Err(CreationError::UnsortedOrDuplicatedIntensities(
                    intensity.level,
                ));
            }
            seen.push(intensity.level);
        }

        // reverse now to not reverse each time to find highest matching intensity
        let intensities: Vec<_> = intensities.into_iter().rev().collect();

        Ok(Self { intensities })
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        accent::CreationError, intensity::Intensity, pass::Pass, tag_impls::Literal, Accent,
    };

    #[test]
    fn e() {
        let base_intensity = Intensity::new(
            0,
            vec![(
                "".to_owned(),
                Pass::new(vec![
                    ("(?-i)[a-z]".to_string(), Literal::new_boxed("e")),
                    ("(?-i)[A-Z]".to_string(), Literal::new_boxed("E")),
                ])
                .unwrap(),
            )],
        );
        let e = Accent::try_from(vec![base_intensity]).unwrap();

        assert_eq!(e.say_it("Hello World!", 0), "Eeeee Eeeee!");
    }

    #[test]
    fn construction_error_empty_intensities() {
        assert_eq!(
            Accent::try_from(Vec::new()).err().unwrap(),
            CreationError::IntensityZeroMissing
        );
    }

    #[test]
    fn construction_error_first_must_be_0() {
        let intensities = vec![Intensity::new(12, Vec::new())];

        assert_eq!(
            Accent::try_from(intensities).err().unwrap(),
            CreationError::FirstIntensityNotZero
        );
    }

    #[test]
    fn construction_error_out_of_order() {
        let intensities = vec![
            Intensity::new(0, Vec::new()),
            Intensity::new(3, Vec::new()),
            Intensity::new(1, Vec::new()),
        ];

        assert_eq!(
            Accent::try_from(intensities).err().unwrap(),
            CreationError::UnsortedOrDuplicatedIntensities(1)
        );
    }
}