chordlib 0.12.4

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

use super::FormatChordPro;
use crate::types::{ChordRepresentation, Line, SimpleChord, chord_duration_to_layout_milliclicks};

pub fn render_line(
    line: &Line,
    key: Option<&SimpleChord>,
    representation: Option<&ChordRepresentation>,
    language: Option<usize>,
    worship_pro_features: bool,
    bar_duration: u32,
    beats_per_bar: u32,
) -> String {
    if worship_pro_features
        || line
            .parts
            .iter()
            .any(|part| part.languages.iter().any(|l| !l.is_empty()))
    {
        return line
            .parts
            .iter()
            .map(|part| part.format_chord_pro(key, representation, language, worship_pro_features))
            .collect();
    }

    let mut result = String::with_capacity(128);
    let mut chord = String::new();
    let mut chord_duration = 0;
    let mut current_bar_duration = 0i32;

    for part in &line.parts {
        if current_bar_duration <= 0 {
            result.push_str("[|]");
            if current_bar_duration < 0 {
                append_chord_block(&mut result, &chord, chord_duration, bar_duration);
            }
            current_bar_duration += bar_duration as i32;
        }

        chord = part
            .chord
            .as_ref()
            .map(|c| {
                c.format(
                    key.unwrap_or(&SimpleChord::default()),
                    representation.unwrap_or(&ChordRepresentation::default()),
                )
            })
            .unwrap_or_default();

        chord_duration = part
            .chord
            .as_ref()
            .map(|c| {
                chord_duration_to_layout_milliclicks(c.get_duration(), bar_duration, beats_per_bar)
            })
            .unwrap_or(bar_duration);

        append_chord_block(&mut result, &chord, chord_duration, bar_duration);
        current_bar_duration -= chord_duration as i32;
    }

    if current_bar_duration < 0 {
        append_chord_block(&mut result, &chord, chord_duration, bar_duration);
    }

    result.push_str("[|]");
    result
}

fn append_chord_block(result: &mut String, chord: &str, chord_duration: u32, bar_duration: u32) {
    result.push('[');
    result.push_str(chord);
    result.push(']');

    let base_width = 16 / (bar_duration / chord_duration).max(1) as usize;
    let spacing = base_width.saturating_sub(chord.chars().count() + 1);
    result.extend(std::iter::repeat_n(' ', spacing));
}

impl FormatChordPro for &Line {
    fn format_chord_pro(
        &self,
        key: Option<&SimpleChord>,
        representation: Option<&ChordRepresentation>,
        language: Option<usize>,
        worship_pro_features: bool,
    ) -> String {
        render_line(
            self,
            key,
            representation,
            language,
            worship_pro_features,
            4000,
            4,
        )
    }
}