chordlib 0.8.1

Work with chord-and-lyrics songs: parse, transform, and render them to multiple formats
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 crate::error::Error;
use crate::types::Part;

pub struct PartIterator<'a> {
    content_chord: Option<&'a str>,
    content_text: Option<&'a str>,
}

impl<'a> PartIterator<'a> {
    pub fn new(content: &'a str) -> Self {
        let vec = content.split('\n').collect::<Vec<&str>>();
        if vec.len() > 1 {
            Self {
                content_chord: Some(vec[0]),
                content_text: Some(vec[1]),
            }
        } else if vec.len() == 1 {
            if vec[0].contains("[ch]") {
                Self {
                    content_chord: Some(vec[0]),
                    content_text: None,
                }
            } else {
                Self {
                    content_chord: None,
                    content_text: Some(vec[0]),
                }
            }
        } else {
            Self {
                content_chord: None,
                content_text: None,
            }
        }
    }
}

impl<'a> Iterator for PartIterator<'a> {
    type Item = Result<Part, Error>;

    fn next(&mut self) -> Option<Self::Item> {
        if let Some(mut content_chord) = self.content_chord {
            let old_content_chord = content_chord;
            let start = content_chord.find("[ch]")?;
            if start > 0
                && let Some(content_text) = self.content_text
            {
                let byte_index = content_text
                    .chars()
                    .take(start)
                    .map(|b| b.len_utf8())
                    .sum::<usize>();
                let text = &content_text[..byte_index];
                self.content_text = Some(&content_text[byte_index..]);
                self.content_chord = Some(&content_chord[start..]);
                return Some(("", text).try_into());
            }
            content_chord = &content_chord[start + 4..];
            let end = content_chord.find("[/ch]")?;
            let chord = &content_chord[..end];
            let next_start = content_chord.find("[ch]").unwrap_or(content_chord.len());
            content_chord = &content_chord[next_start..];
            self.content_chord = Some(content_chord);
            if let Some(content_text) = self.content_text {
                let text = if !content_chord.is_empty() {
                    let char_index =
                        old_content_chord.chars().count() - content_chord.chars().count() - 9;
                    let byte_index = content_text
                        .chars()
                        .take(char_index)
                        .map(|b| b.len_utf8())
                        .sum::<usize>();
                    let text = &content_text[..byte_index];
                    self.content_text = Some(&content_text[byte_index..]);
                    text
                } else {
                    let text = content_text;
                    self.content_text = None;
                    text
                };
                Some((chord, text).try_into())
            } else {
                Some((chord, "").try_into())
            }
        } else {
            Some(("", self.content_text.take()?).try_into())
        }
    }
}

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

    #[test]
    fn part_iterator() {
        let inputs = [
            "",
            "[ch]A[/ch]",
            "[ch]A[/ch] [ch]B[/ch]",
            "[ch]A[/ch]    [ch]B[/ch]\nHeyö you",
            "[ch]A[/ch]          [ch]B[/ch]\nHey",
            "    [ch]A[/ch]\nHey you",
            "Hello World",
        ];
        let outputs = [
            vec![("", "").try_into().unwrap()],
            vec![("A", "").try_into().unwrap()],
            vec![("A", "").try_into().unwrap(), ("B", "").try_into().unwrap()],
            vec![
                ("A", "Heyö ").try_into().unwrap(),
                ("B", "you").try_into().unwrap(),
            ],
            vec![
                ("A", "Hey").try_into().unwrap(),
                ("B", "").try_into().unwrap(),
            ],
            vec![
                ("", "Hey ").try_into().unwrap(),
                ("A", "you").try_into().unwrap(),
            ],
            vec![("", "Hello World").try_into().unwrap()],
        ];
        for (input, output) in inputs.iter().zip(outputs.iter()) {
            assert_eq!(
                &PartIterator::new(input)
                    .collect::<Result<Vec<Part>, Error>>()
                    .unwrap(),
                output
            );
        }
    }
}