WIP

src/main.rs

@@ -1,9 +1,9 @@
 use itertools::Itertools;
 
 mod flags;
-mod seq;
 mod syn;
 mod tone;
+mod seq;
 
 fn main() {
     let flags = flags::Flags::new();

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);
@@ -95,7 +97,7 @@ impl Seq {
             _ => {
                self.beats[0].0 -= 1;
                Some(self.beats[0].1.clone())
-                }
+            },
          },
       }
    }
@@ -140,17 +142,14 @@ mod test {
 
       assert_eq!(seq.beats[0], (1 as usize, tone::new("c")));
       assert_eq!(seq.beats[1], (4 as usize, tone::new("d")));
-        assert_eq!(seq.beats[2], (2 as usize, tone::new("!")));
+      assert_eq!(seq.beats[2], (1 as usize, tone::new("g")));
-        assert_eq!(seq.beats[3], (1 as usize, tone::new("g")));
+      assert_eq!(seq.beats[3], (2 as usize, tone::new("e")));
-        assert_eq!(seq.beats[4], (2 as usize, tone::new("e")));
 
       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));

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,14 @@ 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);
-                    }
+               },
             };
-            }
+         },
       };
    }
 
@@ -75,12 +70,11 @@ impl Syn {
          Syn::Real(syn) => syn.note_off(ch, b.i32()),
          Syn::Text{m, ..} => {
             match m.get_mut(&ch) {
-                    Some(m) => {
+               Some(m) => { m.remove(&b.i32()); },
-                        m.remove(&b.i32());
+               None => {},
-                    }
-                    None => {}
             };
-            }
+
+         },
       };
    }
 
@@ -90,7 +84,7 @@ impl Syn {
          Syn::Text{m, i} => {
             eprintln!("{} | render[{}]({:?})", chrono::prelude::Utc::now(), i, m);
             *i += 1;
-            }
+         },
       };
    }
 }

src/tone.rs

@@ -9,9 +9,7 @@ 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>[+-]?)(?<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") {
@@ -45,7 +43,7 @@ impl Tone {
                } as i32;
 
                result
-                }
+            },
          },
       })
    }