charter_rs/

lib.rs

use regex::Regex;
use std::fs::read_to_string;
use std::io;
use std::path::PathBuf;
use unicode_segmentation::UnicodeSegmentation;

#[derive(PartialEq, Eq, Debug, Clone, Default)]
struct Match<'a> {
    start: usize,
    end: usize,
    text: String,
    source: &'a str,
}

impl<'a> Match<'a> {
    pub fn new<T, S>(start: usize, end: usize, text: T, source: S) -> Self
    where
        T: Into<String>,
        S: Into<&'a str>,
    {
        let span = Match {
            start,
            end,
            text: text.into(),
            source: source.into(),
        };
        span.ensure_is_valid();
        span
    }

    fn is_valid(&self) -> bool {
        //let a = self.source.chars().collect::<Vec<_>>()[self.start..self.end].to_vec();
        let a = &self.source[self.start..self.end].to_string();
        let b = &self.text;
        a == b
    }

    fn ensure_is_valid(&self) -> () {
        if !self.is_valid() {
            panic!(
                "Invalid span. {:?} not at self.source[{}, {}], which == {:?}",
                self.text,
                self.start,
                self.end,
                &self.source[self.start..self.end],
            );
        }
    }
}

#[derive(PartialEq, Eq, Debug)]
pub struct Measure<'a> {
    pub chart: &'a Chart,
    pub index: i32,
    pub line_c: i32,
    pub line_index: i32,
    pub line_measure_count: i32,
    pub rhythmic: Option<Match<'a>>,
    pub harmonic: Match<'a>,
    pub lyrical: Option<Match<'a>>,
}

impl<'a> Measure<'a> {
    fn new(
        chart: &'a Chart,
        index: i32,
        line_c: i32,
        line_index: i32,
        line_measure_count: i32,
        rhythmic: Option<Match<'a>>,
        harmonic: Match<'a>,
        lyrical: Option<Match<'a>>,
    ) -> Self {
        Measure {
            chart,
            index,
            line_c,
            line_index,
            line_measure_count,
            rhythmic,
            harmonic,
            lyrical,
        }
    }

    #[inline]
    pub fn short_debug(&self) -> String {
        format!(
            "Measure{{ index: {}, line_c: {}, line_index: {}, line_measure_count: {} , self.is_last_in_line: {}\nrhythmic: {:?},\nharmonic: {:?},\nlyrical: {:?}}}",
            self.index,
            self.line_c,
            self.line_index,
            self.line_measure_count,
            self.is_last_in_line(),
            self.rhythmic.clone().unwrap_or_default().text,
            self.harmonic.text,
            self.lyrical.clone().unwrap_or_default().text
        )
    }

    #[inline]
    fn is_last_in_line(&self) -> bool {
        self.line_index + 1 == self.line_measure_count
    }
}

#[derive(PartialEq, Eq, Debug)]
struct Section<'a> {
    chart: &'a Chart,
    measure_start: usize,
    measure_end: usize,
    section_indicator: Match<'a>,
}

impl<'a> Section<'a> {
    fn new(
        chart: &'a Chart,
        measure_start: usize,
        measure_end: usize,
        section_indicator: Match<'a>,
    ) -> Section<'a> {
        Section {
            chart,
            measure_start,
            measure_end,
            section_indicator,
        }
    }
}

#[derive(PartialEq, Eq, Debug)]
pub struct Chart {
    pub path: PathBuf,
    pub contents: String,
}

//https://www.reddit.com/r/rust/comments/2j0k21/rust_option_vs_result/
impl Chart {
    const RHYTHMIC_TRIGGERS: [&'static str; 14] = [
        "𝅜", "𝅝", "𝅗𝅥", "𝅘𝅥", "𝅘𝅥𝅮", "𝅘𝅥𝅯", "𝅘𝅥𝅰", "𝅘𝅥𝅱", "𝅘𝅥𝅲", "♪", "♫", "♩", "𝅗𝅥", "𝅝",
    ];

    pub fn new<S: Into<PathBuf>>(path: S) -> Result<Self, io::Error> {
        let path_buf = path.into();
        let contents = read_to_string(&path_buf)?;
        Ok(Chart {
            path: path_buf,
            contents: Chart::normalize_input(contents),
        })
    }

    #[inline]
    pub fn normalize_input<T: AsRef<str>>(input: T) -> T
    where
        T: From<String>,
    {
        let normalized = input
            .as_ref()
            .replace("\r\n", "\n") // Convert Windows newlines to Unix
            .lines()
            .map(|line| line.trim_end()) // Strip trailing whitespace from each line
            .collect::<Vec<_>>()
            .join("\n");

        T::from(normalized)
    }

    fn contains_measure_lines(s: &str) -> bool {
        for c in s.chars() {
            if c == '|' {
                return true;
            }
        }
        false
    }

    fn contains_rhythmic(s: &str) -> bool {
        for grapheme in s.graphemes(true) {
            if Chart::RHYTHMIC_TRIGGERS.contains(&grapheme) {
                return true;
            }
        }
        false
    }

    fn chord_line_indexes(&self) -> Vec<usize> {
        let mut indexes = Vec::new();
        for (l, line) in self.contents.lines().into_iter().enumerate() {
            if line.contains('|') {
                indexes.push(l);
            }
        }
        indexes
    }

    fn chord_lines(&self) -> Vec<String> {
        let mut lines = Vec::new();
        for (l, line) in self.contents.lines().into_iter().enumerate() {
            if self.chord_line_indexes().contains(&l) {
                lines.push(line.to_string());
            }
        }
        lines
    }

    pub fn sections(&self) -> Vec<Section> {
        let mut sections: Vec<Section> = Vec::new();
        let section_indicators = self.section_indicators();
        let m = 0;
        for section_indicator in section_indicators {
            sections.push(Section {
                chart: &self,
                measure_start: m,
                measure_end: m,
                section_indicator: section_indicator,
            })
        }
        sections
    }

    pub fn measures(&self) -> Vec<Measure> {
        let mut measures: Vec<Measure> = Vec::new();
        let mut m = 0;
        let chord_line_indexes = self.chord_line_indexes();
        let lines: Vec<&str> = self.contents.lines().collect(); // collect into a Vec for indexing
        let line_start_c = 0usize;
        let prev_line_start_c = 0usize;
        let next_line_start_c = 0usize;

        for (l, &line) in lines.iter().enumerate() {
            if chord_line_indexes.contains(&l) {
                if l == 0 {
                    continue; // avoid out-of-bounds when l == 0
                }

                let prev_line = lines[l - 1usize];
                let next_line = lines[l + 1usize];
                let harmonic_line: &str = line;
                let mut lyrical_line: Option<&str> = None;
                let mut rhythmic_line: Option<&str> = None;
                let mut line_measure_indexes: Vec<usize> = Vec::new();
                let prev_line_is_rhythmic = Chart::contains_rhythmic(prev_line);
                let next_line_is_lyrical = l + 1usize < lines.len()
                    && !Chart::contains_measure_lines(next_line)
                    && !Chart::contains_rhythmic(next_line);

                if prev_line_is_rhythmic {
                    rhythmic_line = Some(prev_line);
                } else {
                    rhythmic_line = None;
                }
                if next_line_is_lyrical {
                    lyrical_line = Some(next_line);
                } else {
                    lyrical_line = None;
                }
                for (c, char) in harmonic_line.graphemes(true).enumerate() {
                    if char == "|" {
                        line_measure_indexes.push(c)
                    }
                }

                let max_len = [
                    harmonic_line,
                    lyrical_line.unwrap_or_default(),
                    rhythmic_line.unwrap_or_default(),
                ]
                .iter()
                .map(|line| line.graphemes(true).count())
                .max()
                .unwrap_or(0); // fallback if lines is empty

                for (i, line_measure_index) in line_measure_indexes.iter().enumerate() {
                    let mut slice_len: usize;
                    let mut slice_start: usize;
                    let mut next_line_measure_index: usize;

                    if i + 2usize < line_measure_indexes.len() {
                        slice_start = line_measure_indexes[i];
                        slice_len = line_measure_indexes[i + 1usize] - slice_start;
                        //   print!("*");
                    } else if i + 1usize < line_measure_indexes.len() {
                        //panic!("Happend");
                        slice_start = line_measure_indexes[i];
                        slice_len = max_len - slice_start; // - *line_measure_index;
                    //  print!("!");
                    } else {
                        slice_start = line.len();
                        slice_len = 1usize;
                        // print!("?");
                    }
                    //println!("m: {} slice_start:{:?} slice_len:{:?} line:{:?}", m,slice_start, slice_len, line);
                    //panic!("{}",rhythmic_line.graphemes(true));
                    //panic!("{:?}",  rhythmic_line.unwrap_or_default().graphemes(true));
                    let mut rhythm_slice: Option<Match> = None;
                    let mut lyric_slice: Option<Match> = None;

                    if prev_line_is_rhythmic {
                        rhythm_slice = Some(Match {
                            start: 0usize,
                            end: 0usize,
                            text: rhythmic_line
                                .unwrap()
                                .chars()
                                .skip(slice_start)
                                .take(slice_len)
                                .collect(),
                            source: &*self.contents,
                        });
                    }
                    if next_line_is_lyrical {
                        //panic!("{:?}",rhythm_slice);
                        lyric_slice = Some(Match {
                            start: 0usize,
                            end: 0usize,
                            text: lyrical_line
                                .unwrap()
                                .chars()
                                .skip(slice_start)
                                .take(slice_len)
                                .collect(),
                            source: &*self.contents,
                        });
                    }

                    let harmonic_slice = Match {
                        start: 0usize,
                        end: 0usize,
                        text: harmonic_line
                            .chars()
                            .skip(slice_start)
                            .take(slice_len)
                            .collect(),
                        source: &*self.contents,
                    };

                    //panic!("harmonic_slice: {}", harmonic_slice);

                    let measure = Measure {
                        chart: self,
                        index: m,
                        line_c: slice_start as i32,
                        line_index: i as i32,
                        line_measure_count: line_measure_indexes.len() as i32 - 1,
                        rhythmic: rhythm_slice,
                        harmonic: harmonic_slice,
                        lyrical: lyric_slice,
                    };
                    if measure.line_index == measure.line_measure_count {
                    } else {
                        measures.push(measure);
                        m += 1;
                    }
                }

                //panic!("path:{:?}\nline_measure_indexes{:?}\nline: {}\nl:{}\nrhythmic_line:{:?}\nharmonic_line:{:?}\nlyrical_line: {:?}",
                //       self.path,line_measure_indexes, line, l,rhythmic_line.unwrap_or_default(), harmonic_line, lyrical_line.unwrap_or_default())

                //measures.push(Measure::new(self,))
                // You can now use chord_line, rhythm_line, etc.
            }
        }

        measures
    }

    pub fn section_indicators(&self) -> Vec<Match> {
        let re = Regex::new(r"\[([^\]]+)\]").unwrap();
        //panic!("OMG {:?}",re.find_iter(&self.contents).collect::<Vec<_>>()[0].)
        let re_matches = re.find_iter(&self.contents);
        let mut matches: Vec<Match> = Vec::<Match>::new();
        for re_match in re_matches {
            matches.push(Match::new(
                re_match.start(),
                re_match.end(),
                re_match.as_str(),
                &*self.contents,
            ))
        }
        matches
    }

    pub fn join_all_measures(
        &self,
        include_harmonic: bool,
        include_rhythmic: bool,
        include_lyrical: bool,
    ) -> String {
        let mut ret = String::new();
        let mut multiline_block: Vec<String> = Vec::new();
        let mut rhythmic_line = "".to_string();
        let mut harmonic_line = "".to_string();
        let mut lyrical_line = "".to_string();
        let section_indicators = self.section_indicators();
        // lines are rhythmic, harmonic, lyrical
        for (m, measure) in self.measures().iter().enumerate() {
            //ret += &*format!("#\"{}\"", measure.index).to_string();
            //ret += "\n";
            if measure.line_index == 0 {
                multiline_block = Vec::new();
                rhythmic_line = "".to_string();
                harmonic_line = "".to_string();
                lyrical_line = "".to_string();
            }

            rhythmic_line += measure.rhythmic.clone().unwrap_or_default().text.as_str();
            lyrical_line += measure.lyrical.clone().unwrap_or_default().text.as_str();
            harmonic_line += measure.harmonic.text.as_str();

            if (measure.is_last_in_line()) {
                if rhythmic_line.len() > 0 {
                    multiline_block.push(rhythmic_line.clone());
                }
                if harmonic_line.len() > 0 {
                    multiline_block.push(harmonic_line.clone());
                }
                if lyrical_line.len() > 0 {
                    multiline_block.push(lyrical_line.clone());
                }
                //ret += format!("[{}-{}]\n", measure.index-measure.line_measure_count + 1,measure.index).as_str();
                ret += multiline_block.join("\n").as_str();
                ret += "\n";

                //println!("Added block:\n{}", multiline_block.join("\n").as_str());
            }
        }
        ret += &*self
            .section_indicators()
            .iter()
            .map(|m| m.text.clone())
            .collect::<Vec<String>>()
            .join("\n");
        ret
    }
}