bms 0.1.2

Be-Music Source parser
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

use crate::subsequence::*;
use regex::Regex;
use std::{
    convert::TryFrom,
    error::Error,
    fs::File,
    io::{BufReader, Read},
    path::PathBuf,
};

pub struct ChartData {
    pub player: u8,
    pub genre: String,
    pub title: String,
    pub artist: String,
    pub bpm: f64,
    pub play_level: u8,
    pub sound_paths: Vec<PathBuf>,
    pub subseqs: Vec<SubSequence>,
}

/// In Be-Music Source terminology, an object represents anything
/// that can appear in a chart.
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum Object {
    Silent,
    Note { sound: usize },
}

impl ChartData {
    fn from_data(data: String) -> Result<Self, Box<dyn Error>> {
        let r = Regex::new(r"#(.{3})(.{2}):(.*)").unwrap();
        let mut player = 0;
        let mut genre = "".to_string();
        let mut title = "".to_string();
        let mut artist = "".to_string();
        let mut bpm = 0.0;
        let mut level = 0;
        let mut paths = Vec::new();
        let mut subseqs = Vec::new();
        for line in data.lines() {
            if let Some((command, value)) = line.split_once(" ") {
                if !command.starts_with("#") {
                    continue;
                }

                match &command[1..] {
                    "PLAYER" => player = value.parse::<u8>()?,
                    "GENRE" => genre = value.to_string(),
                    "TITLE" => title = value.to_string(),
                    "ARTIST" => artist = value.to_string(),
                    "BPM" => bpm = value.parse::<f64>()?,
                    "PLAYLEVEL" => level = value.parse::<u8>()?,
                    _ => {
                        if command.starts_with("#WAV") || command.starts_with("#wav") {
                            paths.push(PathBuf::from(value));
                        }
                    }
                }
            }
        }

        for m in r.find_iter(data.as_str()) {
            if let Ok(seq) = SubSequence::try_from(m.as_str().to_string()) {
                subseqs.push(seq);
            }
        }

        Ok(ChartData {
            player,
            genre,
            title,
            artist,
            bpm,
            play_level: level,
            sound_paths: paths,
            subseqs,
        })
    }

    pub fn from_path(p: PathBuf) -> Result<Self, Box<dyn Error>> {
        let f = File::open(&p)?;
        let mut r = BufReader::new(f);
        let mut data = String::new();
        r.read_to_string(&mut data).expect("Failed to read data");

        Self::from_data(data)
    }

    pub fn count_measures(&self) -> usize {
        let mut subseqs2 = self.subseqs.clone();
        subseqs2.dedup_by_key(|x| x.measure);
        subseqs2.len()
    }

    pub fn get_measure(&self, measure: u32) -> Vec<SubSequence> {
        self.subseqs
            .iter()
            .filter(|&x| x.measure == measure)
            .map(|x| x.clone())
            .collect()
    }
}

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

    #[test]
    fn sequence_test() {
        let seq =
            SubSequence::try_from("#00111:0101010001".to_string()).expect("Failed to parse string");

        assert_eq!(seq.measure, 1);
        assert_eq!(seq.channel, 11);
        assert_eq!(
            seq.notes,
            vec![
                Object::Note { sound: 1 },
                Object::Note { sound: 1 },
                Object::Note { sound: 1 },
                Object::Silent,
                Object::Note { sound: 1 }
            ]
        );
    }
}