tegen 0.1.4

tegen is a Rust library designed to generate text from a given template.
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

use rand::Rng;

/// The `TextGenerator` struct, used for generating text from a template.
pub struct TextGenerator {
    start_c: char,
    end_c: char,
    sep: char,
}

impl TextGenerator {
    /// Creates a new `TextGenerator` struct.
    pub fn new() -> Self {
        Self {
            start_c: '{',
            end_c: '}',
            sep: '|',
        }
    }

    /// Generates text from the given template.
    /// A template starts with `{` and ends with `}` and can contain `|` characters to separate different options.
    /// For example, `{Hello|Salutations}, {World|Reality}!`
    pub fn generate(&self, text: &str) -> String {
        self.scan_and_replace(text.chars().collect::<Vec<char>>())
            .iter()
            .map(|x| (*x).to_string())
            .collect()
    }

    fn get_random_part(&self, text: Vec<char>) -> Vec<char> {
        let mut open_level = 0;
        let mut last_pos = 0;
        let mut is_ignore = false;

        let mut parts = Vec::<String>::new();

        for (i, &c) in text.iter().enumerate() {
            if c == self.start_c {
                open_level += 1;
                is_ignore = true;
                continue;
            }

            if c == self.end_c {
                open_level -= 1;
                if open_level == 0 {
                    is_ignore = false;
                }
                continue;
            }

            if is_ignore {
                continue;
            }

            if c == self.sep {
                parts.push(text[last_pos..i].iter().map(|x| (*x).to_string()).collect());
                last_pos = i + 1;
            }
        }

        parts.push(text[last_pos..].iter().map(|x| (*x).to_string()).collect());

        let mut rng = rand::thread_rng();
        parts[rng.gen_range(0..parts.len())].chars().collect()
    }

    fn scan_and_replace(&self, text: Vec<char>) -> Vec<char> {
        let mut start_safe_pos = 0;
        let mut start_pos = 0;
        let mut end_pos = 0;
        let mut open_level = 0;
        let mut is_find = false;
        let mut result = Vec::<char>::new();

        for (i, &c) in text.iter().enumerate() {
            if c == self.start_c {
                if open_level == 0 {
                    start_pos = i;
                    result.append(
                        &mut text[start_safe_pos..start_pos]
                            .iter()
                            .map(|x| (*x).to_string())
                            .collect::<String>()
                            .chars()
                            .collect::<Vec<char>>(),
                    );
                }

                open_level += 1;
                continue;
            }

            if c == self.end_c {
                open_level -= 1;
                if open_level == 0 {
                    is_find = true;
                    end_pos = i;

                    start_safe_pos = end_pos + 1;
                    result.append(
                        &mut self.scan_and_replace(
                            self.get_random_part(
                                text[(start_pos + 1)..end_pos]
                                    .iter()
                                    .map(|x| (*x).to_string())
                                    .collect::<String>()
                                    .chars()
                                    .collect::<Vec<char>>(),
                            ),
                        ),
                    );
                }
                continue;
            }
        }

        if !is_find {
            return text;
        }

        result.append(
            &mut text[(end_pos + 1)..]
                .iter()
                .map(|x| (*x).to_string())
                .collect::<String>()
                .chars()
                .collect::<Vec<char>>(),
        );

        result
    }
}