beats 1.2.4 → 1.2.5

data/test/cachingwriter_test.rb

@@ -21,7 +21,7 @@ class CachingWriterTest < Test::Unit::TestCase
     buffer = WaveFile::Buffer.new([0, 1, 2], format)
     writer.write(buffer)
     assert_equal(buffer1_bytes, get_bytes(string_io))
-    
+
     buffer = WaveFile::Buffer.new([3, 4, 5], format)
     writer.write(buffer)
     assert_equal(buffer1_bytes + buffer2_bytes, get_bytes(string_io))

data/test/fixtures/valid/foo.txt

@@ -0,0 +1,18 @@
+Song:
+  Tempo: 120
+  Flow:
+    - Verse:   x1
+    - Chorus:  x2
+  Kit:
+    - bass:    test/sounds/agogo_high_stereo_16.wav
+    - bass2:   test/sounds/snare_stereo_16.wav
+
+Verse:
+  - bass:   X...X...X...X...
+  - bass:   ..X...X...X...X.
+  - bass2:  X.X.X.X.X.X.X.X.
+
+
+Chorus:
+  - bass:   X...X...
+  - bass2:  X.X.X.X.

data/test/includes.rb

@@ -1,22 +1,15 @@
 # Standard Ruby libraries
 require 'test/unit'
 require 'yaml'
+require 'syck'
 require 'rubygems'
 
 # External gems
-gem 'wavefile', "=0.4.0"
 require 'wavefile'
 
 # BEATS classes
-require 'audioengine'
-require 'audioutils'
 require 'beats'
 require 'wavefile/cachingwriter'
-require 'kit'
-require 'pattern'
-require 'song'
-require 'songparser'
-require 'songoptimizer'
-require 'track'
+include Beats
 
 YAML::ENGINE.yamler = 'syck' if defined?(YAML::ENGINE)

data/test/integration_test.rb

@@ -3,7 +3,7 @@ require 'includes'
 class IntegrationTest < Test::Unit::TestCase
   TRACK_NAMES =  ["bass", "snare", "hh_closed", "hh_closed2", "agogo", "tom4", "tom2"]
   OUTPUT_FOLDER = "test/integration_output"
-  
+
   def setup
     # Make sure no output from previous tests is still around
     clean_output_folder()
@@ -17,19 +17,19 @@ class IntegrationTest < Test::Unit::TestCase
                         "no_flow.txt",
                         "sound_in_kit_not_found.txt",
                         "sound_in_track_not_found.txt"]
-        
+
     invalid_fixtures.each do |fixture_name|
       assert_raise(SongParseError) do
-        beats = Beats.new("test/fixtures/invalid/#{fixture_name}", "doesn't matter", {:split => false})
+        beats = BeatsRunner.new("test/fixtures/invalid/#{fixture_name}", "doesn't matter", {:split => false})
         beats.run()
       end
     end
   end
-  
-  
+
+
   # TODO: Add tests for the -p option
   # TODO: Add test verify that song generated with and without SongOptimizer are identical.
-  
+
   def test_base_path
     run_combined_test("mono", 16, "_base_path", "test/sounds")
     run_split_test("mono", 16, "_base_path", "test/sounds")
@@ -41,21 +41,21 @@ class IntegrationTest < Test::Unit::TestCase
     run_combined_test("stereo", 8)
     run_combined_test("stereo", 16)
   end
-  
+
   def run_combined_test(num_channels, bits_per_sample, suffix="", base_path=nil)
     # Make sure no output from previous tests is still around
     assert_directory_is_empty OUTPUT_FOLDER
-    
+
     song_fixture         = "test/fixtures/valid/example_#{num_channels}_#{bits_per_sample}#{suffix}.txt"
     actual_output_file   = "#{OUTPUT_FOLDER}/example_combined_#{num_channels}_#{bits_per_sample}#{suffix}.wav"
     expected_output_file = "test/fixtures/expected_output/example_combined_#{num_channels}_#{bits_per_sample}.wav"
-    
+
     options = {:split => false}
     unless base_path == nil
       options[:base_path] = base_path
     end
 
-    beats = Beats.new(song_fixture, actual_output_file, options)
+    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.")
 
@@ -63,32 +63,32 @@ class IntegrationTest < Test::Unit::TestCase
     expected_output_file_contents = File.open(expected_output_file, "rb") {|f| f.read() }
     actual_output_file_contents = File.open(actual_output_file, "rb") {|f| f.read() }
     assert_equal(expected_output_file_contents, actual_output_file_contents)
-    
+
     # Clean up after ourselves
     File.delete(actual_output_file)
   end
-  
+
   def test_generate_split
     run_split_test("mono",    8)
     run_split_test("mono",   16)
     run_split_test("stereo",  8)
     run_split_test("stereo", 16)
   end
-  
+
   def run_split_test(num_channels, bits_per_sample, suffix="", base_path=nil)
     # Make sure no output from previous tests is still around
     assert_directory_is_empty OUTPUT_FOLDER
-    
+
     song_fixture         = "test/fixtures/valid/example_#{num_channels}_#{bits_per_sample}#{suffix}.txt"
     actual_output_prefix   = "#{OUTPUT_FOLDER}/example_split_#{num_channels}_#{bits_per_sample}#{suffix}"
     expected_output_prefix = "test/fixtures/expected_output/example_split_#{num_channels}_#{bits_per_sample}"
-    
+
     options = {:split => true}
     unless base_path == nil
       options[:base_path] = base_path
     end
 
-    beats = Beats.new(song_fixture, actual_output_prefix + ".wav", options)
+    beats = BeatsRunner.new(song_fixture, actual_output_prefix + ".wav", options)
     beats.run()
     TRACK_NAMES.each do |track_name|
       if(track_name.start_with?("tom"))
@@ -97,12 +97,12 @@ class IntegrationTest < Test::Unit::TestCase
       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.")
-      
+
       # 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() }
       actual_output_file_contents = File.open(actual_output_file, "rb") {|f| f.read() }
       assert_equal(expected_output_file_contents, actual_output_file_contents)
-            
+
       # Clean up after ourselves
       File.delete(actual_output_file)
     end
@@ -111,11 +111,11 @@ class IntegrationTest < Test::Unit::TestCase
   def assert_directory_is_empty dir
     assert_equal([".", ".."].sort, Dir.new(dir).entries.sort)
   end
-  
+
   def clean_output_folder()
     # Make the folder if it doesn't already exist
     Dir.mkdir(OUTPUT_FOLDER) unless File.exists?(OUTPUT_FOLDER)
-    
+
     dir = Dir.new(OUTPUT_FOLDER)
     file_names = dir.entries
     file_names.each do |file_name|

data/test/kit_test.rb

@@ -9,10 +9,10 @@ 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", {})
 
@@ -25,7 +25,7 @@ class KitTest < Test::Unit::TestCase
     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"]})
@@ -35,68 +35,68 @@ class KitTest < Test::Unit::TestCase
     #                                                               "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"]})
-  
-    return kits
+
+    kits
   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)
   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.
@@ -105,7 +105,7 @@ class KitTest < Test::Unit::TestCase
       # 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.
@@ -114,19 +114,19 @@ class KitTest < Test::Unit::TestCase
       # 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])

data/test/pattern_test.rb

@@ -6,29 +6,29 @@ class PatternTest < Test::Unit::TestCase
 
   def generate_test_data
     test_patterns = {}
-    
+
     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"
     test_patterns[:verse] = pattern
-    
+
     pattern = Pattern.new :staircase
     pattern.track "bass.wav",      "X..."
     pattern.track "snare.wav",     "X.."
     pattern.track "hh_closed.wav", "X."
     test_patterns[:staircase] = pattern
-    
-    return test_patterns
+
+    test_patterns
   end
-  
+
   def test_initialize
     test_patterns = generate_test_data()
-    
+
     pattern = test_patterns[:blank]
     assert_equal(pattern.name, :blank)
     assert_equal(pattern.tracks.length, 0)
@@ -44,7 +44,7 @@ class PatternTest < Test::Unit::TestCase
 
   def test_step_count
     test_patterns = generate_test_data()
-    
+
     assert_equal(0,  test_patterns[:blank].step_count())
     assert_equal(32, test_patterns[:verse].step_count())
     assert_equal(4,  test_patterns[:staircase].step_count())
@@ -55,14 +55,14 @@ class PatternTest < Test::Unit::TestCase
     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.")
     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.")
@@ -70,7 +70,7 @@ class PatternTest < Test::Unit::TestCase
     right_pattern.track("bass",      "X...X...")
     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...")
@@ -78,7 +78,7 @@ class PatternTest < Test::Unit::TestCase
     different_names_pattern.track("hh_open", "X.X.X.X.")
     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...")
@@ -86,7 +86,7 @@ class PatternTest < Test::Unit::TestCase
     different_beats_pattern.track("hh_closed", "X.XXX.X.")
     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...")

data/test/song_test.rb

@@ -11,13 +11,13 @@ class SongTest < Test::Unit::TestCase
     base_path = File.dirname(__FILE__) + "/.."
 
     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."
-    
+
     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"))
@@ -33,18 +33,18 @@ class SongTest < Test::Unit::TestCase
     chorus.track "snare.wav", "....X..X"
     chorus.track "ride.wav",  "X.....X."
     test_songs[:from_code].flow = [:verse, :chorus, :verse, :chorus, :chorus]
-    
-    return test_songs
+
+    test_songs
   end
-    
+
   def test_initialize
     test_songs = generate_test_data()
-    
+
     assert_equal([], test_songs[:blank].flow)
     assert_equal([], test_songs[:no_flow].flow)
     assert_equal([:verse, :chorus, :verse, :chorus, :chorus], test_songs[:from_code].flow)
   end
-  
+
   def test_pattern
     song = Song.new()
     verse1 = song.pattern :Verse
@@ -61,10 +61,10 @@ class SongTest < Test::Unit::TestCase
     assert_equal(2, song.patterns.length)
     assert_equal({:Chorus => chorus, :Verse => verse2}, song.patterns)
   end
-  
+
   def test_total_tracks
     test_songs = generate_test_data()
-    
+
     assert_equal(0, test_songs[:blank].total_tracks)
     assert_equal(3, test_songs[:no_flow].total_tracks)
     assert_equal(3, test_songs[:from_code].total_tracks)
@@ -73,10 +73,10 @@ class SongTest < Test::Unit::TestCase
     assert_equal(5, test_songs[:example_no_kit].total_tracks)
     assert_equal(5, test_songs[:example_with_kit].total_tracks)
   end
-  
+
   def test_track_names
     test_songs = generate_test_data()
-    
+
     assert_equal([], test_songs[:blank].track_names)
     assert_equal(["bass.wav", "hh_closed.wav", "snare.wav"], test_songs[:no_flow].track_names)
     assert_equal(["bass.wav", "hh_closed.wav", "ride.wav", "snare.wav"], test_songs[:from_code].track_names)
@@ -96,25 +96,25 @@ class SongTest < Test::Unit::TestCase
                   "test/sounds/ride_mono_8.wav"],
                   test_songs[:example_with_kit].track_names)
   end
-  
+
   def test_copy_ignoring_patterns_and_flow
     test_songs = generate_test_data()
     original_song = test_songs[:example_no_kit]
     cloned_song = original_song.copy_ignoring_patterns_and_flow()
-    
+
     assert_not_equal(cloned_song, original_song)
     assert_equal(cloned_song.tempo, original_song.tempo)
     assert_equal([], cloned_song.flow)
     assert_equal({}, cloned_song.patterns)
   end
-  
+
   def test_split
     test_songs = generate_test_data()
     split_songs = test_songs[:example_with_kit].split()
-    
+
     assert_equal(Hash, split_songs.class)
     assert_equal(6, split_songs.length)
-    
+
     song_names = split_songs.keys.sort
     assert_equal(["bass",
                   "hhclosed",
@@ -123,7 +123,7 @@ class SongTest < Test::Unit::TestCase
                   "test/sounds/hh_closed_mono_8.wav",
                   "test/sounds/ride_mono_8.wav"],
                  song_names)
-                 
+
     song_names.each do |song_name|
       song = split_songs[song_name]
       assert_equal(99, song.tempo)
@@ -131,7 +131,7 @@ class SongTest < Test::Unit::TestCase
       assert_equal([:verse, :verse, :chorus, :chorus, :verse, :verse, :chorus, :chorus, :chorus, :chorus,
                     :bridge, :chorus, :chorus, :chorus, :chorus],
                    song.flow)
-                   
+
       song.patterns.each do |pattern_name, pattern|
         assert_equal(1, pattern.tracks.length)
         assert_equal([song_name], pattern.tracks.keys)
@@ -139,20 +139,20 @@ class SongTest < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_remove_unused_patterns
     test_songs = generate_test_data()
-    
+
     assert_equal(1, test_songs[:no_flow].patterns.length)
     test_songs[:no_flow].remove_unused_patterns()
     assert_equal({}, test_songs[:no_flow].patterns)
-    
+
     assert_equal(3, test_songs[:example_no_kit].patterns.length)
     test_songs[:example_no_kit].remove_unused_patterns()
     assert_equal(3, test_songs[:example_no_kit].patterns.length)
     assert_equal(Hash, test_songs[:example_no_kit].patterns.class)
   end
-  
+
   def test_to_yaml
     test_songs = generate_test_data()
     kit = Kit.new("test/sounds", {"bass"     => "bass_mono_8.wav",
@@ -161,7 +161,7 @@ class SongTest < Test::Unit::TestCase
                                   "hhopen"   => "hh_open_mono_8.wav"})
 
     result = test_songs[:example_with_kit].to_yaml(kit)
-    
+
     assert_equal(File.read("test/fixtures/yaml/song_yaml.txt"), result)
   end
 end