Add dominant and minor seventh chords (#26)

noeddl · web-flow · commit 66aa86a88a78 · 2019-10-12T21:32:01.000+02:00
* Add minor seventh to intervals

* Rename ChordQuality to ChordType

* Add dominant 7th chords

* Add minor 7th chords
diff --git a/src/chord/chord.rs b/src/chord/chord.rs
@@ -20,30 +20,35 @@ impl fmt::Display for ParseChordError {
     }
 }
 
-/// Chord quality.
-/// https://en.wikipedia.org/wiki/Chord_names_and_symbols_(popular_music)#Chord_quality
+/// The type of the chord depending on the intervals it contains.
 #[derive(Debug, Clone, Copy, PartialEq)]
-pub enum ChordQuality {
+pub enum ChordType {
     Major,
     Minor,
+    DominantSeventh,
+    MinorSeventh,
 }
 
-impl ChordQuality {
+impl ChordType {
     fn get_intervals(self) -> Vec<Interval> {
         use Interval::*;
 
         match self {
             Self::Major => vec![PerfectUnison, MajorThird, PerfectFifth],
             Self::Minor => vec![PerfectUnison, MinorThird, PerfectFifth],
+            Self::DominantSeventh => vec![PerfectUnison, MajorThird, PerfectFifth, MinorSeventh],
+            Self::MinorSeventh => vec![PerfectUnison, MinorThird, PerfectFifth, MinorSeventh],
         }
     }
 }
 
-impl fmt::Display for ChordQuality {
+impl fmt::Display for ChordType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = match self {
             Self::Major => "major",
             Self::Minor => "minor",
+            Self::DominantSeventh => "dominant 7th",
+            Self::MinorSeventh => "minor 7th",
         };
 
         write!(f, "{}", s)
@@ -53,7 +58,7 @@ impl fmt::Display for ChordQuality {
 /// A chord such as C, Cm and so on.
 pub struct Chord {
     name: String,
-    pub quality: ChordQuality,
+    pub chord_type: ChordType,
     pub root: Note,
     notes: Vec<Note>,
 }
@@ -64,7 +69,7 @@ impl Chord {
     }
 
     pub fn get_diagram(self, min_fret: FretID) -> ChordDiagram {
-        let chord_shapes = ChordShapeSet::new(self.quality);
+        let chord_shapes = ChordShapeSet::new(self.chord_type);
 
         let (frets, intervals) = chord_shapes.get_config(self.root, min_fret);
 
@@ -80,7 +85,7 @@ impl Chord {
 
 impl fmt::Display for Chord {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{} - {} {}", self.name, self.notes[0], self.quality)
+        write!(f, "{} - {} {}", self.name, self.notes[0], self.chord_type)
     }
 }
 
@@ -91,7 +96,7 @@ impl FromStr for Chord {
         let name = s.to_string();
 
         // Regular expression for chord names.
-        let re = Regex::new(r"(?P<root>[CDEFGAB][#b]?)(?P<quality>m?)").unwrap();
+        let re = Regex::new(r"(?P<root>[CDEFGAB][#b]?)(?P<type>m?7?)").unwrap();
 
         // Match regex.
         let caps = match re.captures(s) {
@@ -105,30 +110,33 @@ impl FromStr for Chord {
             Err(_) => return Err(ParseChordError { name }),
         };
 
-        // Get chord quality.
-        let quality = match &caps["quality"] {
-            "m" => ChordQuality::Minor,
-            _ => ChordQuality::Major,
+        // Get chord type.
+        let chord_type = match &caps["type"] {
+            "m" => ChordType::Minor,
+            "7" => ChordType::DominantSeventh,
+            "m7" => ChordType::MinorSeventh,
+            _ => ChordType::Major,
         };
 
         // Collect notes of the chord.
         let mut notes = vec![];
 
-        for interval in quality.get_intervals() {
+        for interval in chord_type.get_intervals() {
             notes.push(root + interval);
         }
 
         Ok(Self {
             name,
             root,
-            quality,
+            chord_type,
             notes,
         })
     }
 }
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::many_single_char_names)]
     use super::*;
     use rstest::rstest_parametrize;
 
@@ -161,7 +169,7 @@ mod tests {
         let t = Note::from_str(third).unwrap();
         let f = Note::from_str(fifth).unwrap();
         assert_eq!(c.notes, vec![r, t, f]);
-        assert_eq!(c.quality, ChordQuality::Major);
+        assert_eq!(c.chord_type, ChordType::Major);
     }
 
     #[rstest_parametrize(
@@ -193,7 +201,87 @@ mod tests {
         let t = Note::from_str(third).unwrap();
         let f = Note::from_str(fifth).unwrap();
         assert_eq!(c.notes, vec![r, t, f]);
-        assert_eq!(c.quality, ChordQuality::Minor);
+        assert_eq!(c.chord_type, ChordType::Minor);
+    }
+
+    #[rstest_parametrize(
+        chord,
+        root,
+        third,
+        fifth,
+        seventh,
+        case("C7", "C", "E", "G", "Bb"),
+        case("C#7", "C#", "F", "G#", "B"),
+        case("Db7", "Db", "F", "Ab", "B"),
+        case("D7", "D", "F#", "A", "C"),
+        case("D#7", "D#", "G", "A#", "C#"),
+        case("Eb7", "Eb", "G", "Bb", "Db"),
+        case("E7", "E", "G#", "B", "D"),
+        case("F7", "F", "A", "C", "Eb"),
+        case("F#7", "F#", "A#", "C#", "E"),
+        case("Gb7", "Gb", "Bb", "Db", "E"),
+        case("G7", "G", "B", "D", "F"),
+        case("G#7", "G#", "C", "D#", "F#"),
+        case("Ab7", "Ab", "C", "Eb", "Gb"),
+        case("A7", "A", "C#", "E", "G"),
+        case("A#7", "A#", "D", "F", "G#"),
+        case("Bb7", "Bb", "D", "F", "Ab"),
+        case("B7", "B", "D#", "F#", "A")
+    )]
+    fn test_from_str_dominant_seventh(
+        chord: &str,
+        root: &str,
+        third: &str,
+        fifth: &str,
+        seventh: &str,
+    ) {
+        let c = Chord::from_str(chord).unwrap();
+        let r = Note::from_str(root).unwrap();
+        let t = Note::from_str(third).unwrap();
+        let f = Note::from_str(fifth).unwrap();
+        let s = Note::from_str(seventh).unwrap();
+        assert_eq!(c.notes, vec![r, t, f, s]);
+        assert_eq!(c.chord_type, ChordType::DominantSeventh);
+    }
+
+    #[rstest_parametrize(
+        chord,
+        root,
+        third,
+        fifth,
+        seventh,
+        case("Cm7", "C", "Eb", "G", "Bb"),
+        case("C#m7", "C#", "E", "G#", "B"),
+        case("Dbm7", "Db", "E", "Ab", "B"),
+        case("Dm7", "D", "F", "A", "C"),
+        case("D#m7", "D#", "F#", "A#", "C#"),
+        case("Ebm7", "Eb", "Gb", "Bb", "Db"),
+        case("Em7", "E", "G", "B", "D"),
+        case("Fm7", "F", "Ab", "C", "Eb"),
+        case("F#m7", "F#", "A", "C#", "E"),
+        case("Gbm7", "Gb", "A", "Db", "E"),
+        case("Gm7", "G", "Bb", "D", "F"),
+        case("G#m7", "G#", "B", "D#", "F#"),
+        case("Abm7", "Ab", "B", "Eb", "Gb"),
+        case("Am7", "A", "C", "E", "G"),
+        case("A#m7", "A#", "C#", "F", "G#"),
+        case("Bbm7", "Bb", "Db", "F", "Ab"),
+        case("Bm7", "B", "D", "F#", "A")
+    )]
+    fn test_from_str_minor_seventh(
+        chord: &str,
+        root: &str,
+        third: &str,
+        fifth: &str,
+        seventh: &str,
+    ) {
+        let c = Chord::from_str(chord).unwrap();
+        let r = Note::from_str(root).unwrap();
+        let t = Note::from_str(third).unwrap();
+        let f = Note::from_str(fifth).unwrap();
+        let s = Note::from_str(seventh).unwrap();
+        assert_eq!(c.notes, vec![r, t, f, s]);
+        assert_eq!(c.chord_type, ChordType::MinorSeventh);
     }
 
     #[rstest_parametrize(
diff --git a/src/chord/chord_shape.rs b/src/chord/chord_shape.rs
@@ -1,4 +1,4 @@
-use crate::chord::ChordQuality;
+use crate::chord::ChordType;
 use crate::chord::FretID;
 use crate::chord::FretPattern;
 use crate::note::Interval;
@@ -10,8 +10,8 @@ use std::str::FromStr;
 type IntervalPattern = [Interval; STRING_COUNT];
 
 /// A chord shape is a configuration of frets to be pressed to play a
-/// chord with a certain chord quality. The shape can be moved along
-/// the fretboard to derive several chords.
+/// certain type of chord. The shape can be moved along the fretboard
+/// to derive several chords.
 ///
 /// http://play-ukulele.simonplantinga.nl/2014/05/ukulele-chords-iii/
 /// https://newhamukes.wordpress.com/2013/08/30/moveable-chords/
@@ -58,22 +58,36 @@ pub struct ChordShapeSet {
 }
 
 impl ChordShapeSet {
-    pub fn new(chord_quality: ChordQuality) -> Self {
-        let chord_shapes = match chord_quality {
-            ChordQuality::Major => vec![
+    pub fn new(chord_type: ChordType) -> Self {
+        let chord_shapes = match chord_type {
+            ChordType::Major => vec![
                 ChordShape::new("C", [0, 0, 0, 3], ["P5", "P1", "M3", "P1"]),
                 ChordShape::new("A", [2, 1, 0, 0], ["P1", "M3", "P5", "P1"]),
                 ChordShape::new("G", [0, 2, 3, 2], ["P1", "P5", "P1", "M3"]),
                 ChordShape::new("F", [2, 0, 1, 0], ["M3", "P5", "P1", "M3"]),
                 ChordShape::new("D", [2, 2, 2, 0], ["P5", "P1", "M3", "P5"]),
             ],
-            ChordQuality::Minor => vec![
+            ChordType::Minor => vec![
                 ChordShape::new("C", [0, 3, 3, 3], ["P5", "m3", "P5", "P1"]),
                 ChordShape::new("A", [2, 0, 0, 0], ["P1", "m3", "P5", "P1"]),
                 ChordShape::new("G", [0, 2, 3, 1], ["P1", "P5", "P1", "m3"]),
                 ChordShape::new("F", [1, 0, 1, 3], ["m3", "P5", "P1", "P5"]),
                 ChordShape::new("D", [2, 2, 1, 0], ["P5", "P1", "m3", "P5"]),
             ],
+            ChordType::DominantSeventh => vec![
+                ChordShape::new("C", [0, 0, 0, 1], ["P5", "P1", "M3", "m7"]),
+                ChordShape::new("A", [0, 1, 0, 0], ["m7", "M3", "P5", "P1"]),
+                ChordShape::new("G", [0, 2, 1, 2], ["P1", "P5", "m7", "M3"]),
+                ChordShape::new("E", [1, 2, 0, 2], ["M3", "m7", "P1", "P5"]),
+                ChordShape::new("D", [2, 0, 2, 0], ["P5", "m7", "M3", "P5"]),
+            ],
+            ChordType::MinorSeventh => vec![
+                ChordShape::new("C#", [1, 1, 0, 2], ["P5", "P1", "m3", "m7"]),
+                ChordShape::new("A", [0, 0, 0, 0], ["m7", "m3", "P5", "P1"]),
+                ChordShape::new("G", [0, 2, 1, 1], ["P1", "P5", "m7", "m3"]),
+                ChordShape::new("E", [0, 2, 0, 2], ["m3", "m7", "P1", "P5"]),
+                ChordShape::new("D", [2, 0, 1, 0], ["P5", "m7", "m3", "P5"]),
+            ],
         };
 
         Self { chord_shapes }
diff --git a/src/chord/mod.rs b/src/chord/mod.rs
@@ -3,7 +3,7 @@ mod chord;
 mod chord_shape;
 
 pub use self::chord::Chord;
-pub use self::chord::ChordQuality;
+pub use self::chord::ChordType;
 pub use self::chord_shape::ChordShape;
 pub use self::chord_shape::ChordShapeSet;
 
diff --git a/src/note/interval.rs b/src/note/interval.rs
@@ -23,6 +23,7 @@ pub enum Interval {
     MinorThird,
     MajorThird,
     PerfectFifth,
+    MinorSeventh,
 }
 
 impl Interval {
@@ -35,6 +36,7 @@ impl Interval {
             MinorThird => 3,
             MajorThird => 4,
             PerfectFifth => 7,
+            MinorSeventh => 10,
         }
     }
 
@@ -48,6 +50,7 @@ impl Interval {
             MinorThird => 3,
             MajorThird => 3,
             PerfectFifth => 5,
+            MinorSeventh => 7,
         }
     }
 }
@@ -65,6 +68,7 @@ impl FromStr for Interval {
             "P5" => PerfectFifth,
             "m3" => MinorThird,
             "M3" => MajorThird,
+            "m7" => MinorSeventh,
             _ => return Err(ParseIntervalError { name }),
         };
 
diff --git a/tests/ukebox.rs b/tests/ukebox.rs

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@ pub enum Interval {`
`23`	`23`	`MinorThird,`
`24`	`24`	`MajorThird,`
`25`	`25`	`PerfectFifth,`
	`26`	`+ MinorSeventh,`
`26`	`27`	`}`
`27`	`28`
`28`	`29`	`impl Interval {`
`@@ -35,6 +36,7 @@ impl Interval {`
`35`	`36`	`MinorThird => 3,`
`36`	`37`	`MajorThird => 4,`
`37`	`38`	`PerfectFifth => 7,`
	`39`	`+ MinorSeventh => 10,`
`38`	`40`	`}`
`39`	`41`	`}`
`40`	`42`
`@@ -48,6 +50,7 @@ impl Interval {`
`48`	`50`	`MinorThird => 3,`
`49`	`51`	`MajorThird => 3,`
`50`	`52`	`PerfectFifth => 5,`
	`53`	`+ MinorSeventh => 7,`
`51`	`54`	`}`
`52`	`55`	`}`
`53`	`56`	`}`
`@@ -65,6 +68,7 @@ impl FromStr for Interval {`
`65`	`68`	`"P5" => PerfectFifth,`
`66`	`69`	`"m3" => MinorThird,`
`67`	`70`	`"M3" => MajorThird,`
	`71`	`+ "m7" => MinorSeventh,`
`68`	`72`	`_ => return Err(ParseIntervalError { name }),`
`69`	`73`	`};`
`70`	`74`