WIP

src/main.rs

@@ -28,8 +28,8 @@ fn play(mut s: seq::SynSeq, sample_rate: usize, bpm: usize) {
         sample_rate: sample_rate,
         channel_sample_count: samples_per_beat,
     };
-    let beats = s.beats();
+    let beats = s.beats() + 3;
-    let duration = 1 + 60 * beats / bpm;
+    let duration = 60 * beats / bpm;
 
     let sample_count = (params.channel_sample_count) as usize;
     let mut left: Vec<f32> = vec![0_f32; sample_count];

src/seq.rs

@@ -44,8 +44,8 @@ impl SynSeq {
    pub fn beats(&self) -> usize {
       let mut longest = 0 as usize;
       for (_, seq) in self.seqs.iter() {
-         longest = if seq.beats.len() > longest {
+         longest = if seq.len() > longest {
-            seq.beats.len()
+            seq.len()
          } else {
             longest
          };
@@ -56,7 +56,7 @@ impl SynSeq {
 
 #[derive(PartialEq)]
 pub struct Seq {
-   beats: Vec<(i32, tone::Tone)>,
+   beats: Vec<(usize, tone::Tone)>,
    state: Option<tone::Tone>,
 }
 
@@ -72,6 +72,14 @@ impl Seq {
       }
    }
 
+   fn len(&self) -> usize {
+      let mut sum = 0 as usize;
+      for beat in self.beats.iter() {
+         sum += beat.0 as usize;
+      }
+      sum
+   }
+
    fn pop(&mut self) -> (Option<tone::Tone>, bool) {
       let state_before = self.state.clone();
       let tone_after = self._pop();
@@ -103,13 +111,13 @@ impl Seq {
    }
 
    fn append_one(&mut self, s: String) {
-      let re = regex::Regex::new(r"^(?<count>[0-9]*)(?<tone>[a-z].*)$").unwrap();
+      let re = regex::Regex::new(r"^(?<count>[0-9]*)(?<tone>.*)$").unwrap();
       let captures = re.captures(&s).unwrap();
 
       let n = match captures.name("count") {
          Some(number) if number.as_str().len() > 0 => number.as_str().parse::<usize>().unwrap(),
          _ => 1,
-      } as i32;
+      } as usize;
 
       let tone = tone::new(captures.name("tone").unwrap().as_str());
       self.beats.push((n, tone));
@@ -123,14 +131,19 @@ mod test {
    #[test]
    fn test_seq() {
       let mut seq = new();
+
       seq.append("c");
       seq.append("4d");
+      seq.append("2-");
       seq.append("g 2e");
-      assert_eq!(seq.beats.len(), 4);
+
-      assert_eq!(seq.beats[0], (1 as i32, tone::new("c")));
+      assert_eq!(seq.beats.len(), 5);
-      assert_eq!(seq.beats[1], (4 as i32, tone::new("d")));
+      assert_eq!(seq.len(), 10);
-      assert_eq!(seq.beats[2], (1 as i32, tone::new("g")));
+
-      assert_eq!(seq.beats[3], (2 as i32, tone::new("e")));
+      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[3], (2 as usize, tone::new("e")));
 
       assert_eq!(seq.pop(), (Some(tone::new("c")), true));
       assert_eq!(seq.pop(), (Some(tone::new("d")), true));

src/tone.rs

@@ -8,39 +8,42 @@ 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]+))$").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.captures(s.as_ref()).unwrap();
+      let captures = re.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 => {
+         None => match captures.name("rest") {
-            let mut result = match captures.name("letter").unwrap().as_str() {
+            Some(_) => 0,
-               "a" => 57,
+            _ => {
-               "b" => 59,
+               let mut result = match captures.name("letter").unwrap().as_str() {
-               "c" => 60,
+                  "a" => 57,
-               "d" => 62,
+                  "b" => 59,
-               "e" => 64,
+                  "c" => 60,
-               "f" => 65,
+                  "d" => 62,
-               _ => 67,
+                  "e" => 64,
-            } as i32;
+                  "f" => 65,
+                  _ => 67,
+               } as i32;
 
-            result += match captures.name("sharpness") {
+               result += match captures.name("sharpness") {
-               Some(sharpness) => match sharpness.as_str() {
+                  Some(sharpness) => match sharpness.as_str() {
-                  "+" => 1,
+                     "+" => 1,
-                  "-" => -1,
+                     "-" => -1,
-                  _ => 0,
+                     _ => 0,
-               },
+                  },
-               None => 0,
+                  None => 0,
-            } as i32;
+               } as i32;
 
-            result += match captures.name("octave") {
+               result += match captures.name("octave") {
-               Some(octave) => match octave.as_str() {
+                  Some(octave) => match octave.as_str() {
-                  "" => 0,
+                     "" => 0,
-                  _ => (octave.as_str().parse::<i32>().unwrap() - 3) * 12,
+                     _ => (octave.as_str().parse::<i32>().unwrap() - 3) * 12,
-               },
+                  },
-               None => 0,
+                  None => 0,
-            } as i32;
+               } as i32;
 
-            result
+               result
+            },
          },
       })
    }
@@ -54,18 +57,27 @@ impl Tone {
 mod test {
    #[test]
    fn test_tone_new() {
+      eprintln!("numeric");
       assert_eq!(super::new("60").i32(), 60);
 
+      eprintln!("rests");
+      assert_eq!(super::new("-").i32(), 0);
+      assert_eq!(super::new(".").i32(), 0);
+
+      eprintln!("alpha");
       assert_eq!(super::new("c").i32(), 60);
       assert_eq!(super::new("e").i32(), 64);
       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);
 
+      eprintln!("alpha octave");
       assert_eq!(super::new("c3").i32(), 60);
       assert_eq!(super::new("c4").i32(), 60+12);
 
+      eprintln!("alpha mod octave");
       assert_eq!(super::new("c+4").i32(), 60+12+1);
    }
 }