beats 1.3.0 → 2.0.0

data/lib/beats/transforms/song_swinger.rb

@@ -1,15 +1,13 @@
 module Beats
   module Transforms
-    class InvalidSwingRateError < RuntimeError; end
-
     class SongSwinger
+      class InvalidSwingRateError < RuntimeError; end
+
       def self.transform(song, swing_rate)
         validate_swing_rate(swing_rate)
 
         song.patterns.values.each do |pattern|
           pattern.tracks.values.each do |track|
-            original_rhythm = track.rhythm
-
             if swing_rate == 8
               track.rhythm = swing_8(track.rhythm)
             elsif swing_rate == 16

data/lib/wavefile/cachingwriter.rb

@@ -11,7 +11,7 @@ module WaveFile
 
     def write(buffer)
       packed_buffer_data = {}
-      
+
       key = buffer.hash
       if @buffer_cache.member?(key)
         packed_buffer_data = @buffer_cache[key]
@@ -29,7 +29,7 @@ module WaveFile
         @buffer_cache[key] = packed_buffer_data
       end
 
-      @file.syswrite(packed_buffer_data[:data])
+      @io.write(packed_buffer_data[:data])
       @total_sample_frames += packed_buffer_data[:sample_count]
     end
   end

data/test/audioengine_test.rb

@@ -15,10 +15,10 @@ end
 
 # Allow setting sample data directly, instead of loading from a file
 class MockKit < Kit
-  attr_accessor :sound_bank, :num_channels
+  attr_accessor :items
 end
 
-class AudioEngineTest < Test::Unit::TestCase
+class AudioEngineTest < Minitest::Test
   FIXTURES = [:repeats_not_specified,
               :pattern_with_overflow,
               :example_no_kit,
@@ -29,7 +29,7 @@ class AudioEngineTest < Test::Unit::TestCase
     base_path = File.dirname(__FILE__) + "/.."
     song_parser = SongParser.new
 
-    test_engines[:blank] = AudioEngine.new(Song.new, Kit.new(base_path, {}))
+    test_engines[:blank] = AudioEngine.new(Song.new, KitBuilder.new(base_path).build_kit)
 
     FIXTURES.each do |fixture_name|
       song, kit = song_parser.parse(base_path, File.read("test/fixtures/valid/#{fixture_name}.txt"))
@@ -56,27 +56,25 @@ class AudioEngineTest < Test::Unit::TestCase
   # TS   A step with no sound, shorter than full sound length
   # Z    A zero sample
 
-  MONO_KIT = MockKit.new(".", {})
-  MONO_KIT.sound_bank = { "S"  => [-100, 200, 300, -400],
-                          "SL" => [-100, 200, 300, -400, 0, 0],
-                          "SS" => [-100, 200],
-                          "SO" => [300, -400],
-                          "TE" => [0, 0, 0, 0],
-                          "TL" => [0, 0, 0, 0, 0, 0],
-                          "TS" => [0, 0],
-                          "Z"  => [0] }
-  MONO_KIT.num_channels = 1
-
-  STEREO_KIT = MockKit.new(".", {})
-  STEREO_KIT.sound_bank = { "S"  => [[-100, 800], [200, -700], [300, -600], [-400, 400]],
-                            "SL" => [[-100, 800], [200, -700], [300, -600], [-400, 400], [0, 0], [0, 0]],
-                            "SS" => [[-100, 800], [200, -700]],
-                            "SO" => [[300, -600], [-400, 400]],
-                            "TE" => [[0, 0], [0, 0], [0, 0], [0, 0]],
-                            "TL" => [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]],
-                            "TS" => [[0, 0], [0, 0]],
-                            "Z"  => [[0, 0]] }
-  STEREO_KIT.num_channels = 2
+  MONO_KIT = MockKit.new({}, 1, 16)
+  MONO_KIT.items = { "S"  => [-100, 200, 300, -400],
+                     "SL" => [-100, 200, 300, -400, 0, 0],
+                     "SS" => [-100, 200],
+                     "SO" => [300, -400],
+                     "TE" => [0, 0, 0, 0],
+                     "TL" => [0, 0, 0, 0, 0, 0],
+                     "TS" => [0, 0],
+                     "Z"  => [0] }
+
+  STEREO_KIT = MockKit.new({}, 2, 16)
+  STEREO_KIT.items = { "S"  => [[-100, 800], [200, -700], [300, -600], [-400, 400]],
+                       "SL" => [[-100, 800], [200, -700], [300, -600], [-400, 400], [0, 0], [0, 0]],
+                       "SS" => [[-100, 800], [200, -700]],
+                       "SO" => [[300, -600], [-400, 400]],
+                       "TE" => [[0, 0], [0, 0], [0, 0], [0, 0]],
+                       "TL" => [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]],
+                       "TS" => [[0, 0], [0, 0]],
+                       "Z"  => [[0, 0]] }
 
 
   # These tests use unrealistically short sounds and step sample lengths, to make tests easier to work with.

data/test/audioutils_test.rb

@@ -1,6 +1,6 @@
 require 'includes'
 
-class AudioUtilsTest < Test::Unit::TestCase
+class AudioUtilsTest < Minitest::Test
   def test_composite
     # Mono empty arrays
     assert_equal([], AudioUtils.composite([], 1))

data/test/cachingwriter_test.rb

@@ -1,20 +1,18 @@
 require 'includes'
 
-# Makes @file writable so it can be replaced with StringIO for testing
-class StringCachingWriter < WaveFile::CachingWriter
-  attr_writer :file
-end
-
 # Basic tests for CachingWriter; the integration tests test it more thoroughly.
-class CachingWriterTest < Test::Unit::TestCase
+class CachingWriterTest < Minitest::Test
   def test_mono
     buffer1_bytes = [0, 0, 1, 0, 2, 0]
     buffer2_bytes = [3, 0, 4, 0, 5, 0]
 
-    format = WaveFile::Format.new(:mono, 16, 44100)
-    writer = StringCachingWriter.new("does_not_matter", format)
+    format = WaveFile::Format.new(:mono, :pcm_16, 44100)
     string_io = StringIO.new
-    writer.file = string_io
+    writer = WaveFile::CachingWriter.new(string_io, format)
+
+    # Remove WaveFile header to make test assertions simpler
+    string_io.truncate(0)
+    string_io.rewind
 
     assert_equal(format, writer.format)
 
@@ -35,10 +33,13 @@ class CachingWriterTest < Test::Unit::TestCase
     buffer1_bytes = [0, 0, 3, 0, 1, 0, 2, 0]
     buffer2_bytes = [9, 0, 6, 0, 8, 0, 7, 0]
 
-    format = WaveFile::Format.new(:stereo, 16, 44100)
-    writer = StringCachingWriter.new("does_not_matter", format)
+    format = WaveFile::Format.new(:stereo, :pcm_16, 44100)
     string_io = StringIO.new
-    writer.file = string_io
+    writer = WaveFile::CachingWriter.new(string_io, format)
+
+    # Remove WaveFile header to make test assertions simpler
+    string_io.truncate(0)
+    string_io.rewind
 
     assert_equal(format, writer.format)
 

data/test/fixtures/invalid/leading_bar_line.txt

@@ -0,0 +1,15 @@
+# Support for tracks that start with a | character are no longer supported
+# as of v2.0.0. The reason is that this is not valid YAML, and only worked
+# due to a bug in Syck. Now that Beats is using Psych, this is invalid.
+
+Song:
+  Tempo: 120
+  Kit:
+    - bass:     test/sounds/bass_mono_8.wav
+    - snare:    test/sounds/snare_mono_8.wav
+  Flow:
+    - Verse:  x1
+
+Verse:
+  - bass:    X...X...
+  - snare:  |..X...X.

data/test/fixtures/{valid → invalid}/with_structure.txt

@@ -1,5 +1,5 @@
 # Header contains a "Structure" section instead of a "Flow" section.
-# This is valid for now, but is deprecated.
+# Support for this section was removed in v2.0.0.
 
 Song:
   Tempo: 100
@@ -7,4 +7,4 @@ Song:
     - Verse: x2
 
 Verse:
-  - test/sounds/bass_mono_8.wav: X...X...
+  - test/sounds/bass_mono_8.wav: X...X...

data/test/fixtures/valid/multiple_tracks_same_sound.txt

@@ -29,5 +29,6 @@ Chorus:
   - bass:                     X...X...XX..X...
   - snare:                    ....X.......X...
   - hh_closed:                X.XXX.XXX.XX..X.
+  - bass:                     ..X..X..X..X..X.
   - test/sounds/tom4_mono_16.wav:  ...........X....
-  - test/sounds/tom2_mono_16.wav:  ..............X.
+  - test/sounds/tom2_mono_16.wav:  ..............X.

data/test/fixtures/valid/optimize_pattern_collision.txt

@@ -6,7 +6,7 @@
 # the other one leading to incorrect song output.
 #
 # In the example below, when sub-dividing patterns with a max size of 4 steps, the new patterns
-# highlighted with !!!! would both be called Verse20, causing a collision. 
+# highlighted with !!!! would both be called Verse20, causing a collision.
 
 
 Song:
@@ -18,11 +18,10 @@ Song:
 Verse:
 #                                 0    4    8    12   16   20
 #                                                          !!!!
-  - test/sounds/bass_mono_8.wav: |X...|X...|X...|X...|X...|X.XX|
+  - test/sounds/bass_mono_8.wav:  X...|X...|X...|X...|X...|X.XX|
 
 
-Verse2:                       
+Verse2:
 #                                 0    4    8    12   16   20
 #                                 !!!!
-  - test/sounds/bass_mono_8.wav: |X..X|X..X|X..X|X..X|X..X|X..X|
-
+  - test/sounds/bass_mono_8.wav:  X..X|X..X|X..X|X..X|X..X|X..X|

data/test/fixtures/valid/track_with_spaces.txt

@@ -0,0 +1,13 @@
+# An example song that has tracks with the space character in them
+
+Song:
+  Tempo: 120
+  Flow:
+    - Verse:   x2
+  Kit:
+    - bass:       test/sounds/bass_stereo_16.wav
+    - snare:      test/sounds/snare_stereo_16.wav
+
+Verse:
+  - bass:       X... X...|X... X...
+  - snare:      .... X...|.... X...

data/test/includes.rb

@@ -1,7 +1,6 @@
 # Standard Ruby libraries
-require 'test/unit'
+require 'minitest/autorun'
 require 'yaml'
-require 'syck'
 require 'rubygems'
 
 # External gems
@@ -11,5 +10,3 @@ require 'wavefile'
 require 'beats'
 require 'wavefile/cachingwriter'
 include Beats
-
-YAML::ENGINE.yamler = 'syck' if defined?(YAML::ENGINE)

data/test/integration_test.rb

@@ -1,6 +1,6 @@
 require 'includes'
 
-class IntegrationTest < Test::Unit::TestCase
+class IntegrationTest < Minitest::Test
   TRACK_NAMES =  ["bass", "snare", "hh_closed", "hh_closed2", "agogo", "tom4", "tom2"]
   OUTPUT_FOLDER = "test/integration_output"
 
@@ -19,7 +19,7 @@ class IntegrationTest < Test::Unit::TestCase
                         "sound_in_track_not_found.txt"]
 
     invalid_fixtures.each do |fixture_name|
-      assert_raise(SongParseError) do
+      assert_raises(SongParser::ParseError) do
         beats = BeatsRunner.new("test/fixtures/invalid/#{fixture_name}", "doesn't matter", {:split => false})
         beats.run
       end
@@ -57,7 +57,7 @@ class IntegrationTest < Test::Unit::TestCase
 
     beats = BeatsRunner.new(song_fixture, actual_output_file, options)
     beats.run
-    assert(File.exists?(actual_output_file), "Expected file '#{actual_output_file}' to exist, but it doesn't.")
+    assert(File.exist?(actual_output_file), "Expected file '#{actual_output_file}' to exist, but it doesn't.")
 
     # Reading the files this way instead of a plain File.read() for Windows compatibility with binary files
     expected_output_file_contents = File.open(expected_output_file, "rb") {|f| f.read() }
@@ -96,7 +96,7 @@ class IntegrationTest < Test::Unit::TestCase
       end
       actual_output_file = "#{actual_output_prefix}-#{track_name}.wav"
       expected_output_file = "#{expected_output_prefix}-#{track_name}.wav"
-      assert(File.exists?(actual_output_file), "Expected file '#{actual_output_file}' to exist, but it doesn't.")
+      assert(File.exist?(actual_output_file), "Expected file '#{actual_output_file}' to exist, but it doesn't.")
 
       # Reading the files this way instead of a plain File.read() for Windows compatibility with binary files
       expected_output_file_contents = File.open(expected_output_file, "rb") {|f| f.read }
@@ -114,7 +114,7 @@ class IntegrationTest < Test::Unit::TestCase
 
   def clean_output_folder()
     # Make the folder if it doesn't already exist
-    Dir.mkdir(OUTPUT_FOLDER) unless File.exists?(OUTPUT_FOLDER)
+    Dir.mkdir(OUTPUT_FOLDER) unless File.exist?(OUTPUT_FOLDER)
 
     dir = Dir.new(OUTPUT_FOLDER)
     file_names = dir.entries

data/test/kit_builder_test.rb

@@ -0,0 +1,52 @@
+require 'includes'
+
+class KitBuilderTest < Minitest::Test
+  def test_has_label?
+    kit_builder = KitBuilder.new("test/sounds")
+
+    assert_equal(false, kit_builder.has_label?("label1"))
+    assert_equal(false, kit_builder.has_label?("label2"))
+
+    kit_builder.add_item("label1", "bass_mono_8.wav")
+    assert_equal(true,  kit_builder.has_label?("label1"))
+    assert_equal(false, kit_builder.has_label?("label2"))
+  end
+
+  def test_build_kit_happy_path
+    kit_builder = KitBuilder.new("test/sounds")
+
+    kit_builder.add_item("mono8", "bass_stereo_8.wav")
+    kit_builder.add_item("bass_mono_16.wav", "bass_mono_16.wav")
+
+    kit = kit_builder.build_kit
+
+    assert_equal(Kit, kit.class)
+    assert_equal(2, kit.num_channels)
+    assert_equal(16, kit.bits_per_sample)
+    assert_equal(Array, kit.get_sample_data('mono8').class)
+    assert_equal(Array, kit.get_sample_data('bass_mono_16.wav').class)
+  end
+
+  def test_build_kit_no_sounds
+    kit_builder = KitBuilder.new("test/sounds")
+
+    kit = kit_builder.build_kit
+    assert_equal(Kit, kit.class)
+    assert_equal(1, kit.num_channels)
+    assert_equal(16, kit.bits_per_sample)
+  end
+
+  def test_build_kit_with_non_existent_sound_file
+    kit_builder = KitBuilder.new("test/sounds")
+    kit_builder.add_item("fake", "i_do_not_exist.wav")
+
+    assert_raises(KitBuilder::SoundFileNotFoundError) { kit_builder.build_kit }
+  end
+
+  def test_build_kit_with_invalid_sound_file
+    kit_builder = KitBuilder.new("test/sounds")
+    kit_builder.add_item("ruby_file", "../kit_builder_test.rb")
+
+    assert_raises(KitBuilder::InvalidSoundFormatError) { kit_builder.build_kit }
+  end
+end

data/test/kit_test.rb

@@ -1,151 +1,28 @@
 require 'includes'
 
-# Kit which allows directly changing the sound bank after initialization, to allows tests
-# to use fixture data directly in the test instead of loading it from the file system.
-class MutableKit < Kit
-  attr_accessor :sound_bank
-end
-
-class KitTest < Test::Unit::TestCase
-  MIN_SAMPLE_8BIT = 0
-  MAX_SAMPLE_8BIT = 255
-
-  def generate_test_data
-    kits = {}
-
-    # Kit with no sounds
-    kits[:empty] = Kit.new("test/sounds", {})
-
-    # Kits which only has simple sounds
-    kits[:mono8]    = Kit.new("test/sounds", {"mono8" => "bass_mono_8.wav"})
-    kits[:mono16]   = Kit.new("test/sounds", {"mono8"  => "bass_mono_8.wav",
-                                              "mono16" => "bass_mono_16.wav"})
-    kits[:stereo8]  = Kit.new("test/sounds", {"mono8"   => "bass_mono_8.wav",
-                                              "stereo8" => "bass_stereo_8.wav"})
-    kits[:stereo16] = Kit.new("test/sounds", {"mono8"    => "bass_mono_8.wav",
-                                              "mono16"   => "bass_mono_16.wav",
-                                              "stereo16" => "bass_stereo_16.wav"})
-
-    # Kits which contain a composite sound
-    #kits[:basic_composite] = Kit.new("test/sounds", {"mono8"  => "bass_mono_8.wav",
-    #                                                 "composite_mono8" => ["snare_mono_8.wav", "tom3_mono_8.wav"]})
-    #kits[:mismatched_bps_composite] = Kit.new("test/sounds", {"mono8"  => "bass_mono_8.wav",
-    #                                                          "composite_mono16" => ["snare_mono_8.wav", "tom3_mono_16.wav"]})
-    #kits[:mismatched_channels_composite] = Kit.new("test/sounds", {"mono8"  => "bass_mono_8.wav",
-    #                                                               "composite_stereo16" => ["snare_stereo_16.wav", "tom3_mono_16.wav"]})
-    #kits[:mismatched_everything_composite] = Kit.new("test/sounds", {"mono8"  => "bass_mono_8.wav",
-    #                                                                 "composite_stereo16" => ["snare_stereo_8.wav", "tom3_mono_16.wav"]})
-
-    kits
+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([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') }
+    assert_equal([7,8,9], kit.get_sample_data('label3'))
   end
 
-  def test_valid_initialization
-    kits = generate_test_data
-
-    assert_equal(16, kits[:empty].bits_per_sample)
-    assert_equal(1, kits[:empty].num_channels)
-
-    assert_equal(16, kits[:mono8].bits_per_sample)
-    assert_equal(1, kits[:mono8].num_channels)
-
-    assert_equal(16, kits[:mono16].bits_per_sample)
-    assert_equal(1, kits[:mono16].num_channels)
-
-    assert_equal(16, kits[:stereo8].bits_per_sample)
-    assert_equal(2, kits[:stereo8].num_channels)
-
-    assert_equal(16, kits[:stereo16].bits_per_sample)
-    assert_equal(2, kits[:stereo16].num_channels)
-
-    #assert_equal(16, kits[:basic_composite].bits_per_sample)
-    #assert_equal(1, kits[:basic_composite].num_channels)
-
-    #assert_equal(16, kits[:mismatched_bps_composite].bits_per_sample)
-    #assert_equal(1, kits[:mismatched_bps_composite].num_channels)
-
-    #assert_equal(16, kits[:mismatched_channels_composite].bits_per_sample)
-    #assert_equal(2, kits[:mismatched_channels_composite].num_channels)
-
-    #assert_equal(16, kits[:mismatched_everything_composite].bits_per_sample)
-    #assert_equal(2, kits[:mismatched_everything_composite].num_channels)
+  def test_kit_with_no_items
+    kit = Kit.new({}, 1, 16)
+    assert_raises(Kit::LabelNotFoundError) { kit.get_sample_data('foo') }
   end
 
-  def test_invalid_initialization
-    # Tests for adding non-existant sound file to Kit
-    assert_raise(SoundFileNotFoundError) { Kit.new("test/sounds", {"i_do_not_exist" => "i_do_not_exist.wav"}) }
-
-    assert_raise(SoundFileNotFoundError) { Kit.new("test/sounds", {"mono16" => "bass_mono_16.wav",
-                                                                   "i_do_not_exist" => "i_do_not_exist.wav"}) }
-
-    #assert_raise(SoundFileNotFoundError) { Kit.new("test/sounds", {"mono16" => "bass_mono_16.wav",
-    #                                                               "composite" => ["bass_mono_16.wav", "snare_mono_16.wav"],
-    #                                                               "i_do_not_exist" => "i_do_not_exist.wav"}) }
-
-    # Tests for adding invalid sound files to Kit
-    assert_raise(InvalidSoundFormatError) { Kit.new("test", {"bad" => "kit_test.rb"}) }
-
-    assert_raise(InvalidSoundFormatError) { Kit.new("test", {"mono16" => "sounds/bass_mono_16.wav",
-                                                             "bad" => "kit_test.rb"}) }
-
-    #assert_raise(InvalidSoundFormatError) { Kit.new("test", {"mono16" => "sounds/bass_mono_16.wav",
-    #                                                         "composite" => ["sounds/bass_mono_16.wav", "sounds/snare_mono_16.wav"],
-    #                                                         "bad" => "kit_test.rb"}) }
-  end
-
-  def test_get_sample_data
-    kits = generate_test_data
-    # Should get an error when trying to get a non-existent sound
-    assert_raise(StandardError) { kits[:mono8].get_sample_data("nonexistant") }
-
-    [:mono8, :mono16].each do |kit_name|
-      sample_data = kits[kit_name].get_sample_data("mono8")
-      # Assert sample data is 16-bit. If max and min samples are outside 0-255 bounds, then it is.
-      assert(sample_data.max > MAX_SAMPLE_8BIT)
-      assert(sample_data.min < MIN_SAMPLE_8BIT)
-      # Assert it has 1 channel. This is true if every item is a Fixnum.
-      assert_equal([], sample_data.select {|sample| sample.class != Fixnum})
-    end
-
-    [:stereo8, :stereo16].each do |kit_name|
-      sample_data = kits[kit_name].get_sample_data("mono8")
-      # Assert sample data is 16-bit. If max and min samples are outside 0-255 bounds, then it is.
-      assert(sample_data.flatten.max > MAX_SAMPLE_8BIT)
-      assert(sample_data.flatten.min < MIN_SAMPLE_8BIT)
-      # Assert it has 2 channels. This is true if every item is an Array.
-      assert_equal([], sample_data.select {|sample| sample.class != Array})
-    end
-
-    #actual_sample_data = kits[:basic_composite].get_sample_data("composite_mono8")
-    #expected_sample_data = WaveFile.open("test/sounds/composite_snare_mono_8_tom3_mono_8_mono_16.wav").sample_data
-    #assert_equal(expected_sample_data, actual_sample_data)
-
-    #actual_sample_data = kits[:mismatched_bps_composite].get_sample_data("composite_mono16")
-    #expected_sample_data = WaveFile.open("test/sounds/composite_snare_mono_8_tom3_mono_16_mono_16.wav").sample_data
-    #assert_equal(expected_sample_data, actual_sample_data)
-
-    #actual_sample_data = kits[:mismatched_channels_composite].get_sample_data("composite_stereo16")
-    #expected_sample_data = WaveFile.open("test/sounds/composite_snare_stereo_16_tom3_mono_16_stereo_16.wav").sample_data
-    #assert_equal(expected_sample_data, actual_sample_data)
-
-    #actual_sample_data = kits[:mismatched_everything_composite].get_sample_data("composite_stereo16")
-    #expected_sample_data = WaveFile.open("test/sounds/composite_snare_stereo_8_tom3_mono_16_stereo_16.wav").sample_data
-    #assert_equal(expected_sample_data[0..10], actual_sample_data[0..10])
+  def test_num_channels
+    kit = Kit.new({}, 2, 16)
+    assert_equal(2, kit.num_channels)
   end
 
-  def test_scale!
-    sound_bank = {"a" => [-10, 0, 20], "b" => [], "c" => [12346, 9999]}
-
-    kit = MutableKit.new(".", {})
-    kit.sound_bank = sound_bank
-
-    kit.scale!(5)
-    assert_equal([-2, 0, 4], kit.get_sample_data("a"))
-    assert_equal([], kit.get_sample_data("b"))
-    assert_equal([2469, 1999], kit.get_sample_data("c"))
-
-    kit.scale!(2)
-    assert_equal([-1, 0, 2], kit.get_sample_data("a"))
-    assert_equal([], kit.get_sample_data("b"))
-    assert_equal([1234, 999], kit.get_sample_data("c"))
+  def test_bits_per_sample
+    kit = Kit.new({}, 2, 16)
+    assert_equal(16, kit.bits_per_sample)
   end
 end
+