reststs AND rustfmt changed whitespace

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::tone;
 use crate::syn;
+use crate::tone;
 
 pub struct SynSeq {
     seqs: std::collections::HashMap<i32, Seq>,
@@ -7,7 +7,7 @@ pub struct SynSeq {
 }
 
 pub fn new_syn(syn: syn::Syn) -> SynSeq {
-   SynSeq{
+    SynSeq {
         seqs: std::collections::HashMap::new(),
         syn: syn,
     }
@@ -21,7 +21,7 @@ impl SynSeq {
                 let mut seq = new();
                 seq.append(s);
                 self.seqs.insert(ch, seq);
-         },
+            }
         };
     }
 
@@ -29,13 +29,11 @@ impl SynSeq {
         for (ch, seq) in self.seqs.iter_mut() {
             let ch = ch.clone();
             match seq.pop() {
-            (Some(tone), changed) if changed => {
+                (Some(tone), changed) if changed => self.syn.set(ch, Some(tone.clone())),
-               self.syn.set(ch, Some(tone.clone()))
-            },
                 (None, changed) if changed => {
                     self.syn.set(ch, None);
-            },
+                }
-            _ => {},
+                _ => {}
             };
         }
         self.syn.render(left, right);
@@ -66,7 +64,7 @@ fn new() -> Seq {
 
 impl Seq {
     fn new() -> Seq {
-      Seq{
+        Seq {
             beats: vec![],
             state: None,
         }
@@ -97,7 +95,7 @@ impl Seq {
                 _ => {
                     self.beats[0].0 -= 1;
                     Some(self.beats[0].1.clone())
-            },
+                }
             },
         }
     }
@@ -142,14 +140,17 @@ 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], (1 as usize, tone::new("g")));
+        assert_eq!(seq.beats[2], (2 as usize, tone::new("!")));
-      assert_eq!(seq.beats[3], (2 as usize, tone::new("e")));
+        assert_eq!(seq.beats[3], (1 as usize, tone::new("g")));
+        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::Synthesizer;
 use rustysynth::SoundFont;
+use rustysynth::Synthesizer;
 use rustysynth::SynthesizerSettings;
 use std::sync::Arc;
 
@@ -7,7 +7,7 @@ use crate::tone;
 
 pub enum Syn {
     Real(Synthesizer),
-   Text{
+    Text {
         m: std::collections::HashMap<i32, std::collections::HashMap<i32, i32>>,
         i: u32,
     },
@@ -17,7 +17,10 @@ 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{m: std::collections::HashMap::new(), i: 0},
+            true => Syn::Text {
+                m: std::collections::HashMap::new(),
+                i: 0,
+            },
         }
     }
 
@@ -37,10 +40,10 @@ impl Syn {
             // velocity=[0..128)
             Syn::Real(syn) => {
                 syn.note_off_all_channel(ch, false);
-         },
+            }
-         Syn::Text{m, ..} => {
+            Syn::Text { m, .. } => {
                 m.remove(&ch);
-         },
+            }
         };
         if let Some(tone) = b {
             self.tone_on(ch, tone);
@@ -52,39 +55,42 @@ impl Syn {
             // channel=[0..16)
             // velocity=[0..128)
             Syn::Real(syn) => syn.note_on(ch, b.i32(), 127),
-         Syn::Text{m, ..} => {
+            Syn::Text { m, .. } => {
                 match m.get_mut(&ch) {
-               Some(m2) => { m2.insert(b.i32(), 127); },
+                    Some(m2) => {
+                        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, ..} => {
+            Syn::Text { m, .. } => {
                 match m.get_mut(&ch) {
-               Some(m) => { m.remove(&b.i32()); },
+                    Some(m) => {
-               None => {},
+                        m.remove(&b.i32());
+                    }
+                    None => {}
                 };
-
+            }
-         },
         };
     }
 
     pub fn render(&mut self, a: &mut [f32], b: &mut [f32]) {
         match self {
             Syn::Real(syn) => syn.render(a, b),
-         Syn::Text{m, i} => {
+            Syn::Text { m, i } => {
                 eprintln!("{} | render[{}]({:?})", chrono::prelude::Utc::now(), i, m);
                 *i += 1;
-         },
+            }
         };
     }
 }

src/tone.rs

@@ -9,8 +9,10 @@ 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.captures(&s).expect(format!("tone '{}' does not match regex", s).as_ref());
+        let captures = re
-      Tone (match captures.name("numeric") {
+            .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,
@@ -43,7 +45,7 @@ impl Tone {
                     } as i32;
 
                     result
-            },
+                }
             },
         })
     }
@@ -70,14 +72,14 @@ mod test {
         assert_eq!(super::new("g").i32(), 67);
 
         eprintln!("alpha mod");
-      assert_eq!(super::new("c+").i32(), 60+1);
+        assert_eq!(super::new("c+").i32(), 60 + 1);
-      assert_eq!(super::new("c-").i32(), 60-1);
+        assert_eq!(super::new("c-").i32(), 60 - 1);
 
         eprintln!("alpha octave");
         assert_eq!(super::new("c3").i32(), 60);
-      assert_eq!(super::new("c4").i32(), 60+12);
+        assert_eq!(super::new("c4").i32(), 60 + 12);
 
         eprintln!("alpha mod octave");
-      assert_eq!(super::new("c+4").i32(), 60+12+1);
+        assert_eq!(super::new("c+4").i32(), 60 + 12 + 1);
     }
 }