WIP

Cargo.lock

@@ -242,7 +242,6 @@ dependencies = [
  "chrono",
  "clap",
  "env_logger",
- "io-prompt-prototype",
  "itertools 0.14.0",
  "midir",
  "regex",
@@ -413,12 +412,6 @@ dependencies = [
  "hashbrown",
 ]
 
-[[package]]
-name = "io-prompt-prototype"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca9d71ad6b790f2522eeb0a4f207fa7ef21826777d4714c7ff09483bf17b0ab8"
-
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.2"

Cargo.toml

@@ -7,7 +7,6 @@ edition = "2024"
 chrono = "0.4.44"
 clap = { version = "4.5.60", features = ["derive"] }
 env_logger = "0.11.9"
-io-prompt-prototype = "1.0.0"
 itertools = "0.14.0"
 midir = "0.10.3"
 regex = "1.12.3"

src/flags.rs

@@ -5,9 +5,6 @@ pub struct Flags {
     #[arg(short, long, default_value_t = false)]
     pub debug: bool,
 
-    #[arg(short, long, default_value_t = false)]
-    pub interactive: bool,
-
     #[arg(long, default_value_t = 120)]
     pub bpm: usize,
 
@@ -17,8 +14,8 @@ pub struct Flags {
     #[arg(long, default_value = "super_small_font.sf2")]
     pub sound_font: String,
 
-    #[arg(short, long, default_value = "c 2*e+")]
+    #[arg(short, long, default_value = "c 2e+")]
-    pub play: Vec<String>,
+    pub play: Option<String>,
 }
 
 impl Flags {

src/main.rs

@@ -1,78 +1,50 @@
-use io_prompt_prototype::prompt;
 use itertools::Itertools;
 
 mod flags;
-mod parse;
-mod player;
-mod seq;
 mod syn;
 mod tone;
+mod seq;
 
 fn main() {
-    let mut flags = flags::Flags::new();
+    let flags = flags::Flags::new();
-    if flags.debug {
-        eprintln!("{:?}", flags);
-    }
-    if flags.interactive {
-        flags.play = vec![];
-    }
 
-    let once = flags.play.iter().filter(|x| x.len() > 0).count() > 0;
-    let mut player = player::new(flags.sample_rate.clone(), flags.bpm.clone());
-    loop {
-        play_with_flags(&flags, &mut player);
-        if once {
-            break;
-        }
-    }
-}
-
-fn play_with_flags(flags: &flags::Flags, player: &mut player::Player) {
     let mut syn_seq = seq::new_syn(syn::Syn::new(
-        flags.debug.clone(),
+        flags.debug,
-        flags.sound_font.clone(),
+        flags.sound_font,
-        flags.sample_rate.clone(),
+        flags.sample_rate,
     ));
-
+    syn_seq.append(1, "3c1");
-    let mut i = 0;
+    if let Some(play) = flags.play {
-    for p in flags.play.iter() {
+      syn_seq.append(0, play);
-        for p in parse::new(p.clone()) {
-            syn_seq.append(i as i32, p);
-            i += 1;
-        }
     }
 
-    let sync = i > 0;
+    play(syn_seq, flags.sample_rate, flags.bpm);
-    if !sync {
-        let mut to_break = false;
-        let mut payload = vec![];
-        loop {
-            let mut s: String = prompt!("> ").parse().expect("failed to readline");
-            s = s.split_whitespace().join(" ");
-            payload.push(s.clone());
-            match s.as_ref() {
-                "" => match to_break {
-                    false => {
-                        to_break = true;
-                    }
-                    true => {
-                        break;
-                    }
-                },
-                _ => {
-                    to_break = false;
 }
+
+fn play(mut s: seq::SynSeq, sample_rate: usize, bpm: usize) {
+    let samples_per_beat = sample_rate / bpm * 60;
+    let params = tinyaudio::prelude::OutputDeviceParameters {
+        channels_count: 2,
+        sample_rate: sample_rate,
+        channel_sample_count: samples_per_beat,
     };
-        }
+    let beats = s.beats() + 3;
+    let duration = 60 * beats / bpm;
 
-        for p in parse::new(payload.join("\n")) {
+    let sample_count = (params.channel_sample_count) as usize;
-            syn_seq.append(i as i32, p);
+    let mut left: Vec<f32> = vec![0_f32; sample_count];
-            i += 1;
+    let mut right: Vec<f32> = vec![0_f32; sample_count];
-        }
-    }
 
-    match sync {
+    let _device = tinyaudio::prelude::run_output_device(params, {
-        true => player.play(syn_seq),
+        move |data| {
-        false => player.play_async(syn_seq),
+            s.render(&mut left[..], &mut right[..]); // put in a state of rendering the next loop of these notes
-    };
+            for (i, value) in left.iter().interleave(right.iter()).enumerate() {
+                data[i] = *value;
+            }
+        }
+    })
+    .unwrap();
+
+    // Wait it out
+    std::thread::sleep(std::time::Duration::from_secs(duration as u64));
 }

src/parse.rs

@@ -1,119 +0,0 @@
-use std::io::Read;
-
-pub fn new<S: ToString>(s: S) -> Vec<String> {
-    parse(from_string(s.to_string()))
-}
-
-fn from_string(s: String) -> String {
-    match std::fs::File::open(s.clone()) {
-        Ok(mut reader) => {
-            let mut content = String::new();
-            reader
-                .read_to_string(&mut content)
-                .expect(format!("failed to read {}", s).as_ref());
-            content
-        }
-        Err(_) => s,
-    }
-}
-
-fn parse(s: String) -> Vec<String> {
-    let s = s
-        .split("\n")
-        .filter(|x: &&str| {
-            !x // doesnt start with #
-                .split_whitespace()
-                .collect::<Vec<_>>()
-                .join("")
-                .starts_with("#")
-        })
-        .map(|x| {
-            x.split("#")
-                .take(1) // drop after #
-                .collect::<Vec<_>>()
-                .join("")
-                .split_whitespace()
-                .collect::<Vec<_>>()
-                .join(" ")
-        })
-        .collect::<Vec<_>>()
-        .join("\n");
-    let mut channels = vec![];
-    let lines = s.split("\n").collect::<Vec<_>>();
-    let mut j = 0;
-    for i in 0..lines.len() {
-        match lines[i] {
-            "" => {
-                j = 0;
-            }
-            _ => {
-                while channels.len() <= j {
-                    channels.push("".to_string());
-                }
-                channels[{
-                    let tmp = j;
-                    j += 1;
-                    tmp
-                }] += &(" ".to_string() + lines[i]);
-            }
-        };
-    }
-    channels
-        .iter()
-        .map(|x| x.split_whitespace().collect::<Vec<_>>().join(" "))
-        .collect()
-}
-
-#[cfg(test)]
-mod test {
-    #[test]
-    fn test_string() {
-        assert_eq!(super::new("a b c")[0], "a b c".to_string());
-        assert_eq!(super::new("a b c".to_string())[0], "a b c".to_string());
-    }
-
-    #[test]
-    fn test_single_line_file() {
-        assert_eq!(
-            super::new("src/testdata/single_line_file.txt")[0],
-            "a b c".to_string()
-        );
-    }
-
-    #[test]
-    fn test_two_channels_one_bar() {
-        assert_eq!(
-            super::new("src/testdata/two_channels_one_bar.txt")[0],
-            "2*a 2*b 2*c".to_string()
-        );
-        assert_eq!(
-            super::new("src/testdata/two_channels_one_bar.txt")[1],
-            ". a5 . b5 . c5".to_string()
-        );
-    }
-
-    #[test]
-    fn test_two_channels_two_bars() {
-        assert_eq!(
-            super::new("src/testdata/two_channels_two_bars.txt")[0],
-            "a b c d e f".to_string()
-        );
-        assert_eq!(
-            super::new("src/testdata/two_channels_two_bars.txt")[1],
-            "2*a 2*b 2*c 2*d 2*e 2*f".to_string()
-        );
-    }
-
-    #[test]
-    fn drop_comment_lines() {
-        assert_eq!(
-            super::new("# hello\n # world\na b c")[0],
-            "a b c".to_string()
-        );
-    }
-
-    #[test]
-    fn drop_comment_trailer() {
-        assert_eq!(super::new("a b c # hello world")[0], "a b c".to_string());
-    }
-}

src/player.rs

@@ -1,61 +0,0 @@
-use itertools::Itertools;
-
-use crate::seq;
-
-pub struct Player {
-    bpm: usize,
-    params: tinyaudio::OutputDeviceParameters,
-    device: Option<tinyaudio::OutputDevice>,
-}
-
-pub fn new(sample_rate: usize, bpm: usize) -> Player {
-    let samples_per_beat = sample_rate / bpm * 60;
-    Player {
-        bpm: bpm,
-        params: tinyaudio::prelude::OutputDeviceParameters {
-            channels_count: 2,
-            sample_rate: sample_rate,
-            channel_sample_count: samples_per_beat,
-        },
-        device: None,
-    }
-}
-
-impl Player {
-    pub fn play(&mut self, s: seq::SynSeq) {
-        self.play_with_sync(s, true);
-    }
-
-    pub fn play_async(&mut self, s: seq::SynSeq) {
-        self.play_with_sync(s, false);
-    }
-
-    fn play_with_sync(&mut self, mut s: seq::SynSeq, sync: bool) {
-        let sample_count = (self.params.channel_sample_count) as usize;
-        let mut left: Vec<f32> = vec![0_f32; sample_count];
-        let mut right: Vec<f32> = vec![0_f32; sample_count];
-
-        let beats = s.beats() + 3;
-        let duration = 60 * beats / self.bpm;
-
-        if self.device.is_some() {
-            self.device.as_mut().expect("lost device").close();
-        }
-        self.device = Some(
-            tinyaudio::prelude::run_output_device(self.params, {
-                move |data| {
-                    s.render(&mut left[..], &mut right[..]); // put in a state of rendering the next loop of these notes
-                    for (i, value) in left.iter().interleave(right.iter()).enumerate() {
-                        data[i] = *value;
-                    }
-                }
-            })
-            .unwrap(),
-        );
-
-        if sync {
-            // Wait it out
-            std::thread::sleep(std::time::Duration::from_secs(duration as u64));
-        }
-    }
-}

src/seq.rs

@@ -1,5 +1,5 @@
-use crate::syn;
 use crate::tone;
+use crate::syn;
 
 pub struct SynSeq {
    seqs: std::collections::HashMap<i32, Seq>,
@@ -21,7 +21,7 @@ impl SynSeq {
             let mut seq = new();
             seq.append(s);
             self.seqs.insert(ch, seq);
-            }
+         },
       };
    }
 
@@ -29,11 +29,13 @@ impl SynSeq {
       for (ch, seq) in self.seqs.iter_mut() {
          let ch = ch.clone();
          match seq.pop() {
-                (Some(tone), changed) if changed => self.syn.set(ch, Some(tone.clone())),
+            (Some(tone), changed) if changed => {
+               self.syn.set(ch, Some(tone.clone()))
+            },
             (None, changed) if changed => {
                self.syn.set(ch, None);
-                }
+            },
-                _ => {}
+            _ => {},
          };
       }
       self.syn.render(left, right);
@@ -55,8 +57,7 @@ impl SynSeq {
 #[derive(PartialEq)]
 pub struct Seq {
    beats: Vec<(usize, tone::Tone)>,
-    had_more: bool,
+   state: Option<tone::Tone>,
-    eof: bool,
 }
 
 fn new() -> Seq {
@@ -67,8 +68,7 @@ impl Seq {
    fn new() -> Seq {
       Seq{
          beats: vec![],
-            had_more: false,
+         state: None,
-            eof: false,
       }
    }
 
@@ -81,18 +81,12 @@ impl Seq {
    }
 
    fn pop(&mut self) -> (Option<tone::Tone>, bool) {
-        let mut changed = !self.had_more && self.beats.len() > 0;
+      let state_before = self.state.clone();
-        self.had_more = match self.beats.len() {
+      let tone_after = self._pop();
-            0 => false,
+      if state_before != tone_after {
-            _ => self.beats[0].0 > 1,
+         self.state = tone_after.clone();
-        };
-        let eof_before = self.eof;
-        self.eof = self.beats.len() == 0;
-        if !eof_before && self.eof {
-            changed = true;
       }
-        let tone = self._pop();
+      (tone_after, self.state != state_before)
-        (tone, changed)
    }
 
    fn _pop(&mut self) -> Option<tone::Tone> {
@@ -103,7 +97,7 @@ impl Seq {
             _ => {
                self.beats[0].0 -= 1;
                Some(self.beats[0].1.clone())
-                }
+            },
          },
       }
    }
@@ -117,7 +111,7 @@ impl Seq {
    }
 
    fn append_one(&mut self, s: String) {
-        let re = regex::Regex::new(r"^((?<count>[0-9]+)\*)?(?<tone>.*)$").unwrap();
+      let re = regex::Regex::new(r"^(?<count>[0-9]*)(?<tone>.*)$").unwrap();
       let captures = re.captures(&s).unwrap();
 
       let n = match captures.name("count") {
@@ -125,8 +119,7 @@ impl Seq {
          _ => 1,
       } as usize;
 
-        let tone_s = captures.name("tone").unwrap().as_str();
+      let tone = tone::new(captures.name("tone").unwrap().as_str());
-        let tone = tone::new(tone_s);
       self.beats.push((n, tone));
    }
 }
@@ -139,33 +132,28 @@ mod test {
    fn test_seq() {
       let mut seq = new();
 
-        seq.append("c c");
+      seq.append("c");
-        seq.append("4*d");
+      seq.append("4d");
-        seq.append("2*-");
+      seq.append("2-");
-        seq.append("g 2*e");
+      seq.append("g 2e");
 
-        assert_eq!(seq.beats.len(), 6);
+      assert_eq!(seq.beats.len(), 5);
-        assert_eq!(seq.len(), 11);
+      assert_eq!(seq.len(), 10);
 
       assert_eq!(seq.beats[0], (1 as usize, tone::new("c")));
-        assert_eq!(seq.beats[1], (1 as usize, tone::new("c")));
+      assert_eq!(seq.beats[1], (4 as usize, tone::new("d")));
-        assert_eq!(seq.beats[2], (4 as usize, tone::new("d")));
+      assert_eq!(seq.beats[2], (1 as usize, tone::new("g")));
-        assert_eq!(seq.beats[3], (2 as usize, tone::new("!")));
+      assert_eq!(seq.beats[3], (2 as usize, tone::new("e")));
-        assert_eq!(seq.beats[4], (1 as usize, tone::new("g")));
-        assert_eq!(seq.beats[5], (2 as usize, tone::new("e")));
 
-        assert_eq!(seq.pop(), (Some(tone::new("c")), true));
       assert_eq!(seq.pop(), (Some(tone::new("c")), true));
       assert_eq!(seq.pop(), (Some(tone::new("d")), true));
       for _ in 1..4 {
          assert_eq!(seq.pop(), (Some(tone::new("d")), false));
       }
-        assert_eq!(seq.pop(), (Some(tone::new(".")), true));
-        assert_eq!(seq.pop(), (Some(tone::new("?")), false));
       assert_eq!(seq.pop(), (Some(tone::new("g")), true));
       assert_eq!(seq.pop(), (Some(tone::new("e")), true));
       assert_eq!(seq.pop(), (Some(tone::new("e")), false));
-        assert_eq!(seq.pop(), (None, true), "shouldve newly had no more");
+      assert_eq!(seq.pop(), (None, true));
-        assert_eq!(seq.pop(), (None, false), "shouldve still had no more");
+      assert_eq!(seq.pop(), (None, false));
    }
 }

src/syn.rs

@@ -1,5 +1,5 @@
-use rustysynth::SoundFont;
 use rustysynth::Synthesizer;
+use rustysynth::SoundFont;
 use rustysynth::SynthesizerSettings;
 use std::sync::Arc;
 
@@ -17,10 +17,7 @@ impl Syn {
    pub fn new(debug: bool, sound_font: String, sample_rate: usize) -> Syn {
       match debug {
          false => Syn::new_real(sound_font, sample_rate),
-            true => Syn::Text {
+         true => Syn::Text{m: std::collections::HashMap::new(), i: 0},
-                m: std::collections::HashMap::new(),
-                i: 0,
-            },
       }
    }
 
@@ -40,10 +37,10 @@ impl Syn {
          // velocity=[0..128)
          Syn::Real(syn) => {
             syn.note_off_all_channel(ch, false);
-            }
+         },
          Syn::Text{m, ..} => {
             m.remove(&ch);
-            }
+         },
       };
       if let Some(tone) = b {
          self.tone_on(ch, tone);
@@ -57,16 +54,27 @@ impl Syn {
          Syn::Real(syn) => syn.note_on(ch, b.i32(), 127),
          Syn::Text{m, ..} => {
             match m.get_mut(&ch) {
-                    Some(m2) => {
+               Some(m2) => { m2.insert(b.i32(), 127); },
-                        m2.insert(b.i32(), 127);
-                    }
                None => {
                   let mut m2 = std::collections::HashMap::new();
                   m2.insert(b.i32(), 127);
                   m.insert(ch, m2);
-                    }
+               },
+            };
+         },
       };
    }
+
+   fn tone_off(&mut self, ch: i32, b: tone::Tone) {
+      match self {
+         Syn::Real(syn) => syn.note_off(ch, b.i32()),
+         Syn::Text{m, ..} => {
+            match m.get_mut(&ch) {
+               Some(m) => { m.remove(&b.i32()); },
+               None => {},
+            };
+
+         },
       };
    }
 
@@ -74,23 +82,9 @@ impl Syn {
       match self {
          Syn::Real(syn) => syn.render(a, b),
          Syn::Text{m, i} => {
-                eprintln!(
+            eprintln!("{} | render[{}]({:?})", chrono::prelude::Utc::now(), i, m);
-                    "{} | render[{}]({:?})",
-                    chrono::prelude::Utc::now(),
-                    i,
-                    m.iter()
-                        .map(|tuple| (
-                            tuple.0,
-                            tuple
-                                .1
-                                .iter()
-                                .map(|v| tone::new(v.0.to_string()).string())
-                                .collect::<Vec<_>>()
-                        ))
-                        .collect::<Vec<_>>(),
-                );
             *i += 1;
-            }
+         },
       };
    }
 }
@@ -106,6 +100,8 @@ mod test {
      syn.tone_on(0, tone::new("c"));
      syn.tone_on(0, tone::new("d"));
 
+     syn.tone_off(0, tone::new("d"));
+
      let mut buffer1 = Vec::<f32>::new();
      let mut buffer2 = Vec::<f32>::new();
      syn.render(&mut buffer1, &mut buffer2);
@@ -118,6 +114,8 @@ mod test {
      syn.tone_on(0, tone::new("c"));
      syn.tone_on(0, tone::new("d"));
 
+     syn.tone_off(0, tone::new("d"));
+
      let mut buffer1 = Vec::<f32>::new();
      let mut buffer2 = Vec::<f32>::new();
      syn.render(&mut buffer1, &mut buffer2);

src/testdata/battle_against_a_true_hero.txt

@@ -1,9 +0,0 @@
-# https://www.musicnotes.com/sheetmusic/chrissy-ricker/battle-against-a-true-hero-easy/MN0235808
-# c major
-
-CM4 CM5 CM5 CM1 CM1 CM2 . .
-
-CM3 CM0 CM0 CM4 CM4 .   . .
-
-CM4 CM5 CM5 CM1 CM1 CM2 . .
-

src/testdata/chord_progressions.txt

@@ -1,12 +0,0 @@
-# x+0 x+5 x+7 x+0
-CM0 CM3 CM4 CM0
-
-.
-
-# x+2 x+7 x+0
-CM1 CM4 CM0
-
-.
-
-# x+0 x+7 x+9 x+5
-CM0 CM4 CM5 CM3

src/testdata/fifth_wheel.txt

@@ -1,5 +0,0 @@
-# fifth wheel = +7 semitones
-# f -> c -> g -> d -> a -> e -> b
-
-f  c  g  d  a  e  b
-ff cf gf df af ef bf

src/testdata/major_chord_progressions.txt

@@ -1,19 +0,0 @@
-CM0  CM3  CM4  CM0
-CM0T CM3T CM4T CM0T
-CM0f CM3f CM4f CM0f
-
-.
-.
-.
-
-CM1  CM4  CM0
-CM1T CM4T CM0T
-CM1f CM4f CM0f
-
-.
-.
-.
-
-CM0  CM4  CM5  CM3
-CM0T CM4T CM5T CM3T
-CM0f CM4f CM5f CM3f

src/testdata/major_chords.txt

@@ -1,27 +0,0 @@
-# major CHORD = root + major_third + perfect_fifth
-# c = c,e,g
-
-f
-a
-c
-
-c
-e
-g
-
-g
-b
-d
-
-d
-f+
-a
-
-a
-c+
-e
-
-e
-g+
-b
-

src/testdata/major_third.txt

@@ -1,18 +0,0 @@
-# major third
-# +2 letters (the third letter) with exactly 2 sharps between
-
-# c,e c+,f d,f+
-c   c+   d
-cT  c+T  dT
-
-# d+,g e,g+ f,a
-d+  e  f
-d+T eT fT
-
-# f+,a+ g,b g+,c
-f+  g  g+
-f+T gT g+T
-
-# a,c+ a+,d b,d+
-a     a+    b
-aT    a+T   bT

src/testdata/minor_chords.txt

@@ -1,27 +0,0 @@
-# minor CHORD = root + minor_third + perfect_fifth
-# c = c,e-,g
-
-f
-g+
-c
-
-c
-e-
-g
-
-g
-a+
-d
-
-d
-f
-a
-
-a
-c
-e
-
-e
-g
-b
-

src/testdata/minor_third.txt

@@ -1,18 +0,0 @@
-# minor third
-# +2 letters (the third letter) with exactly 1 half step between
-
-# c,e- c+,e d,f
-c  c+  d
-ct c+t dt
-
-# d+,f+ e,g f,g+
-d+  e  f
-d+t et ft
-
-# f+,a g,a+ g+,b
-f+  g  g+
-f+t gt g+t
-
-# a,c a+,c+ b,d
-a  a+  b
-at a+t bt

src/testdata/plus_three_sounds_nice.txt

@@ -1,12 +0,0 @@
-#CM0 CM3 CM4 CM0
-#CM1 CM4 CM0
-#CM0 CM4 CM5 CM3
-
-# 1 4 6 4 # pop101
-#GM0 GM3 GM5 GM3
-
-60
-63
-66
-69
-72

src/testdata/sandbox.txt

@@ -1,12 +0,0 @@
-#CM0 CM3 CM4 CM0
-#CM1 CM4 CM0
-#CM0 CM4 CM5 CM3
-
-# 1 4 6 4 # pop101
-#GM0 GM3 GM5 GM3
-
-60
-63
-66
-69
-72

src/testdata/single_line_file.txt

@@ -1 +0,0 @@
-a b c

src/testdata/two_channels_one_bar.txt

@@ -1,2 +0,0 @@
-2*a 2*b 2*c
-. a5 . b5 . c5

src/testdata/two_channels_two_bars.txt

@@ -1,5 +0,0 @@
-a b c
-2*a 2*b 2*c
-
-d e f
-2*d 2*e 2*f

src/tone.rs

@@ -8,44 +8,21 @@ pub fn new<S: ToString>(s: S) -> Tone {
 
 impl Tone {
    fn new(s: String) -> Tone {
-        let re = regex::Regex::new(r"^(((?<letter>^[a-g])(?<sharpness>[+-]?)|(?<major>[A-G]M[0-6])|(?<minor>[A-G]m[0-6]))(?<octave>[1-5]?)((?<major_third>T)|(?<minor_third>t)|(?<fifth>f))?|(?<numeric>[0-9]+)|(?<rest>[^a-gA-G0-9]))$").unwrap();
+      let re = regex::Regex::new(r"^((?<letter>^[a-g])(?<sharpness>[+-]?)(?<octave>[1-5]?)|(?<numeric>[0-9]+)|(?<rest>[^a-zA-Z0-9]))$").unwrap();
-        let captures = re
+      let captures = re.captures(&s).expect(format!("tone '{}' does not match regex", s).as_ref());
-            .captures(&s)
-            .expect(format!("tone '{}' does not match regex", s).as_ref());
       Tone (match captures.name("numeric") {
          Some(number) => number.as_str().parse::<i32>().unwrap(),
          None => match captures.name("rest") {
             Some(_) => 0,
             _ => {
-                    let mut result = match captures.name("letter") {
+               let mut result = match captures.name("letter").unwrap().as_str() {
-                        Some(letter) => Tone::char_to_middle_i32(letter.as_str()),
+                  "a" => 57,
-                        None => match captures.name("major") {
+                  "b" => 59,
-                            Some(major) => {
+                  "c" => 60,
-                                Tone::char_to_middle_i32(&major.as_str()[..1])
+                  "d" => 62,
-                                    + match &major.as_str()[2..] {
+                  "e" => 64,
-                                        "0" => 0,
+                  "f" => 65,
-                                        "1" => 2,
+                  _ => 67,
-                                        "2" => 4,
-                                        "3" => 5,
-                                        "4" => 7,
-                                        "5" => 9,
-                                        _ => 11,
-                                    }
-                            }
-                            None => {
-                                let minor = captures.name("minor").unwrap();
-                                Tone::char_to_middle_i32(&minor.as_str()[..1])
-                                    + match &minor.as_str()[2..] {
-                                        "0" => 0,
-                                        "1" => 2,
-                                        "2" => 3,
-                                        "3" => 5,
-                                        "4" => 7,
-                                        "5" => 8,
-                                        _ => 10,
-                                    }
-                            }
-                        },
                } as i32;
 
                result += match captures.name("sharpness") {
@@ -65,70 +42,15 @@ impl Tone {
                   None => 0,
                } as i32;
 
-                    result += match captures.name("major_third") {
-                        Some(_) => 4, // TODO not all are good
-                        None => 0,
-                    } as i32;
-
-                    result += match captures.name("minor_third") {
-                        Some(_) => 3, // TODO not all are good
-                        None => 0,
-                    } as i32;
-
-                    result += match captures.name("fifth") {
-                        Some(_) => 7,
-                        None => 0,
-                    } as i32;
-
                result
-                }
+            },
          },
       })
    }
 
-    fn char_to_middle_i32(c: &str) -> i32 {
-        match c.to_lowercase().as_str() {
-            "a" => 57,
-            "b" => 59,
-            "c" => 60,
-            "d" => 62,
-            "e" => 64,
-            "f" => 65,
-            _ => 67,
-        }
-    }
-
    pub fn i32(&self) -> i32 {
       self.0
    }
-
-    pub fn string(&self) -> String {
-        let v = self.i32();
-        let modifier = if v > 0 && v < 57 {
-            "-"
-        } else if v >= 69 {
-            "+"
-        } else {
-            ""
-        };
-        modifier.to_string()
-            + match v {
-                45 | 57 | 69 => "a",
-                46 | 58 | 70 => "a+",
-                47 | 59 | 71 => "b",
-                48 | 60 | 72 => "c",
-                49 | 61 | 73 => "c+",
-                50 | 62 | 74 => "d",
-                51 | 63 | 75 => "d+",
-                52 | 64 | 76 => "e",
-                53 | 65 | 77 => "f",
-                54 | 66 | 78 => "f+",
-                55 | 67 | 79 => "g",
-                56 | 68 | 80 => "g+",
-                0 => " ",
-                _ => "?",
-            }
-    }
 }
 
 #[cfg(test)]
@@ -158,84 +80,4 @@ mod test {
       eprintln!("alpha mod octave");
       assert_eq!(super::new("c+4").i32(), 60+12+1);
    }
-
-    #[test]
-    fn test_tone_new_major_third() {
-        assert_eq!(super::new("cT").i32(), 60 + 4);
-        assert_eq!(super::new("c1T").i32(), 60 + 4 - 24);
-
-        assert_eq!(super::new("c+T").i32(), 60 + 1 + 4);
-        assert_eq!(super::new("c+1T").i32(), 60 + 1 + 4 - 24);
-
-        assert_eq!(super::new("CM0T").i32(), 60 + 4);
-        assert_eq!(super::new("CM01T").i32(), 60 + 4 - 24);
-    }
-
-    #[test]
-    fn test_tone_new_minor_third() {
-        assert_eq!(super::new("ct").i32(), 60 + 3);
-        assert_eq!(super::new("c1t").i32(), 60 + 3 - 24);
-
-        assert_eq!(super::new("c+t").i32(), 60 + 1 + 3);
-        assert_eq!(super::new("c+1t").i32(), 60 + 1 + 3 - 24);
-
-        assert_eq!(super::new("CM0t").i32(), 60 + 3);
-        assert_eq!(super::new("CM01t").i32(), 60 + 3 - 24);
-    }
-
-    #[test]
-    fn test_tone_new_fifth() {
-        assert_eq!(super::new("cf").i32(), 60 + 7);
-        assert_eq!(super::new("c1f").i32(), 60 + 7 - 24);
-
-        assert_eq!(super::new("c+f").i32(), 60 + 1 + 7);
-        assert_eq!(super::new("c+1f").i32(), 60 + 1 + 7 - 24);
-
-        assert_eq!(super::new("CM0f").i32(), 60 + 7);
-        assert_eq!(super::new("CM01f").i32(), 60 + 7 - 24);
-    }
-
-    #[test]
-    fn test_tone_c_major() {
-        assert_eq!(super::new("CM0"), super::new("c"));
-        assert_eq!(super::new("CM1"), super::new("d"));
-        assert_eq!(super::new("CM2"), super::new("e"));
-        assert_eq!(super::new("CM3"), super::new("f"));
-        assert_eq!(super::new("CM4"), super::new("g"));
-        assert_eq!(super::new("CM5"), super::new("a4"));
-        assert_eq!(super::new("CM6"), super::new("b4"));
-    }
-
-    #[test]
-    fn test_tone_c_minor() {
-        assert_eq!(super::new("Cm0"), super::new("c"));
-        assert_eq!(super::new("Cm1"), super::new("d"));
-        assert_eq!(super::new("Cm2"), super::new("e-"));
-        assert_eq!(super::new("Cm3"), super::new("f"));
-        assert_eq!(super::new("Cm4"), super::new("g"));
-        assert_eq!(super::new("Cm5"), super::new("a-4"));
-        assert_eq!(super::new("Cm6"), super::new("b-4"));
-    }
-
-    #[test]
-    fn test_tone_a_major() {
-        assert_eq!(super::new("AM0"), super::new("a"));
-        assert_eq!(super::new("AM1"), super::new("b"));
-        assert_eq!(super::new("AM2"), super::new("c+"));
-        assert_eq!(super::new("AM3"), super::new("d"));
-        assert_eq!(super::new("AM4"), super::new("e"));
-        assert_eq!(super::new("AM5"), super::new("f+"));
-        assert_eq!(super::new("AM6"), super::new("g+"));
-    }
-
-    #[test]
-    fn test_tone_a_minor() {
-        assert_eq!(super::new("Am0"), super::new("a"));
-        assert_eq!(super::new("Am1"), super::new("b"));
-        assert_eq!(super::new("Am2"), super::new("c"));
-        assert_eq!(super::new("Am3"), super::new("d"));
-        assert_eq!(super::new("Am4"), super::new("e"));
-        assert_eq!(super::new("Am5"), super::new("f"));
-        assert_eq!(super::new("Am6"), super::new("g"));
-    }
 }

todo.yaml

@@ -1,9 +0,0 @@
-todo:
-- can output .wav
-- can output .midi
-scheduled: []
-done: 
-- change define offset instead of only c==60
-- change change offset instead of only c==60 in file
-- can choose minor/major/other scale
-- can change minor/major/other scale in file