WIP

src/seq.rs

@@ -111,7 +111,7 @@ 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") {
@@ -134,10 +134,11 @@ mod test {
 
       seq.append("c");
       seq.append("4d");
+      seq.append("2-");
       seq.append("g 2e");
 
-      assert_eq!(seq.beats.len(), 4);
+      assert_eq!(seq.beats.len(), 5);
-      assert_eq!(seq.len(), 8);
+      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")));

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 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") {
+            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);
    }
 }