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,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);
    }
 }