beats 2.1.0 → 2.1.1

data/test/{songoptimizer_test.rb → song_optimizer_test.rb}

@@ -50,12 +50,11 @@ Verse:
   - snare:  ..........X."
 
   def self.load_fixture(fixture_name)
-    SongParser.new.parse(FIXTURE_BASE_PATH, File.read("test/fixtures/#{fixture_name}"))
+    SongParser.parse(FIXTURE_BASE_PATH, File.read("test/fixtures/#{fixture_name}"))
   end
 
   def test_optimize
-    parser = SongParser.new
-    original_song, kit = parser.parse(File.dirname(__FILE__), EXAMPLE_SONG_YAML)
+    original_song, _ = SongParser.parse(File.dirname(__FILE__), EXAMPLE_SONG_YAML)
 
     optimizer = SongOptimizer.new
     optimized_song = optimizer.optimize(original_song, 4)
@@ -123,8 +122,7 @@ Verse:
   end
 
   def test_optimize_song_nondivisible_max_pattern_length
-    parser = SongParser.new
-    original_song, kit = parser.parse(File.dirname(__FILE__), EXAMPLE_SONG_YAML_EMPTY_SUB_PATTERN)
+    original_song, _ = SongParser.parse(File.dirname(__FILE__), EXAMPLE_SONG_YAML_EMPTY_SUB_PATTERN)
 
     optimizer = SongOptimizer.new
     optimized_song = optimizer.optimize(original_song, 7)
@@ -142,7 +140,7 @@ Verse:
   end
 
   def test_pattern_collision
-    original_song, kit = SongOptimizerTest.load_fixture("valid/optimize_pattern_collision.txt")
+    original_song, _ = SongOptimizerTest.load_fixture("valid/optimize_pattern_collision.txt")
     optimizer = SongOptimizer.new
     optimized_song = optimizer.optimize(original_song, 4)
 
@@ -150,8 +148,7 @@ Verse:
   end
 
   def test_optimize_song_containing_empty_pattern
-    parser = SongParser.new
-    original_song, kit = parser.parse(File.dirname(__FILE__), EXAMPLE_SONG_YAML_EMPTY_SUB_PATTERN)
+    original_song, _ = SongParser.parse(File.dirname(__FILE__), EXAMPLE_SONG_YAML_EMPTY_SUB_PATTERN)
 
     optimizer = SongOptimizer.new
     optimized_song = optimizer.optimize(original_song, 4)

data/test/{songparser_test.rb → song_parser_test.rb}

@@ -24,24 +24,68 @@ class SongParserTest < Minitest::Test
                       :sound_in_kit_wrong_format,
                       :sound_in_track_wrong_format]
 
-  # TODO: Add somes tests to validate the Kits
+  def test_song_header_different_capitalization
+    song, kit = load_fixture("valid/example_song_header_different_capitalization.txt")
+
+    assert_equal(100, song.tempo)
+    assert_equal([:verse, :chorus, :chorus, :verse, :chorus, :chorus], song.flow)
+    assert_equal(["bass", "snare", "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], kit.labels)
+    assert_equal(2, song.patterns.length)
+    assert_equal(2, song.patterns[:verse].tracks.length)
+    assert_equal("X...X...X...X...", song.patterns[:verse].tracks["bass"].rhythm)
+    assert_equal("..............X.", song.patterns[:verse].tracks["snare"].rhythm)
+    assert_equal(2, song.patterns[:chorus].tracks.length)
+    assert_equal("X...X...XX..X...", song.patterns[:chorus].tracks["bass"].rhythm)
+    assert_equal("....X.......X...", song.patterns[:chorus].tracks["snare"].rhythm)
+  end
+
+  def test_multiple_song_headers
+    song, kit = load_fixture("valid/multiple_song_header_sections.txt")
+
+    assert_equal(200, song.tempo)
+    assert_equal([:chorus, :chorus, :chorus, :chorus], song.flow)
+    assert_equal(["bass", "snare", "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], kit.labels)
+    assert_equal(2, song.patterns.length)
+    assert_equal(2, song.patterns[:verse].tracks.length)
+    assert_equal("X...X...X...X...", song.patterns[:verse].tracks["bass"].rhythm)
+    assert_equal("..............X.", song.patterns[:verse].tracks["snare"].rhythm)
+    assert_equal(2, song.patterns[:chorus].tracks.length)
+    assert_equal("X...X...XX..X...", song.patterns[:chorus].tracks["bass"].rhythm)
+    assert_equal("....X.......X...", song.patterns[:chorus].tracks["snare"].rhythm)
+  end
+
+  def test_multiple_patterns_same_name
+    song, kit = load_fixture("valid/multiple_patterns_same_name.txt")
+
+    assert_equal(120, song.tempo)
+    assert_equal([:verse, :verse, :chorus, :chorus, :verse, :verse, :chorus, :chorus], song.flow)
+    assert_equal(["bass", "snare", "hh_closed", "agogo", "test/sounds/tom4_mono_8.wav", "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], kit.labels)
+    assert_equal(2, song.patterns.length)
+    assert_equal(3, song.patterns[:verse].tracks.length)
+    assert_equal("X.X.X.X.", song.patterns[:verse].tracks["bass"].rhythm)
+    assert_equal(".X.X.X.X", song.patterns[:verse].tracks["snare"].rhythm)
+    assert_equal("XXXXXX..", song.patterns[:verse].tracks["test/sounds/tom4_mono_8.wav"].rhythm)
+    assert_equal(2, song.patterns[:chorus].tracks.length)
+    assert_equal("X...X...XX..X...", song.patterns[:chorus].tracks["bass"].rhythm)
+    assert_equal("....X.......X...", song.patterns[:chorus].tracks["snare"].rhythm)
+  end
 
   def test_no_tempo
-    song, kit = load_fixture("valid/no_tempo.txt")
+    song, _ = load_fixture("valid/no_tempo.txt")
 
     assert_equal(120, song.tempo)
     assert_equal([:verse], song.flow)
   end
 
   def test_fractional_tempo
-    song, kit = load_fixture("valid/fractional_tempo.txt")
+    song, _ = load_fixture("valid/fractional_tempo.txt")
 
     assert_equal(95.764, song.tempo)
     assert_equal([:verse, :verse, :chorus, :chorus], song.flow)
   end
 
   def test_repeats_not_specified
-    song, kit = load_fixture("valid/repeats_not_specified.txt")
+    song, _ = load_fixture("valid/repeats_not_specified.txt")
 
     assert_equal(100, song.tempo)
     assert_equal([:verse], song.flow)
@@ -51,6 +95,7 @@ class SongParserTest < Minitest::Test
     song, kit = load_fixture("valid/example_flow_patterns_different_capitalization.txt")
 
     assert_equal(100, song.tempo)
+    assert_equal(["bass", "snare", "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], kit.labels)
     assert_equal([:verse, :chorus, :chorus, :verse, :chorus, :chorus], song.flow)
     assert_equal(2, song.patterns.length)
     assert_equal(2, song.patterns[:verse].tracks.length)
@@ -61,10 +106,39 @@ class SongParserTest < Minitest::Test
     assert_equal("....X.......X...", song.patterns[:chorus].tracks["snare"].rhythm)
   end
 
+  def test_song_with_empty_kit
+    song, kit = load_fixture("valid/empty_kit.txt")
+
+    assert_equal(100, song.tempo)
+    assert_equal(["test/sounds/bass_mono_8.wav", "test/sounds/snare_mono_8.wav", "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], kit.labels)
+    assert_equal([:verse, :verse, :chorus, :chorus], song.flow)
+    assert_equal(2, song.patterns.length)
+    assert_equal(2, song.patterns[:verse].tracks.length)
+    assert_equal("X...X...", song.patterns[:verse].tracks["test/sounds/bass_mono_8.wav"].rhythm)
+    assert_equal("..X...X.", song.patterns[:verse].tracks["test/sounds/snare_mono_8.wav"].rhythm)
+    assert_equal(2, song.patterns[:chorus].tracks.length)
+    assert_equal("XXXXXXXX", song.patterns[:chorus].tracks["test/sounds/bass_mono_8.wav"].rhythm)
+    assert_equal(".X.X.X.X", song.patterns[:chorus].tracks["test/sounds/snare_mono_8.wav"].rhythm)
+  end
+
   def test_song_with_unused_kit
     no_kit_song, no_kit_kit = load_fixture("valid/example_no_kit.txt")
     kit_song, kit_kit = load_fixture("valid/example_with_kit.txt")
 
+    assert_equal(["test/sounds/bass_mono_8.wav",
+                  "test/sounds/snare_mono_8.wav",
+                  "test/sounds/hh_closed_mono_8.wav",
+                  "test/sounds/hh_open_mono_8.wav",
+                  "test/sounds/ride_mono_8.wav",
+                  "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], no_kit_kit.labels)
+    assert_equal(["bass",
+                  "snare",
+                  "hhclosed",
+                  "hhopen",
+                  "test/sounds/hh_closed_mono_8.wav",
+                  "test/sounds/ride_mono_8.wav",
+                  "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], kit_kit.labels)
+
     # These two songs should be the same, except that one uses a kit in the song header
     # and the other doesn't.
     [no_kit_song, kit_song].each do |song|
@@ -84,7 +158,7 @@ class SongParserTest < Minitest::Test
   end
 
   def test_empty_track
-    song, kit = load_fixture("valid/example_with_empty_track.txt")
+    song, _ = load_fixture("valid/example_with_empty_track.txt")
 
     assert_equal(1, song.patterns.length)
     assert_equal(2, song.patterns[:verse].tracks.length)
@@ -93,7 +167,7 @@ class SongParserTest < Minitest::Test
   end
 
   def test_track_with_spaces
-    song, kit = load_fixture("valid/track_with_spaces.txt")
+    song, _ = load_fixture("valid/track_with_spaces.txt")
 
     assert_equal(1, song.patterns.length)
     assert_equal(2, song.patterns[:verse].tracks.length)
@@ -102,7 +176,7 @@ class SongParserTest < Minitest::Test
   end
 
   def test_multiple_tracks_same_sound
-    song, kit = load_fixture("valid/multiple_tracks_same_sound.txt")
+    song, _ = load_fixture("valid/multiple_tracks_same_sound.txt")
 
     assert_equal(2, song.patterns.length)
     assert_equal(7, song.patterns[:verse].tracks.length)
@@ -126,7 +200,7 @@ class SongParserTest < Minitest::Test
   end
 
   def test_swung_8
-    song, kit = load_fixture("valid/example_swung_8th.txt")
+    song, _ = load_fixture("valid/example_swung_8th.txt")
 
     assert_equal(180, song.tempo)
     assert_equal([:verse, :verse, :chorus, :chorus], song.flow)
@@ -140,7 +214,7 @@ class SongParserTest < Minitest::Test
   end
 
   def test_swung_16
-    song, kit = load_fixture("valid/example_swung_16th.txt")
+    song, _ = load_fixture("valid/example_swung_16th.txt")
 
     assert_equal(180, song.tempo)
     assert_equal([:verse, :verse, :chorus, :chorus], song.flow)
@@ -154,7 +228,7 @@ class SongParserTest < Minitest::Test
   end
 
   def test_unswung_song
-    song, kit = load_fixture("valid/example_unswung.txt")
+    song, _ = load_fixture("valid/example_unswung.txt")
 
     assert_equal(120, song.tempo)
     assert_equal([:verse, :verse, :chorus, :chorus], song.flow)
@@ -171,6 +245,7 @@ class SongParserTest < Minitest::Test
     song, kit = load_fixture("valid/track_with_composite_kit_sounds.txt")
 
     assert_equal(100, song.tempo)
+    assert_equal(["bass", "snare", "hh_closed", "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], kit.labels)
     assert_equal([:verse, :verse, :chorus, :chorus], song.flow)
     assert_equal(2, song.patterns.length)
     assert_equal(3, song.patterns[:verse].tracks.length)
@@ -187,6 +262,12 @@ class SongParserTest < Minitest::Test
     song, kit = load_fixture("valid/track_with_composite_non_kit_sound.txt")
 
     assert_equal(100, song.tempo)
+    assert_equal(["bass",
+                  "snare",
+                  "hh_closed",
+                  "test/sounds/agogo_high_mono_8.wav",
+                  "test/sounds/hh_open_mono_8.wav",
+                  "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], kit.labels)
     assert_equal([:verse, :verse, :chorus, :chorus], song.flow)
     assert_equal(2, song.patterns.length)
     assert_equal(2, song.patterns[:verse].tracks.length)
@@ -202,6 +283,11 @@ class SongParserTest < Minitest::Test
     song, kit = load_fixture("valid/track_with_composite_mix_kit_and_not_kit_sound.txt")
 
     assert_equal(100, song.tempo)
+    assert_equal(["bass",
+                  "snare",
+                  "hh_closed",
+                  "test/sounds/hh_open_mono_8.wav",
+                  "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], kit.labels)
     assert_equal([:verse, :verse, :chorus, :chorus], song.flow)
     assert_equal(2, song.patterns.length)
     assert_equal(2, song.patterns[:verse].tracks.length)
@@ -217,6 +303,13 @@ class SongParserTest < Minitest::Test
     song, kit = load_fixture("valid/track_with_composite_mix_kit_and_not_kit_sound_2.txt")
 
     assert_equal(100, song.tempo)
+    assert_equal(["bass",
+                  "snare",
+                  "hihat-hh_closed_mono_8",
+                  "hihat-hh_open_mono_8",
+                  "test/sounds/agogo_high_mono_8.wav",
+                  "test/sounds/agogo_low_mono_8.wav",
+                  "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], kit.labels)
     assert_equal([:verse, :verse, :chorus, :chorus], song.flow)
     assert_equal(2, song.patterns.length)
     assert_equal(3, song.patterns[:verse].tracks.length)
@@ -235,6 +328,7 @@ class SongParserTest < Minitest::Test
     song, kit = load_fixture("valid/track_with_composite_single_sound.txt")
 
     assert_equal(100, song.tempo)
+    assert_equal(["bass", "snare", "hh_closed", "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], kit.labels)
     assert_equal([:verse, :verse, :chorus, :chorus], song.flow)
     assert_equal(2, song.patterns.length)
     assert_equal(2, song.patterns[:verse].tracks.length)
@@ -249,6 +343,7 @@ class SongParserTest < Minitest::Test
     song, kit = load_fixture("valid/kit_with_composite_sounds.txt")
 
     assert_equal(100, song.tempo)
+    assert_equal(["bass", "snare", "hihat-hh_closed_mono_8", "hihat-hh_open_mono_8", "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], kit.labels)
     assert_equal([:verse, :verse, :chorus, :chorus], song.flow)
     assert_equal(2, song.patterns.length)
     assert_equal(3, song.patterns[:verse].tracks.length)
@@ -266,6 +361,7 @@ class SongParserTest < Minitest::Test
     song, kit = load_fixture("valid/kit_with_composite_single_sound.txt")
 
     assert_equal(100, song.tempo)
+    assert_equal(["bass", "snare", "hihat-hh_closed_mono_8", "empty_track_placeholder_name_234hkj32hjk4hjkhds23"], kit.labels)
     assert_equal([:verse, :verse, :chorus, :chorus], song.flow)
     assert_equal(2, song.patterns.length)
     assert_equal(2, song.patterns[:verse].tracks.length)
@@ -280,18 +376,18 @@ class SongParserTest < Minitest::Test
   def test_invalid_parse
     INVALID_FIXTURES.each do |fixture|
       assert_raises(SongParser::ParseError) do
-        song, kit = load_fixture("invalid/#{fixture}.txt")
+        _, _ = load_fixture("invalid/#{fixture}.txt")
       end
     end
 
     assert_raises(Track::InvalidRhythmError) do
-      song, kit = load_fixture("invalid/bad_rhythm.txt")
+      _, _ = load_fixture("invalid/bad_rhythm.txt")
     end
   end
 
 private
 
   def load_fixture(fixture_name)
-    SongParser.new.parse(FIXTURE_BASE_PATH, File.read("test/fixtures/#{fixture_name}"))
+    SongParser.parse(FIXTURE_BASE_PATH, File.read("test/fixtures/#{fixture_name}"))
   end
 end

data/test/song_swinger_test.rb

@@ -3,7 +3,7 @@ require 'includes'
 class SongSwingerTest < Minitest::Test
   def test_full_song_swing_rate_8
     base_path = File.dirname(__FILE__) + "/sounds"
-    song, kit = SongParser.new.parse(base_path, File.read("test/fixtures/valid/example_mono_16_base_path.txt"))
+    song, _ = SongParser.parse(base_path, File.read("test/fixtures/valid/example_mono_16_base_path.txt"))
 
     shuffled_song = Transforms::SongSwinger.transform(song, 8)
 
@@ -47,7 +47,7 @@ class SongSwingerTest < Minitest::Test
 
   def test_full_song_swing_rate_16
     base_path = File.dirname(__FILE__) + "/sounds"
-    song, kit = SongParser.new.parse(base_path, File.read("test/fixtures/valid/example_mono_16_base_path.txt"))
+    song, _ = SongParser.parse(base_path, File.read("test/fixtures/valid/example_mono_16_base_path.txt"))
 
     shuffled_song = Transforms::SongSwinger.transform(song, 16)
 
@@ -157,8 +157,10 @@ class SongSwingerTest < Minitest::Test
     expectations.each do |original_rhythm, expected_rhythm|
       song = Song.new
 
-      pattern = song.pattern(:my_pattern)
-      pattern.track("track1", original_rhythm)
+      pattern_tracks = [
+        Track.new("track1", original_rhythm),
+      ]
+      pattern = song.pattern(:my_pattern, pattern_tracks)
 
       song.pattern(pattern)
 

data/test/song_test.rb

@@ -13,25 +13,30 @@ class SongTest < Minitest::Test
     test_songs[:blank] = Song.new
 
     test_songs[:no_flow] = Song.new
-    verse = test_songs[:no_flow].pattern :verse
-    verse.track "bass.wav",      "X.......X......."
-    verse.track "snare.wav",     "....X.......X..."
-    verse.track "hh_closed.wav", "X.X.X.X.X.X.X.X."
+    verse_tracks = [
+      Track.new("bass.wav",      "X.......X......."),
+      Track.new("snare.wav",     "....X.......X..."),
+      Track.new("hh_closed.wav", "X.X.X.X.X.X.X.X."),
+    ]
+    test_songs[:no_flow].pattern(:verse, verse_tracks)
 
-    song_parser = SongParser.new
     FIXTURES.each do |fixture_name|
-      test_songs[fixture_name], throwaway_kit = song_parser.parse(base_path, File.read("test/fixtures/valid/#{fixture_name}.txt"))
+      test_songs[fixture_name], _ = SongParser.parse(base_path, File.read("test/fixtures/valid/#{fixture_name}.txt"))
     end
 
     test_songs[:from_code] = Song.new
-    verse = test_songs[:from_code].pattern :verse
-    verse.track "bass.wav",      "X.......X......."
-    verse.track "snare.wav",     "....X.......X..."
-    verse.track "hh_closed.wav", "X.X.X.X.X.X.X.X."
-    chorus = test_songs[:from_code].pattern :chorus
-    chorus.track "bass.wav",  "X......."
-    chorus.track "snare.wav", "....X..X"
-    chorus.track "ride.wav",  "X.....X."
+    verse_tracks = [
+      Track.new("bass.wav",      "X.......X......."),
+      Track.new("snare.wav",     "....X.......X..."),
+      Track.new("hh_closed.wav", "X.X.X.X.X.X.X.X."),
+    ]
+    test_songs[:from_code].pattern(:verse, verse_tracks)
+    chorus_tracks = [
+      Track.new("bass.wav",  "X......."),
+      Track.new("snare.wav", "....X..X"),
+      Track.new("ride.wav",  "X.....X."),
+    ]
+    test_songs[:from_code].pattern(:chorus, chorus_tracks)
     test_songs[:from_code].flow = [:verse, :chorus, :verse, :chorus, :chorus]
 
     test_songs
@@ -74,6 +79,19 @@ class SongTest < Minitest::Test
     chorus = song.pattern(:Chorus)
     assert_equal(2, song.patterns.length)
     assert_equal({:Chorus => chorus, :Verse => verse2}, song.patterns)
+
+    tracks = [
+      Track.new("track1", "X...X..."),
+      Track.new("track2", "X..."),
+    ]
+    tracks_provided = song.pattern(:Tracks_Provided, tracks)
+    assert_equal(3, song.patterns.length)
+    assert_equal({:Chorus => chorus, :Tracks_Provided => tracks_provided, :Verse => verse2}, song.patterns)
+    assert_equal(["track1", "track2"], song.track_names)
+    assert_equal(tracks_provided.tracks["track1"].rhythm, "X...X...")
+    assert_equal(tracks_provided.tracks["track1"].name, "track1")
+    assert_equal(tracks_provided.tracks["track2"].rhythm, "X.......")
+    assert_equal(tracks_provided.tracks["track2"].name, "track2")
   end
 
   def test_total_tracks

data/test/track_test.rb

@@ -44,13 +44,59 @@ class TrackTest < Minitest::Test
     assert_equal("..XX..X...X...X.X...X...X...X...", test_tracks[:complicated].rhythm)
   end
 
+  def test_invalid_name
+    assert_raises(ArgumentError) { Track.new(:verse, "X...X...|X...X...") }
+    assert_raises(ArgumentError) { Track.new([], "X...X...|X...X...") }
+    assert_raises(ArgumentError) { Track.new({ :foo => :bar }, "X...X...|X...X...") }
+  end
+
+  def test_name_is_frozen
+    original_name = "Verse"
+    track = Track.new(original_name, "X...X...|X...X...")
+
+    # Track is initialized properly
+    assert_equal("Verse", track.name)
+    assert_equal("Verse", original_name)
+
+    # Name is frozen
+    assert_raises(RuntimeError) { track.name << "X" }
+
+    # Changing the original string doesn't modify the track name
+    original_name << "2"
+    assert_equal("Verse", track.name)
+    assert_equal("Verse2", original_name)
+  end
+
+  def test_rhythm_is_frozen
+    original_rhythm = "X...X...|X...X..."
+    track = Track.new("my_track", original_rhythm)
+
+    # Track is initialized properly
+    assert_equal("X...X...X...X...", track.rhythm)
+    assert_equal("X...X...|X...X...", original_rhythm)
+
+    # Rhythm is frozen
+    assert_raises(RuntimeError) { track.rhythm << "X" }
+
+    # Changing the original string doesn't modify the rhythm
+    original_rhythm << "X"
+    assert_equal("X...X...X...X...", track.rhythm)
+    assert_equal("X...X...|X...X...X", original_rhythm)
+  end
+
   def test_invalid_rhythm
-    assert_raises(Track::InvalidRhythmError) { Track.new("bad_rhythm", "abcde") }
-    assert_raises(Track::InvalidRhythmError) { Track.new("bad_rhythm", "X.X.e.X") }
+    [nil, 12, [], {}, :"X...X...", "abcde", "X.X.e.X"].each do |bad_rhythm|
+      assert_raises(Track::InvalidRhythmError) { Track.new("bad_rhythm", bad_rhythm) }
+    end
+  end
+
+  def test_trigger_step_lengths_is_frozen
+    track = Track.new("my_track", "X...X...|X...X...")
+
+    assert_equal([0, 4, 4, 4, 4], track.trigger_step_lengths)
 
-    track = Track.new("test", "X...")
-    assert_raises(Track::InvalidRhythmError) { track.rhythm = "abcde" }
-    assert_raises(Track::InvalidRhythmError) { track.rhythm = "X.X.e.X" }
+    assert_raises(RuntimeError) { track.trigger_step_lengths[2] = 5 }
+    assert_raises(RuntimeError) { track.trigger_step_lengths << [1] }
   end
 
   def test_step_count