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 duration = 1 + 60 * beats / bpm;
+    let beats = s.beats() + 3;
+    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 {
-            seq.beats.len()
+         longest = if seq.len() > longest {
+            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[1], (4 as i32, tone::new("d")));
-      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.len(), 5);
+      assert_eq!(seq.len(), 10);
+
+      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,11 +8,13 @@ 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 captures = re.captures(s.as_ref()).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).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") {
+            Some(_) => 0,
+            _ => {
                let mut result = match captures.name("letter").unwrap().as_str() {
                   "a" => 57,
                   "b" => 59,
@@ -42,6 +44,7 @@ impl Tone {
 
                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);
    }
 }