beats 2.1.0 → 2.1.1

data/test/audio_utils_test.rb

@@ -0,0 +1,86 @@
+require 'includes'
+
+class AudioUtilsTest < Minitest::Test
+  def test_composite
+    assert_raises(ArgumentError) { AudioUtils.composite([[100, 200], [300, 400], [500, 600]], 0, 5) }
+    assert_raises(ArgumentError) { AudioUtils.composite([[100, 200], [300, 400], [500, 600]], -1, 5) }
+
+    # Mono empty arrays
+    assert_equal([], AudioUtils.composite([], 1))
+    assert_equal([], AudioUtils.composite([[]], 1))
+    assert_equal([], AudioUtils.composite([[], [], [], []], 1))
+
+    # Stereo empty arrays
+    assert_equal([], AudioUtils.composite([], 2))
+    assert_equal([], AudioUtils.composite([[]], 2))
+    assert_equal([], AudioUtils.composite([[], [], [], []], 2))
+
+    # Mono
+    assert_equal([10, 20, 30, 40], AudioUtils.composite([[10, 20, 30, 40]], 1))
+    assert_equal([10, 20, 30, 40], AudioUtils.composite([[10, 20, 30, 40], []], 1))
+    assert_equal([10, 20, 30, 40], AudioUtils.composite([[], [10, 20, 30, 40]], 1))
+    assert_equal([30, 50, 70, -10], AudioUtils.composite([[10, 20, 30, 40], [20, 30, 40, -50]], 1))
+    assert_equal([30, 50, 70, -10], AudioUtils.composite([[20, 30, 40, -50], [10, 20, 30, 40]], 1))
+    assert_equal([70, 80, 60], AudioUtils.composite([[20, 30], [10], [40, 50, 60]], 1))
+    assert_equal([70, 80, 60], AudioUtils.composite([[40, 50, 60], [20, 30], [10]], 1))
+
+    # Stereo
+    assert_equal([[10, 20], [30, 40]], AudioUtils.composite([[[10, 20], [30, 40]]], 2))
+    assert_equal([[10, 20], [30, 40]], AudioUtils.composite([[[10, 20], [30, 40]], []], 2))
+    assert_equal([[10, 20], [30, 40]], AudioUtils.composite([[], [[10, 20], [30, 40]]], 2))
+    assert_equal([[30, 50], [70, -10]], AudioUtils.composite([[[10, 20], [30, 40]], [[20, 30], [40, -50]]], 2))
+    assert_equal([[30, 50], [70, -10]], AudioUtils.composite([[[20, 30], [40, -50]], [[10, 20], [30, 40]]], 2))
+    assert_equal([[90, 120], [120, 140], [100, 110]], AudioUtils.composite([[[20, 30], [40, 50]], [[10, 20]], [[60, 70], [80, 90], [100, 110]]], 2))
+    assert_equal([[90, 120], [120, 140], [100, 110]], AudioUtils.composite([[[60, 70], [80, 90], [100, 110]], [[10, 20]], [[20, 30], [40, 50]]], 2))
+
+    # 3 Channel
+    assert_equal([[10, 20, 30], [30, 40, 50]], AudioUtils.composite([[[10, 20, 30], [30, 40, 50]]], 3))
+    assert_equal([[10, 20, 30], [30, 40, 50]], AudioUtils.composite([[[10, 20, 30], [30, 40, 50]], []], 3))
+    assert_equal([[10, 20, 30], [30, 40, 50]], AudioUtils.composite([[], [[10, 20, 30], [30, 40, 50]]], 3))
+    assert_equal([[30, 50, 70], [70, -10, -30]], AudioUtils.composite([[[10, 20, 30], [30, 40, 50]], [[20, 30, 40], [40, -50, -80]]], 3))
+    assert_equal([[30, 50, 70], [70, -10, -30]], AudioUtils.composite([[[20, 30, 40], [40, -50, -80]], [[10, 20, 30], [30, 40, 50]]], 3))
+    assert_equal([[90, 120, 150], [120, 140, 160], [100, 110, 120]], AudioUtils.composite([[[20, 30, 40], [40, 50, 60]],
+                                                                                           [[10, 20, 30]],
+                                                                                           [[60, 70, 80], [80, 90, 100], [100, 110, 120]]], 3))
+    assert_equal([[90, 120, 150], [120, 140, 160], [100, 110, 120]], AudioUtils.composite([[[60, 70, 80], [80, 90, 100], [100, 110, 120]],
+                                                                                           [[10, 20, 30]],
+                                                                                           [[20, 30, 40], [40, 50, 60]]], 3))
+  end
+
+  def test_scale
+    assert_equal([], AudioUtils.scale([], 1, 5))
+    assert_equal([], AudioUtils.scale([], 2, 5))
+    assert_equal([100, 200, 300, 400, 500], AudioUtils.scale([100, 200, 300, 400, 500], 1, 1))
+    assert_equal([20, 40, 60, 80, 100], AudioUtils.scale([100, 200, 300, 400, 500], 1, 5))
+
+    assert_equal([[100, 200], [300, 400], [500, 600]], AudioUtils.scale([[100, 200], [300, 400], [500, 600]], 2, 1))
+    assert_equal([[20, 40], [60, 80], [100, 120]], AudioUtils.scale([[100, 200], [300, 400], [500, 600]], 2, 5))
+
+    assert_equal([[10, 20, 30], [100, 200, 300], [1000, 2000, 3000]], AudioUtils.scale([[10, 20, 30], [100, 200, 300], [1000, 2000, 3000]], 3, 1))
+    assert_equal([[5, 10, 15], [50, 100, 150], [500, 1000, 1500]], AudioUtils.scale([[10, 20, 30], [100, 200, 300], [1000, 2000, 3000]], 3, 2))
+
+    assert_raises(ArgumentError) { AudioUtils.scale([[100, 200], [300, 400], [500, 600]], 0, 5) }
+    assert_raises(ArgumentError) { AudioUtils.scale([[100, 200], [300, 400], [500, 600]], -1, 5) }
+  end
+
+  def test_step_sample_length
+    assert_equal(6615.0, AudioUtils.step_sample_length(44100, 100))
+    assert_equal(3307.5, AudioUtils.step_sample_length(44100, 200))
+    assert_equal(3307.5, AudioUtils.step_sample_length(22050, 100))
+
+    assert_equal(6874.612880831729, AudioUtils.step_sample_length(44100, 96.2236))
+    assert_equal(3437.3064404158645, AudioUtils.step_sample_length(22050, 96.2236))
+  end
+
+  def test_step_start_sample
+    assert_equal(0, AudioUtils.step_start_sample(0, 100))
+    assert_equal(100, AudioUtils.step_start_sample(1, 100))
+    assert_equal(200, AudioUtils.step_start_sample(2, 100))
+    assert_equal(1500, AudioUtils.step_start_sample(15, 100))
+
+    assert_equal(0, AudioUtils.step_start_sample(0, 64.8))
+    assert_equal(64, AudioUtils.step_start_sample(1, 64.8))
+    assert_equal(129, AudioUtils.step_start_sample(2, 64.8))
+    assert_equal(972, AudioUtils.step_start_sample(15, 64.8))
+  end
+end

data/test/fixtures/invalid/sound_in_kit_wrong_format.txt

@@ -4,7 +4,7 @@ Song:
   Flow:
     - Verse: x1
   Kit:
-    - bad: test/songparser_test.rb
+    - bad: test/song_test.rb
 
 Verse:
   - bad: X...X...

data/test/fixtures/invalid/sound_in_track_wrong_format.txt

@@ -5,4 +5,4 @@ Song:
     - Verse: x1
 
 Verse:
-  - test/songparser_test.rb: X...X...
+  - test/song_test.rb: X...X...

data/test/fixtures/valid/empty_kit.txt

@@ -0,0 +1,14 @@
+Song:
+  Tempo: 100 
+  # Kit is defined, but has no sounds. This is valid.
+  Kit:
+  Flow:
+    - Verse:  x2
+    - Chorus: x2
+
+Verse:
+  - test/sounds/bass_mono_8.wav:   X...X...
+  - test/sounds/snare_mono_8.wav:  ..X...X.
+Chorus:
+  - test/sounds/bass_mono_8.wav:   XXXXXXXX
+  - test/sounds/snare_mono_8.wav:  .X.X.X.X

data/test/fixtures/valid/example_song_header_different_capitalization.txt

@@ -0,0 +1,21 @@
+# The elements in the "Song" header have different capitalization from the normal examples
+# The element keys should be case-insensitive, so this should be valid.
+
+SONg:
+  TeMpO: 100
+  fLoW:
+    - Verse:   x1
+    - Chorus:  x2
+    - Verse:   x1
+    - Chorus:  x2
+  kIT:
+    - bass:       test/sounds/bass_mono_8.wav
+    - snare:      test/sounds/snare_mono_8.wav
+
+Verse:
+  - bass:       X...X...X...X...
+  - snare:      ..............X.
+
+Chorus:
+  - bass:       X...X...XX..X...
+  - snare:      ....X.......X...

data/test/fixtures/valid/multiple_patterns_same_name.txt

@@ -0,0 +1,31 @@
+Song:
+  Tempo: 120
+  Flow:
+    - Verse:   x2
+    - Chorus:  x2
+    - Verse:   x2
+    - Chorus:  x2
+  Kit:
+    - bass:       test/sounds/bass_mono_8.wav
+    - snare:      test/sounds/snare_mono_8.wav
+    - hh_closed:  test/sounds/hh_closed_mono_8.wav
+    - agogo:      test/sounds/agogo_high_mono_8.wav
+
+# This pattern will be ignored because it is overridden by a different
+# 'Verse' pattern later in the file.
+Verse:
+  - bass:       X...X...X...X...
+  - snare:      ..............X.
+  - hh_closed:  X.XXX.XX........
+  - hh_closed:  ........X.X.X.X.
+  - agogo:      ..............XX
+
+Chorus:
+  - bass:                         X...X...XX..X...
+  - snare:                        ....X.......X...
+
+# This is the winner, and should override the earlier 'Verse' definition
+Verse:
+  - bass:                        X.X.X.X.
+  - snare:                       .X.X.X.X
+  - test/sounds/tom4_mono_8.wav: XXXXXX..

data/test/fixtures/valid/multiple_song_header_sections.txt

@@ -0,0 +1,29 @@
+# This song header is ignored, because it is overridden by a subsequent song
+# header at the end of the file
+Song:
+  Tempo: 100
+  Flow:
+    - Verse:   x1
+    - Chorus:  x2
+    - Verse:   x1
+    - Chorus:  x2
+  Kit:
+    - bass:       test/sounds/bass_mono_8.wav
+    - snare:      test/sounds/snare_mono_8.wav
+
+Verse:
+  - bass:       X...X...X...X...
+  - snare:      ..............X.
+
+Chorus:
+  - bass:       X...X...XX..X...
+  - snare:      ....X.......X...
+
+# This is the actual song header that should be used
+Song:
+  Tempo: 200
+  Flow:
+    - Chorus:  x4
+  Kit:
+    - bass:   test/sounds/ride_mono_8.wav
+    - snare:  test/sounds/snare2_mono_8.wav

data/test/includes.rb

@@ -1,12 +1,3 @@
-# Standard Ruby libraries
 require 'minitest/autorun'
-require 'yaml'
-require 'rubygems'
-
-# External gems
-require 'wavefile'
-
-# BEATS classes
 require 'beats'
-require 'wavefile/cachingwriter'
 include Beats

data/test/kit_builder_test.rb

@@ -12,6 +12,26 @@ class KitBuilderTest < Minitest::Test
     assert_equal(false, kit_builder.has_label?("label2"))
   end
 
+  def test_add_item
+    kit_builder = KitBuilder.new("test/sounds")
+
+    kit_builder.add_item("bass", "bass_mono_8.wav")
+    assert_equal({}, kit_builder.composite_replacements)
+
+    kit_builder.add_item("snare", ["snare_mono_8.wav", "rim_mono_8.wav"])
+    assert_equal({"snare" => ["snare-snare_mono_8", "snare-rim_mono_8"]}, kit_builder.composite_replacements)
+
+    # Re-adding the same label with different sounds replaces the value in `composite_replacments`
+    kit_builder.add_item("snare", ["hhclosed_mono_8.wav", "ride_mono_8.wav"])
+    assert_equal({"snare" => ["snare-hhclosed_mono_8", "snare-ride_mono_8"]}, kit_builder.composite_replacements)
+
+    # Re-adding the same label with a non-composite sounds removes the value from `composite_replacments`
+    kit_builder.add_item("snare", "snare_mono_8.wav")
+    assert_equal({}, kit_builder.composite_replacements)
+
+    assert_raises(KitBuilder::SoundFileNotFoundError) { kit_builder.add_item("bass", []) }
+  end
+
   def test_build_kit_happy_path
     kit_builder = KitBuilder.new("test/sounds")
 

data/test/kit_test.rb

@@ -4,6 +4,7 @@ class KitTest < Minitest::Test
   def test_kit_with_items
     kit = Kit.new({'label1' => [1,2,3], 'label2' => [4,5,6], 'label3' => [7,8,9]}, 1, 16)
 
+    assert_equal(["label1", "label2", "label3"], kit.labels)
     assert_equal([1,2,3], kit.get_sample_data('label1'))
     assert_equal([4,5,6], kit.get_sample_data('label2'))
     assert_raises(Kit::LabelNotFoundError) { kit.get_sample_data('nope') }
@@ -12,16 +13,22 @@ class KitTest < Minitest::Test
 
   def test_kit_with_no_items
     kit = Kit.new({}, 1, 16)
+
+    assert_equal([], kit.labels)
     assert_raises(Kit::LabelNotFoundError) { kit.get_sample_data('foo') }
   end
 
   def test_num_channels
     kit = Kit.new({}, 2, 16)
+
+    assert_equal([], kit.labels)
     assert_equal(2, kit.num_channels)
   end
 
   def test_bits_per_sample
     kit = Kit.new({}, 2, 16)
+
+    assert_equal([], kit.labels)
     assert_equal(16, kit.bits_per_sample)
   end
 end

data/test/pattern_test.rb

@@ -10,17 +10,21 @@ class PatternTest < Minitest::Test
     pattern = Pattern.new :blank
     test_patterns[:blank] = pattern
 
-    pattern = Pattern.new :verse
-    pattern.track "bass.wav",      "X...X...X...XX..X...X...XX..X..."
-    pattern.track "snare.wav",     "..X...X...X...X.X...X...X...X..."
-    pattern.track "hh_closed.wav", "X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X."
-    pattern.track "hh_open.wav",   "X...............X..............X"
+    verse_tracks = [
+      Track.new("bass.wav",      "X...X...X...XX..X...X...XX..X..."),
+      Track.new("snare.wav",     "..X...X...X...X.X...X...X...X..."),
+      Track.new("hh_closed.wav", "X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X."),
+      Track.new("hh_open.wav",   "X...............X..............X"),
+    ]
+    pattern = Pattern.new(:verse, verse_tracks)
     test_patterns[:verse] = pattern
 
-    pattern = Pattern.new :staircase
-    pattern.track "bass.wav",      "X..."
-    pattern.track "snare.wav",     "X.."
-    pattern.track "hh_closed.wav", "X."
+    staircase_tracks = [
+      Track.new("bass.wav",      "X..."),
+      Track.new("snare.wav",     "X.."),
+      Track.new("hh_closed.wav", "X."),
+    ]
+    pattern = Pattern.new(:staircase, staircase_tracks)
     test_patterns[:staircase] = pattern
 
     test_patterns
@@ -40,36 +44,26 @@ class PatternTest < Minitest::Test
     pattern = test_patterns[:staircase]
     assert_equal(pattern.name, :staircase)
     assert_equal(pattern.tracks.length, 3)
-  end
-
-  def test_track
-    pattern = Pattern.new("whatevs")
-
-    assert_equal({}, pattern.tracks)
-
-    pattern.track("my_sound", "X...X...")
-    assert_pattern_tracks(pattern, {"my_sound" => {name: "my_sound", rhythm: "X...X..."}})
-
-    # Rhythm is shorter than length of current longer rhythm, so should be made same length
-    pattern.track("my_other_sound", "X...")
-    assert_pattern_tracks(pattern, {"my_sound"       => {name: "my_sound",       rhythm: "X...X..."},
-                                    "my_other_sound" => {name: "my_other_sound", rhythm: "X......."}})
-
-    # Track has same name as previous track, and longer rhythm than previous tracks.
-    # Track should have expected name, but pattern key be unique.
-    # The rhythm of other existing tracks should be lengthened.
-    pattern.track("my_sound", ".X..........")
-    assert_pattern_tracks(pattern, {"my_sound"       => {name: "my_sound",       rhythm: "X...X......."},
-                                    "my_other_sound" => {name: "my_other_sound", rhythm: "X..........."},
-                                    "my_sound2"      => {name: "my_sound",       rhythm: ".X.........."}})
 
-    pattern.track("my_sound2", "..X.........")
-    assert_pattern_tracks(pattern, {"my_sound"       => {name: "my_sound",       rhythm: "X...X......."},
-                                    "my_other_sound" => {name: "my_other_sound", rhythm: "X..........."},
-                                    "my_sound2"      => {name: "my_sound",       rhythm: ".X.........."},
-                                    "my_sound22"     => {name: "my_sound2",      rhythm: "..X........."}})
+    tracks = [
+      Track.new("track1", "X...X..."),
+      Track.new("track2", "X..."),
+    ]
+    pattern = Pattern.new(:tracks_provided_in_constructor, tracks)
+    assert_equal(pattern.name, :tracks_provided_in_constructor)
+    assert_equal(pattern.tracks.length, 2)
+    assert_pattern_tracks(pattern, {"track1" => {name: "track1", rhythm: "X...X..."},
+                                    "track2" => {name: "track2",  rhythm: "X......."}})
+
+    tracks = [
+      Track.new("my_sound", "X...X..."),
+      Track.new("my_other_sound", "X..."),
+      Track.new("my_sound", ".X.........."),
+      Track.new("my_sound2", "..X........."),
+      Track.new("my_sound", ".."),
+    ]
+    pattern = Pattern.new("whatevs", tracks)
 
-    pattern.track("my_sound", "..")
     assert_pattern_tracks(pattern, {"my_sound"       => {name: "my_sound",       rhythm: "X...X......."},
                                     "my_other_sound" => {name: "my_other_sound", rhythm: "X..........."},
                                     "my_sound2"      => {name: "my_sound",       rhythm: ".X.........."},
@@ -77,22 +71,28 @@ class PatternTest < Minitest::Test
                                     "my_sound3"      => {name: "my_sound",       rhythm: "............"},})
   end
 
-  def test_track_unique_name_already_taken
-    pattern = Pattern.new("whatevs")
-
-    assert_equal({}, pattern.tracks)
+  def test_track_array_is_frozen
+    tracks = [
+      Track.new("my_sound1", "X...X..."),
+      Track.new("my_sound2", "X.X.X.X."),
+      Track.new("my_sound3", "XXXXXXXX"),
+    ]
+    pattern = Pattern.new("whatevs", tracks)
 
-    pattern.track("my_sound2", "X...X...")
-    assert_pattern_tracks(pattern, {"my_sound2" => {name: "my_sound2", rhythm: "X...X..."}})
+    assert_raises(RuntimeError) { pattern.tracks["my_sound4"] = Track.new("my_sound4", "X...X...") }
+  end
 
-    pattern.track("my_sound", "X.X.X.X.")
-    assert_pattern_tracks(pattern, {"my_sound2" => {name: "my_sound2", rhythm: "X...X..."},
-                                    "my_sound"  => {name: "my_sound",  rhythm: "X.X.X.X."}})
+  def test_track_unique_name_already_taken
+    tracks = [
+      Track.new("my_sound2", "X...X..."),
+      Track.new("my_sound",  "X.X.X.X."),
+      Track.new("my_sound",  "XXXXXXXX"),
+    ]
+    pattern = Pattern.new("whatevs", tracks)
 
-    # The first attempt at a unique name would be "my_sound2", but that is already taken
-    pattern.track("my_sound", "XXXXXXXX")
     assert_pattern_tracks(pattern, {"my_sound2" => {name: "my_sound2", rhythm: "X...X..."},
                                     "my_sound"  => {name: "my_sound",  rhythm: "X.X.X.X."},
+                                    # The first attempt at a unique name would be "my_sound2", but that is already taken
                                     "my_sound3" => {name: "my_sound",  rhythm: "XXXXXXXX"}})
   end
 
@@ -105,48 +105,60 @@ class PatternTest < Minitest::Test
   end
 
   def test_same_tracks_as?
-    left_pattern = Pattern.new("left")
-    left_pattern.track("bass",      "X...X...")
-    left_pattern.track("snare",     "..X...X.")
-    left_pattern.track("hh_closed", "X.X.X.X.")
-
-    right_pattern = Pattern.new("right")
-    right_pattern.track("bass",      "X...X...")
-    right_pattern.track("snare",     "..X...X.")
-    right_pattern.track("hh_closed", "X.X.X.X.")
+    left_tracks = [
+      Track.new("bass",      "X...X..."),
+      Track.new("snare",     "..X...X."),
+      Track.new("hh_closed", "X.X.X.X."),
+    ]
+    left_pattern = Pattern.new("left", left_tracks)
+
+    right_tracks = [
+      Track.new("bass",      "X...X..."),
+      Track.new("snare",     "..X...X."),
+      Track.new("hh_closed", "X.X.X.X."),
+    ]
+    right_pattern = Pattern.new("right", right_tracks)
     assert(left_pattern.same_tracks_as?(right_pattern))
     assert(right_pattern.same_tracks_as?(left_pattern))
 
     # Now switch up the order. Left and right should still be equal.
-    right_pattern = Pattern.new("right")
-    right_pattern.track("snare",     "..X...X.")
-    right_pattern.track("hh_closed", "X.X.X.X.")
-    right_pattern.track("bass",      "X...X...")
+    right_tracks = [
+      Track.new("snare",     "..X...X."),
+      Track.new("hh_closed", "X.X.X.X."),
+      Track.new("bass",      "X...X..."),
+    ]
+    right_pattern = Pattern.new("right", right_tracks)
     assert(left_pattern.same_tracks_as?(right_pattern))
     assert(right_pattern.same_tracks_as?(left_pattern))
 
     # Now compare the pattern with same rhythms but different track names. Should not be equal.
-    different_names_pattern = Pattern.new("different_names")
-    different_names_pattern.track("tom",     "X...X...")
-    different_names_pattern.track("cymbal",  "..X...X.")
-    different_names_pattern.track("hh_open", "X.X.X.X.")
+    different_names_tracks = [
+      Track.new("tom",     "X...X..."),
+      Track.new("cymbal",  "..X...X."),
+      Track.new("hh_open", "X.X.X.X."),
+    ]
+    different_names_pattern = Pattern.new("different_names", different_names_tracks)
     assert_equal(false, left_pattern.same_tracks_as?(different_names_pattern))
     assert_equal(false, different_names_pattern.same_tracks_as?(left_pattern))
 
     # Now compare the pattern with same track names but different rhythms. Should not be equal.
-    different_beats_pattern = Pattern.new("different_beats")
-    different_beats_pattern.track("bass",      "X...X...")
-    different_beats_pattern.track("snare",     "..X...X.")
-    different_beats_pattern.track("hh_closed", "X.XXX.X.")
+    different_beats_tracks = [
+      Track.new("bass",      "X...X..."),
+      Track.new("snare",     "..X...X."),
+      Track.new("hh_closed", "X.XXX.X."),
+    ]
+    different_beats_pattern = Pattern.new("different_beats", different_beats_tracks)
     assert_equal(false, left_pattern.same_tracks_as?(different_beats_pattern))
     assert_equal(false, different_beats_pattern.same_tracks_as?(left_pattern))
 
     # Now compare a pattern with the same tracks, but with one extra one as well. Should not be equal.
-    something_extra = Pattern.new("something_extra")
-    something_extra.track("bass",      "X...X...")
-    something_extra.track("snare",     "..X...X.")
-    something_extra.track("hh_closed", "X.X.X.X.")
-    something_extra.track("extra",     "X..X..X.")
+    something_extra_tracks = [
+      Track.new("bass",      "X...X..."),
+      Track.new("snare",     "..X...X."),
+      Track.new("hh_closed", "X.X.X.X."),
+      Track.new("extra",     "X..X..X."),
+    ]
+    something_extra = Pattern.new("something_extra", something_extra_tracks)
     assert_equal(false, left_pattern.same_tracks_as?(something_extra))
     assert_equal(false, something_extra.same_tracks_as?(left_pattern))
   end