fix note and add tests

src/blip.rs

@@ -0,0 +1,18 @@
+use crate::note::Note;
+
+/// thanks to Rumple_Frumpkins from Bitsy Talk for his help in figuring out the blip format.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Blip {
+    id: String,
+    notes: Vec<Note>,
+    name: Option<String>,
+    /// Attack (ms), Decay (ms), Sustain (level: 1-15), Hold (sustain duration, ms), Release (ms)
+    envelope: [u8; 5],
+    /// first value is milliseconds per note;
+    /// second value is a modifier to the first note (add or subtract milliseconds)
+    beat: [i16; 2],
+    /// I think this is probably pulse width. apparently the potential values are P2, P4 and P8.
+    square: String,
+    /// Notes can sound repeatedly, or just once as the blip fades out.
+    repeat: bool,
+}

src/note.rs

@@ -1,5 +1,6 @@
 use core::fmt;
 use std::fmt::Formatter;
+use crate::Error;
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum RelativeNote {
@@ -23,6 +24,35 @@ pub struct Note {
     octave: u8, // upper limit? 8?
 }
 
+impl Note {
+    fn from(str: &str) -> Result<Self, Error> {
+        let mut chars: Vec<char> = str.chars().collect();
+
+        // last char may or may not be present / may or may not be an octave number
+        let octave = chars.pop().unwrap_or('4').to_string().parse().unwrap_or(4);
+
+        let chars: String = chars.into_iter().collect();
+
+        let relative = match chars.as_ref() {
+             "C"  => RelativeNote::C,
+             "C#" => RelativeNote::CSharp,
+             "D"  => RelativeNote::D,
+             "D#" => RelativeNote::DSharp,
+             "E"  => RelativeNote::E,
+             "F"  => RelativeNote::F,
+             "F#" => RelativeNote::FSharp,
+             "G"  => RelativeNote::G,
+             "G#" => RelativeNote::GSharp,
+             "A"  => RelativeNote::A,
+             "A#" => RelativeNote::ASharp,
+             "B"  => RelativeNote::B,
+            _ => { return Err(Error::RelativeNote); }
+        };
+
+        Ok(Note { relative, octave })
+    }
+}
+
 impl fmt::Display for Note {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(
@@ -60,4 +90,20 @@ mod test {
     fn a_sharp_0() {
         assert_eq!(Note { relative: RelativeNote::ASharp, octave: 0 }.to_string(), "A#0");
     }
+
+    #[test]
+    fn c_sharp_3_from_str() {
+        assert_eq!(
+            Note::from("C#3").unwrap(),
+            Note { relative: RelativeNote::CSharp, octave: 3 }
+        );
+    }
+
+    #[test]
+    fn b_0_from_str() {
+        assert_eq!(
+            Note::from("B0").unwrap(),
+            Note { relative: RelativeNote::B, octave: 0 }
+        );
+    }
 }