Redesign scale-generator

This changes the design of the scale-generator class to
always have a base chromatic scale, and then operate with
intervals on that scale.

This brings the exercise more in line with the data in
problem-specifications.

Author: kytrinyx

exercises/practice/scale-generator/.meta/example.rb

@@ -1,17 +1,19 @@
 class Scale
   ASCENDING_INTERVALS = %w(m M A)
-  CHROMATIC_SCALE = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
+  CHROMATIC_SCALE = %w(C C# D D# E F F# G G# A A# B)
   FLAT_CHROMATIC_SCALE = %w(C Db D Eb E F Gb G Ab A Bb B)
   FLAT_KEYS = %w(F Bb Eb Ab Db Gb d g c f bb eb)
 
-  def initialize(tonic, pattern = nil)
+  def initialize(tonic)
     @tonic = tonic.capitalize
-    @pattern = pattern
     @chromatic_scale = FLAT_KEYS.include?(tonic) ? FLAT_CHROMATIC_SCALE : CHROMATIC_SCALE
   end
 
-  def pitches
-    return reorder_chromatic_scale unless pattern
+  def chromatic
+    reorder_chromatic_scale
+  end
+
+  def interval(pattern)
     last_index = 0
     scale = pattern.each_char.with_object([]) do |c, collector|
       collector << reorder_chromatic_scale[last_index]
@@ -21,10 +23,10 @@ def pitches
 
   private
 
-  attr_reader :tonic, :pattern, :chromatic_scale
+  attr_reader :tonic, :chromatic_scale
 
   def reorder_chromatic_scale
-    return chromatic_scale if tonic == 'C'
+    return chromatic_scale if tonic == "C"
     index = chromatic_scale.index(tonic)
     chromatic_scale[index..-1] + chromatic_scale[0..index - 1]
   end

exercises/practice/scale-generator/scale_generator_test.rb

@@ -2,131 +2,105 @@
 require_relative 'scale_generator'
 
 class ScaleGeneratorTest < Minitest::Test
-  def test_chromatic_scale
+  def test_chromatic_scales_chromatic_scale_with_sharps
+    # skip
+    scale = Scale.new("C")
+    assert_equal ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"], scale.chromatic
+  end
+
+  def test_chromatic_scales_chromatic_scale_with_flats
     skip
-    chromatic = Scale.new('C')
-    expected = %w[C C# D D# E F F# G G# A A# B]
-    actual = chromatic.pitches
-    assert_equal expected, actual
+    scale = Scale.new("F")
+    assert_equal %w[F Gb G Ab A Bb B C Db D Eb E], scale.chromatic
   end
 
-  def test_another_chromatic_scale
+  def test_scales_with_specified_intervals_simple_major_scale
     skip
-    chromatic = Scale.new('F')
-    expected = %w[F Gb G Ab A Bb B C Db D Eb E]
-    actual = chromatic.pitches
-    assert_equal expected, actual
+    scale = Scale.new("C")
+    assert_equal %w[C D E F G A B], scale.interval("MMmMMMm")
   end
 
-  def test_major_scale
+  def test_scales_with_specified_intervals_major_scale_with_sharps
     skip
-    major = Scale.new('C', 'MMmMMMm')
-    expected = %w[C D E F G A B]
-    actual = major.pitches
-    assert_equal expected, actual
+    scale = Scale.new("G")
+    assert_equal ["G", "A", "B", "C", "D", "E", "F#"], scale.interval("MMmMMMm")
   end
 
-  def test_another_major_scale
+  def test_scales_with_specified_intervals_major_scale_with_flats
     skip
-    major = Scale.new('G', 'MMmMMMm')
-    expected = %w[G A B C D E F#]
-    actual = major.pitches
-    assert_equal expected, actual
+    scale = Scale.new("F")
+    assert_equal %w[F G A Bb C D E], scale.interval("MMmMMMm")
   end
 
-  def test_minor_scale
+  def test_scales_with_specified_intervals_minor_scale_with_sharps
     skip
-    minor = Scale.new('f#', 'MmMMmMM')
-    expected = %w[F# G# A B C# D E]
-    actual = minor.pitches
-    assert_equal expected, actual
+    scale = Scale.new("f#")
+    assert_equal ["F#", "G#", "A", "B", "C#", "D", "E"], scale.interval("MmMMmMM")
   end
 
-  def test_another_minor_scale
+  def test_scales_with_specified_intervals_minor_scale_with_flats
     skip
-    minor = Scale.new('bb', 'MmMMmMM')
-    expected = %w[Bb C Db Eb F Gb Ab]
-    actual = minor.pitches
-    assert_equal expected, actual
+    scale = Scale.new("bb")
+    assert_equal %w[Bb C Db Eb F Gb Ab], scale.interval("MmMMmMM")
   end
 
-  def test_dorian_mode
+  def test_scales_with_specified_intervals_dorian_mode
     skip
-    dorian = Scale.new('d', 'MmMMMmM')
-    expected = %w[D E F G A B C]
-    actual = dorian.pitches
-    assert_equal expected, actual
+    scale = Scale.new("d")
+    assert_equal %w[D E F G A B C], scale.interval("MmMMMmM")
   end
 
-  def test_mixolydian_mode
+  def test_scales_with_specified_intervals_mixolydian_mode
     skip
-    mixolydian = Scale.new('Eb', 'MMmMMmM')
-    expected = %w[Eb F G Ab Bb C Db]
-    actual = mixolydian.pitches
-    assert_equal expected, actual
+    scale = Scale.new("Eb")
+    assert_equal %w[Eb F G Ab Bb C Db], scale.interval("MMmMMmM")
   end
 
-  def test_lydian_mode
+  def test_scales_with_specified_intervals_lydian_mode
     skip
-    lydian = Scale.new('a', 'MMMmMMm')
-    expected = %w[A B C# D# E F# G#]
-    actual = lydian.pitches
-    assert_equal expected, actual
+    scale = Scale.new("a")
+    assert_equal ["A", "B", "C#", "D#", "E", "F#", "G#"], scale.interval("MMMmMMm")
   end
 
-  def test_phrygian_mode
+  def test_scales_with_specified_intervals_phrygian_mode
     skip
-    phrygian = Scale.new('e', 'mMMMmMM')
-    expected = %w[E F G A B C D]
-    actual = phrygian.pitches
-    assert_equal expected, actual
+    scale = Scale.new("e")
+    assert_equal %w[E F G A B C D], scale.interval("mMMMmMM")
   end
 
-  def test_locrian_mode
+  def test_scales_with_specified_intervals_locrian_mode
     skip
-    locrian = Scale.new('g', 'mMMmMMM')
-    expected = %w[G Ab Bb C Db Eb F]
-    actual = locrian.pitches
-    assert_equal expected, actual
+    scale = Scale.new("g")
+    assert_equal %w[G Ab Bb C Db Eb F], scale.interval("mMMmMMM")
   end
 
-  def test_harmonic_minor
+  def test_scales_with_specified_intervals_harmonic_minor
     skip
-    harmonic_minor = Scale.new('d', 'MmMMmAm')
-    expected = %w[D E F G A Bb Db]
-    actual = harmonic_minor.pitches
-    assert_equal expected, actual
+    scale = Scale.new("d")
+    assert_equal %w[D E F G A Bb Db], scale.interval("MmMMmAm")
   end
 
-  def test_octatonic
+  def test_scales_with_specified_intervals_octatonic
     skip
-    octatonic = Scale.new('C', 'MmMmMmMm')
-    expected = %w[C D D# F F# G# A B]
-    actual = octatonic.pitches
-    assert_equal expected, actual
+    scale = Scale.new("C")
+    assert_equal ["C", "D", "D#", "F", "F#", "G#", "A", "B"], scale.interval("MmMmMmMm")
   end
 
-  def test_hexatonic
+  def test_scales_with_specified_intervals_hexatonic
     skip
-    hexatonic = Scale.new('Db', 'MMMMMM')
-    expected = %w[Db Eb F G A B]
-    actual = hexatonic.pitches
-    assert_equal expected, actual
+    scale = Scale.new("Db")
+    assert_equal %w[Db Eb F G A B], scale.interval("MMMMMM")
   end
 
-  def test_pentatonic
+  def test_scales_with_specified_intervals_pentatonic
     skip
-    pentatonic = Scale.new('A', 'MMAMA')
-    expected = %w[A B C# E F#]
-    actual = pentatonic.pitches
-    assert_equal expected, actual
+    scale = Scale.new("A")
+    assert_equal ["A", "B", "C#", "E", "F#"], scale.interval("MMAMA")
   end
 
-  def test_enigmatic
+  def test_scales_with_specified_intervals_enigmatic
     skip
-    enigmatic = Scale.new('G', 'mAMMMmM')
-    expected = %w[G G# B C# D# F F#]
-    actual = enigmatic.pitches
-    assert_equal expected, actual
+    scale = Scale.new("G")
+    assert_equal ["G", "G#", "B", "C#", "D#", "F", "F#"], scale.interval("mAMMMmm")
   end
 end