beats 1.2.1 → 1.2.2

data/README.markdown

@@ -5,7 +5,7 @@ BEATS is a command-line drum machine written in pure Ruby. Feed it a song notate
 
     Song:
       Tempo: 120
-      Structure:
+      Flow:
         - Verse:   x2
         - Chorus:  x4
         - Verse:   x2
@@ -35,24 +35,24 @@ And [here's what it sounds like](http://beatsdrummachine.com/beat.mp3) after get
 Current Status
 --------------
 
-The latest stable version of BEATS is 1.2.1, released on March 6, 2011. This is a minor release which includes the following improvments:
+The latest stable version of BEATS is 1.2.2, released on June 12, 2011. This is a minor release which includes two bug fixes:
 
-* You can use the | character to represent bar lines in a track rhythm. This is optional, but often makes longer rhythms easier to read.
-* The "Structure" section of the song header is now called "Flow". (You can still use "Structure" for now, but you'll get a warning).
-* A pattern can contain multiple tracks that use the same sound. Previously, BEATS would pick one of those tracks as the 'winner', and the other tracks wouldn't be played.
-* Bug fix: A better error message is displayed if a sound file is in an unsupported format (such as MP3), or is not even a sound file.
+* Bug fix: Compatibility issues with Windows
+* Bug fix: Return the correct status code when BEATS terminates, to improve scriptability.
 
 
 Installation
 ------------
 
-To install the latest stable version (1.2.1) from [rubygems.org](http://rubygems.org/gems/beats), run the following from the command line:
+To install the latest stable version (1.2.2) from [rubygems.org](http://rubygems.org/gems/beats), run the following from the command line:
 
-    sudo gem install beats
+    gem install beats
 
-You can then run BEATS from the command-line using the `beats` command.
+Note that if you are installing using the default version of Ruby that comes with MacOS X, you might get a file permission error. If that happens, use `sudo gem install beats` instead. If you are using RVM, plain `gem install beats` should work fine.
 
-BEATS is not very useful unless you have some sounds to use with it. You can download some example sounds from [http://beatsdrummachine.com](http://beatsdrummachine.com).
+Once installed, you can then run BEATS from the command-line using the `beats` command.
+
+BEATS is not very useful unless you have some sounds to use with it. You can download some example sounds from [http://beatsdrummachine.com](http://beatsdrummachine.com/download#drum-kits).
 
 
 Usage
@@ -66,7 +66,7 @@ The BEATS wiki also has a [Getting Started](https://github.com/jstrait/beats/wik
 Found a Bug? Have a Suggestion? Want to Contribute?
 ---------------------------------------------------
 
-Contact me (Joel Strait) by sending a GitHub message.
+Contact me (Joel Strait) by sending a GitHub message or opening a GitHub issue.
 
 
 License

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rake/testtask'
+ 
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end

data/bin/beats

@@ -5,23 +5,26 @@ start_time = Time.now
 $:.unshift File.dirname(__FILE__) + "/.."
 require "optparse"
 require "yaml"
-require "lib/wavefile"
-require "lib/beatswavefile"
+require "wavefile"
 require "lib/audioengine"
 require "lib/audioutils"
 require "lib/beats"
+require "lib/beatswavefile"
 require "lib/kit"
 require "lib/pattern"
-require "lib/patternexpander"
 require "lib/song"
 require "lib/songoptimizer"
 require "lib/songparser"
 require "lib/track"
 
-def parse_options
+USAGE_INSTRUCTIONS = ""
+
+def parse_options()
   options = {:split => false, :pattern => nil}
 
   optparse = OptionParser.new do |opts|
+    opts.banner = "usage: beats [options] input_file [output_file]"
+
     opts.on('-s', '--split', "Save each track to an individual wave file") do
       options[:split] = true
     end
@@ -40,33 +43,43 @@ def parse_options
       exit
     end
   end
-  optparse.parse!
+
+  USAGE_INSTRUCTIONS << optparse.to_s
+  optparse.parse!()
 
   return options
 end
 
-options = parse_options
-input_file_name = ARGV[0]
-output_file_name = ARGV[1]
-
-beats = Beats.new(input_file_name, output_file_name, options)
+def print_error(error, input_file_name)
+  case error
+  when OptionParser::InvalidOption
+    puts "beats: illegal option #{error.args.join(' ')}"
+    puts USAGE_INSTRUCTIONS
+  when Errno::ENOENT
+    puts "Song file '#{input_file_name}' not found.\n"
+  when SongParseError
+    puts "Song file '#{input_file_name}' has an error:\n"
+    puts "  #{error}\n"
+  when StandardError
+    puts "An error occured while generating sound for '#{input_file_name}':\n"
+    puts "  #{error}\n"
+  else
+    puts "An unexpected error occured while running BEATS:"
+    puts "  #{error}\n"
+  end
+end
 
 begin
+  options = parse_options()
+  input_file_name = ARGV[0]
+  output_file_name = ARGV[1]
+
+  beats = Beats.new(input_file_name, output_file_name, options)
+
   output = beats.run()
   duration = output[:duration]
   puts "#{duration[:minutes]}:#{duration[:seconds].to_s.rjust(2, '0')} of audio written in #{Time.now - start_time} seconds."
-rescue Errno::ENOENT => detail
-  puts "\n"
-  puts "Song file '#{input_file_name}' not found.\n"
-  puts "\n"
-rescue SongParseError => detail
-  puts "\n"
-  puts "Song file '#{input_file_name}' has an error:\n"
-  puts "  #{detail}\n"
-  puts "\n"
-rescue StandardError => detail
-  puts "\n"
-  puts "An error occured while generating sound for '#{input_file_name}':\n"
-  puts "  #{detail}\n"
-  puts "\n"
+rescue => error
+  print_error(error, input_file_name)
+  exit(false)
 end

data/lib/audioengine.rb

@@ -1,6 +1,14 @@
-# This class actually generates the output sound data for the performance.
-# Applies a Kit to a Song (which contains sub Patterns and Tracks) to
-# produce output sample data.
+# This class actually generates the output audio data that is saved to disk.
+#
+# To produce audio data, it needs two things: a Song and a Kit. The Song tells
+# it which sounds to trigger and when, while the Kit provides the sample data
+# for each of these sounds.
+#
+# Example usage, assuming song and kit are already defined:
+#
+#   engine = AudioEngine.new(song, kit)
+#   engine.write_to_file("my_song.wav")
+#
 class AudioEngine
   SAMPLE_RATE = 44100
   PACK_CODE = "s*"   # All output sample data is assumed to be 16-bit

data/lib/beats.rb

@@ -1,6 +1,6 @@
 class Beats
-  BEATS_VERSION = "1.2.1"
-  
+  BEATS_VERSION = "1.2.2"
+ 
   # Each pattern in the song will be split up into sub patterns that have at most this many steps.
   # In general, audio for several shorter patterns can be generated more quickly than for one long
   # pattern, and can also be cached more effectively.
@@ -8,49 +8,69 @@ class Beats
 
   def initialize(input_file_name, output_file_name, options)
     @input_file_name =  input_file_name
+
+    if output_file_name == nil
+      output_file_name = File.basename(input_file_name, File.extname(input_file_name)) + ".wav"
+    end
     @output_file_name = output_file_name
+    
     @options = options
   end
 
   def run
-    if @input_file_name == nil
-      ARGV[0] = '-h'
-      parse_options()
-    end
+    song, kit = SongParser.new().parse(File.dirname(@input_file_name), File.read(@input_file_name))
 
-    if @output_file_name == nil
-      @output_file_name = File.basename(@input_file_name, File.extname(@input_file_name)) + ".wav"
-    end
+    song = normalize_for_pattern_option(song)
+    songs_to_generate = normalize_for_split_option(song)
 
-    song_parser = SongParser.new()
-    song, kit = song_parser.parse(File.dirname(@input_file_name), File.read(@input_file_name))
+    duration = nil
     song_optimizer = SongOptimizer.new()
+    songs_to_generate.each do |output_file_name, song|
+      song = song_optimizer.optimize(song, OPTIMIZED_PATTERN_LENGTH)
+      duration = AudioEngine.new(song, kit).write_to_file(output_file_name)
+    end
+
+    return {:duration => duration}
+  end
+
+private
 
-    # If the -p option is used, transform the song into one whose flow consists of
-    # playing that single pattern once.
+  # If the -p option is used, transform the song into one whose flow consists of
+  # playing that single pattern once.
+  def normalize_for_pattern_option(song)
     unless @options[:pattern] == nil
       pattern_name = @options[:pattern].downcase.to_sym
-      song.remove_patterns_except(pattern_name)
+
+      unless song.patterns.has_key?(pattern_name)
+        raise StandardError, "The song does not include a pattern called #{pattern_name}"
+      end
+
+      song.flow = [pattern_name]
+      song.remove_unused_patterns()
     end
 
-    duration = nil
+    return song
+  end
+
+  # Returns a hash of file name => song object for each song that should go through the audio engine
+  def normalize_for_split_option(song)
+    songs_to_generate = {}
+
     if @options[:split]
       split_songs = song.split()
       split_songs.each do |track_name, split_song|
-        split_song = song_optimizer.optimize(split_song, OPTIMIZED_PATTERN_LENGTH)
-
         # TODO: Move building the output file name into its own method?
         extension = File.extname(@output_file_name)
         file_name = File.dirname(@output_file_name) + "/" +
                     File.basename(@output_file_name, extension) + "-" + File.basename(track_name, extension) +
                     extension
-        duration = AudioEngine.new(split_song, kit).write_to_file(file_name)
+
+        songs_to_generate[file_name] = split_song
       end
     else
-      song = song_optimizer.optimize(song, OPTIMIZED_PATTERN_LENGTH)
-      duration = AudioEngine.new(song, kit).write_to_file(@output_file_name)
+      songs_to_generate[@output_file_name] = song
     end
 
-    return {:duration => duration}
+    return songs_to_generate
   end
 end

data/lib/beatswavefile.rb

@@ -16,7 +16,7 @@ class BeatsWaveFile < WaveFile
   # this number of samples) must be subsequently be written to the file before it is closed
   # or it won't be valid and you won't be able to play it.
   def open_for_appending(path)
-    file = File.open(path, "w")
+    file = File.open(path, "wb")
     write_header(file, 0)
     
     return file

data/lib/pattern.rb

@@ -1,3 +1,8 @@
+# Domain object which models one or more Tracks playing a part of the song at the same time.
+# For example, a bass drum, snare drum, and hi-hat track playing the song's chorus.
+#
+# This object is like sheet music; the AudioEngine is responsible creating actual
+# audio data for a Pattern (with the help of a Kit).
 class Pattern
   FLOW_TRACK_NAME = "flow"
   

data/lib/song.rb

@@ -1,5 +1,13 @@
 class InvalidTempoError < RuntimeError; end
 
+
+# Domain object which models the 'sheet music' for a full song. Models the Patterns
+# that should be played, in which order (i.e. the flow), and at which tempo.
+#
+# This is the top-level model object that is used by the AudioEngine to produce
+# actual audio data. A Song tells the AudioEngine what sounds to trigger and when.
+# A Kit provides the sample data for each of these sounds. With a Song and a Kit
+# the AudioEngine can produce the audio data that is saved to disk.
 class Song
   DEFAULT_TEMPO = 120
 
@@ -61,21 +69,6 @@ class Song
     
     return copy
   end
-
-  # Changes the song flow to consist of playing the specified pattern once. All other patterns will
-  # be removed from the song as a side effect.
-  #
-  # pattern_to_keep - The Symbol name of the pattern to preserve.
-  #
-  # Returns nothing.
-  def remove_patterns_except(pattern_to_keep)
-    unless @patterns.has_key?(pattern_to_keep)
-      raise StandardError, "The song does not include a pattern called #{pattern_to_keep}"
-    end
-      
-    @flow = [pattern_to_keep]
-    remove_unused_patterns()
-  end
   
   # Splits a Song object into multiple Song objects, where each new
   # Song only has 1 track. For example, if a Song has 5 tracks, this will return

data/lib/songoptimizer.rb

@@ -109,16 +109,39 @@ protected
   #
   # Duplicate Patterns are more likely to occur after calling subdivide_song_patterns().
   def prune_duplicate_patterns(song)
+    pattern_replacements = determine_pattern_replacements(song.patterns)
+
+    # Update flow to remove references to duplicates
+    new_flow = song.flow
+    pattern_replacements.each do |duplicate, replacement|
+      new_flow = new_flow.map do |pattern_name|
+        (pattern_name == duplicate) ? replacement : pattern_name
+      end
+    end
+    song.flow = new_flow
+    
+    # This isn't strictly necessary, but makes resulting songs easier to read for debugging purposes.
+    song.remove_unused_patterns()
+
+    return song
+  end
+
+
+  # Examines a set of patterns definitions, determining which ones have the same tracks with the same
+  # rhythms. Then constructs a hash of pattern => pattern indicating that all occurances in the flow
+  # of the key should be replaced with the value, so that the other equivalent definitions can be pruned
+  # from the song (and hence their sample data doesn't need to be generated).
+  def determine_pattern_replacements(patterns)
     seen_patterns = []
     replacements = {}
     
     # Pattern names are sorted to ensure predictable pattern replacement. Makes tests easier to write.
     # Sort function added manually because Ruby 1.8 doesn't know how to sort symbols...
-    pattern_names = song.patterns.keys.sort {|x, y| x.to_s <=> y.to_s }
+    pattern_names = patterns.keys.sort {|x, y| x.to_s <=> y.to_s }
     
     # Detect duplicates
     pattern_names.each do |pattern_name|
-      pattern = song.patterns[pattern_name]
+      pattern = patterns[pattern_name]
       found_duplicate = false
       seen_patterns.each do |seen_pattern|
         if !found_duplicate && pattern.same_tracks_as?(seen_pattern)
@@ -131,20 +154,7 @@ protected
         seen_patterns << pattern
       end
     end
-    
-    # Update flow to remove references to duplicates
-    new_flow = song.flow
-    replacements.each do |duplicate, replacement|
-      new_flow = new_flow.map do |pattern_name|
-        (pattern_name == duplicate) ? replacement : pattern_name
-      end
-    end
-    song.flow = new_flow
-    
-    # Remove unused Patterns. Not strictly necessary, but makes resulting songs
-    # easier to read for debugging purposes.
-    song.remove_unused_patterns()
 
-    return song
+    return replacements
   end
 end

data/lib/songparser.rb

@@ -1,8 +1,12 @@
 class SongParseError < RuntimeError; end
 
-# This class is used to parse a raw YAML song definition into domain objects. These
-# domain objects can then be used by AudioEngine to generate the output sample data
-# for the song.
+
+# This class is used to parse a raw YAML song definition into domain objects (i.e.
+# Song, Pattern, Track, and Kit). These domain objects can then be used by AudioEngine
+# to generate the actual audio data that is saved to disk.
+#
+# The sole public method is parse(). It takes a raw YAML string and returns a Song and
+# Kit object (or raises an error if the YAML string couldn't be parsed correctly).
 class SongParser
   DONT_USE_STRUCTURE_WARNING =
       "\n" +
@@ -19,17 +23,17 @@ class SongParser
       - Verse: x2
       - Chorus: x2"
   
-  def initialize
+  def initialize()
   end
-  
+
+
   # Parses a raw YAML song definition and converts it into a Song and Kit object.
   def parse(base_path, raw_yaml_string)
     raw_song_components = hashify_raw_yaml(raw_yaml_string)
     
-    # This will be coming in a future version...
-    #unless raw_song_components[:folder] == nil
-    #  base_path = raw_song_components[:folder]
-    #end
+    unless raw_song_components[:folder] == nil
+      base_path = raw_song_components[:folder]
+    end
     
     song = Song.new()
     
@@ -63,9 +67,11 @@ class SongParser
     
     return song, kit
   end
-  
+
+
 private
 
+
   def hashify_raw_yaml(raw_yaml_string)
     begin
       raw_song_definition = YAML.load(raw_yaml_string)
@@ -74,7 +80,6 @@ private
     end
 
     raw_song_components = {}
-    warnings = []
     raw_song_components[:full_definition] = downcase_hash_keys(raw_song_definition)
     
     if raw_song_components[:full_definition]["song"] != nil
@@ -102,11 +107,13 @@ private
     
     return raw_song_components
   end
-      
+
+
   def build_kit(base_path, raw_kit, raw_patterns)
     kit_items = {}
     
     # Add sounds defined in the Kit section of the song header
+    # Converts [{a=>1}, {b=>2}, {c=>3}] from raw YAML to {a=>1, b=>2, c=>3}
     # TODO: Raise error is same name is defined more than once in the Kit
     unless raw_kit == nil
       raw_kit.each do |kit_item|
@@ -136,7 +143,8 @@ private
     kit = Kit.new(base_path, kit_items)
     return kit
   end
-  
+
+
   def add_patterns_to_song(song, raw_patterns)
     raw_patterns.keys.each do |key|
       new_pattern = song.pattern key.to_sym
@@ -145,7 +153,7 @@ private
       # TODO Also raise error if only there is only 1 track and it's a flow track
       if track_list == nil
         # TODO: Use correct capitalization of pattern name in error message
-        # TODO: Possibly allow if pattern not referenced in the Structure, or has 0 repeats?
+        # TODO: Possibly allow if pattern not referenced in the Flow, or has 0 repeats?
         raise SongParseError, "Pattern '#{key}' has no tracks. It needs at least one."
       end
       
@@ -160,7 +168,8 @@ private
       end
     end
   end
-  
+
+
   def set_song_flow(song, raw_flow)
     flow = []
 
@@ -195,7 +204,8 @@ private
     }
     song.flow = flow
   end
-    
+
+
   # Converts all hash keys to be lowercase
   def downcase_hash_keys(hash)
     return hash.inject({}) do |new_hash, pair|

data/lib/track.rb

@@ -1,5 +1,11 @@
 class InvalidRhythmError < RuntimeError; end
 
+
+# Domain object which models a kit sound playing a rhythm. For example,
+# a bass drum playing every quarter note for two measures.
+#
+# This object is like sheet music; the AudioEngine is responsible creating actual
+# audio data for a Track (with the help of a Kit).
 class Track
   REST = "."
   BEAT = "X"
@@ -27,7 +33,7 @@ class Track
       elsif ch == REST
         beat_length += 1
       else
-        raise InvalidRhythmError, "Track #{@name} has an invalid rhythm: '#{rhythm}'. Can only contain 'X' or '.'"
+        raise InvalidRhythmError, "Track #{@name} has an invalid rhythm: '#{rhythm}'. Can only contain '#{BEAT}', '#{REST}' or '#{BARLINE}'"
       end
     end
     

data/test/audioengine_test.rb

@@ -1,6 +1,6 @@
 $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
-require 'test/includes'
+require 'includes'
 
 # Make private methods public for testing
 class MockAudioEngine < AudioEngine

data/test/audioutils_test.rb

@@ -1,6 +1,6 @@
 $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
-require 'test/includes'
+require 'includes'
 
 class AudioUtilsTest < Test::Unit::TestCase
   def test_composite

data/test/includes.rb

@@ -2,12 +2,15 @@
 require 'test/unit'
 require 'yaml'
 require 'rubygems'
+
+# External gems
 require 'wavefile'
 
 # BEATS classes
 require 'audioengine'
 require 'audioutils'
 require 'beats'
+require 'beatswavefile'
 require 'kit'
 require 'pattern'
 require 'patternexpander'
@@ -15,4 +18,3 @@ require 'song'
 require 'songparser'
 require 'songoptimizer'
 require 'track'
-require 'beatswavefile'

data/test/{integration.rb → integration_test.rb}

@@ -1,8 +1,8 @@
 $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
-require 'test/includes'
+require 'includes'
 
-class SongParserTest < Test::Unit::TestCase
+class IntegrationTest < Test::Unit::TestCase
   TRACK_NAMES =  ["bass", "snare", "hh_closed", "hh_closed2", "agogo", "tom4", "tom2"]
   OUTPUT_FOLDER = "test/integration_output"
   
@@ -48,7 +48,11 @@ class SongParserTest < Test::Unit::TestCase
     beats = Beats.new(song_fixture, actual_output_file, {:split => false, :pattern => nil})
     beats.run()
     assert(File.exists?(actual_output_file), "Expected file '#{actual_output_file}' to exist, but it doesn't.")
-    assert_equal(File.read(expected_output_file), File.read(actual_output_file))
+
+    # 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)
@@ -81,14 +85,21 @@ class SongParserTest < 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.")
-      assert_equal(File.read(expected_output_file), File.read(actual_output_file))
       
+      # 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
   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|
@@ -97,4 +108,4 @@ class SongParserTest < Test::Unit::TestCase
       end
     end
   end
-end
+end

data/test/kit_test.rb

@@ -1,6 +1,6 @@
 $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
-require 'test/includes'
+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.

data/test/pattern_test.rb

@@ -1,6 +1,6 @@
 $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
-require 'test/includes'
+require 'includes'
 
 class PatternTest < Test::Unit::TestCase
   SAMPLE_RATE = 44100

data/test/patternexpander_test.rb

@@ -1,6 +1,6 @@
 $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
-require 'test/includes'
+require 'includes'
 
 class PatternExpanderTest < Test::Unit::TestCase  
   def test_expand_pattern_no_repeats

data/test/song_test.rb

@@ -1,6 +1,6 @@
 $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
-require 'test/includes'
+require 'includes'
 
 class SongTest < Test::Unit::TestCase
   FIXTURES = [:repeats_not_specified,
@@ -47,6 +47,23 @@ class SongTest < Test::Unit::TestCase
     assert_equal([:verse, :chorus, :verse, :chorus, :chorus], test_songs[:from_code].flow)
   end
   
+  def test_pattern
+    song = Song.new()
+    verse1 = song.pattern :Verse
+
+    assert_equal(:Verse, verse1.name)
+    assert_equal({:Verse => verse1}, song.patterns)
+
+    verse2 = song.pattern :Verse
+    assert_equal(:Verse, verse2.name)
+    assert_equal({:Verse => verse2}, song.patterns)
+    assert_not_equal(verse1, verse2)
+
+    chorus = song.pattern :Chorus
+    assert_equal(2, song.patterns.length)
+    assert_equal({:Chorus => chorus, :Verse => verse2}, song.patterns)
+  end
+  
   def test_total_tracks
     test_songs = generate_test_data()
     
@@ -93,20 +110,6 @@ class SongTest < Test::Unit::TestCase
     assert_equal({}, cloned_song.patterns)
   end
   
-  def test_remove_patterns_except
-    # Remove an existing pattern.
-    test_songs = generate_test_data()
-    test_songs[:example_with_kit].remove_patterns_except(:chorus)
-    assert_equal([:chorus], test_songs[:example_with_kit].flow)
-    assert_equal([:chorus], test_songs[:example_with_kit].patterns.keys)
-
-    # Try to remove a non-existent pattern. Error city.
-    test_songs = generate_test_data()
-    assert_raise(StandardError) do
-      test_songs[:example_with_kit].remove_patterns_except(:iamnotapattern)
-    end
-  end
-
   def test_split
     test_songs = generate_test_data()
     split_songs = test_songs[:example_with_kit].split()

data/test/songoptimizer_test.rb

@@ -1,6 +1,6 @@
 $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
-require 'test/includes'
+require 'includes'
 
 class MockSongOptimizer < SongOptimizer
   def clone_song_ignoring_patterns_and_flow(original_song)

data/test/songparser_test.rb

@@ -1,6 +1,6 @@
 $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
-require 'test/includes'
+require 'includes'
 
 class SongParserTest < Test::Unit::TestCase
   FIXTURE_BASE_PATH = File.dirname(__FILE__) + "/.."

data/test/track_test.rb

@@ -1,6 +1,6 @@
 $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
-require 'test/includes'
+require 'includes'
 
 class TrackTest < Test::Unit::TestCase
   def generate_test_data

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: beats
 version: !ruby/object:Gem::Version 
-  hash: 29
   prerelease: 
-  segments: 
-  - 1
-  - 2
-  - 1
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors: 
 - Joel Strait
@@ -15,12 +10,21 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-06 00:00:00 -05:00
-default_executable: 
-dependencies: []
-
+date: 2011-06-13 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: wavefile
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+  type: :runtime
+  version_requirements: *id001
 description: A command-line drum machine. Feed it a song notated in YAML, and it will produce a precision-milled Wave file of impeccable timing and feel.
-email: ""
+email: joel dot strait at Google's popular web mail service
 executables: 
 - beats
 extensions: []
@@ -30,6 +34,7 @@ extra_rdoc_files: []
 files: 
 - LICENSE
 - README.markdown
+- Rakefile
 - lib/audioengine.rb
 - lib/audioutils.rb
 - lib/beats.rb
@@ -41,7 +46,6 @@ files:
 - lib/songoptimizer.rb
 - lib/songparser.rb
 - lib/track.rb
-- lib/wavefile.rb
 - bin/beats
 - test/audioengine_test.rb
 - test/audioutils_test.rb
@@ -104,7 +108,7 @@ files:
 - test/fixtures/valid/with_structure.txt
 - test/fixtures/yaml/song_yaml.txt
 - test/includes.rb
-- test/integration.rb
+- test/integration_test.rb
 - test/kit_test.rb
 - test/pattern_test.rb
 - test/patternexpander_test.rb
@@ -198,7 +202,6 @@ files:
 - test/sounds/tom4_stereo_8.wav
 - test/sounds/tone.wav
 - test/track_test.rb
-has_rdoc: true
 homepage: http://beatsdrummachine.com/
 licenses: []
 
@@ -212,23 +215,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.6.1
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: A command-line drum machine. Feed it a song notated in YAML, and it will produce a precision-milled Wave file of impeccable timing and feel.
@@ -294,7 +291,7 @@ test_files:
 - test/fixtures/valid/with_structure.txt
 - test/fixtures/yaml/song_yaml.txt
 - test/includes.rb
-- test/integration.rb
+- test/integration_test.rb
 - test/kit_test.rb
 - test/pattern_test.rb
 - test/patternexpander_test.rb

data/lib/wavefile.rb

@@ -1,475 +0,0 @@
-# DO NOT EDIT THIS FILE
-# DO NOT EDIT THIS FILE
-# DO NOT EDIT THIS FILE
-#
-# OK, so what's the deal here? This file contains the WaveFile class defined
-# in v0.3.0 of the WaveFile gem (http://github.com/jstrait/wavefile). So why
-# are we manually importing the class instead of just using the Gem? The
-# reason is that (on my machine at least) it takes about 0.2 seconds
-# to load RubyGems in 1.8.7. This is a non-trivial amount of time, and for
-# shorter songs it can be a relatively large percentage of the total runtime.
-# (In Ruby 1.9, it has no effect on performance, since RubyGems is already
-# baked in anyway).
-#
-# So, considering that the WaveFile gem only contains one class (this file),
-# I'm just moving it here. This means BEATS doesn't have to use the
-# WaveFile gem, it therefore doesn't need to use RubyGems either. It's a hack,
-# but a pragmatic hack.
-# 
-# The caveat is that to make this as Gem-like as possible, this file should
-# be treated as an external library, and not edited.
-
-=begin
-WAV File Specification
-FROM http://ccrma.stanford.edu/courses/422/projects/WaveFormat/
-The canonical WAVE format starts with the RIFF header:
-0         4   ChunkID          Contains the letters "RIFF" in ASCII form
-                               (0x52494646 big-endian form).
-4         4   ChunkSize        36 + SubChunk2Size, or more precisely:
-                               4 + (8 + SubChunk1Size) + (8 + SubChunk2Size)
-                               This is the size of the rest of the chunk
-                               following this number.  This is the size of the
-                               entire file in bytes minus 8 bytes for the
-                               two fields not included in this count:
-                               ChunkID and ChunkSize.
-8         4   Format           Contains the letters "WAVE"
-                               (0x57415645 big-endian form).
-
-The "WAVE" format consists of two subchunks: "fmt " and "data":
-The "fmt " subchunk describes the sound data's format:
-12        4   Subchunk1ID      Contains the letters "fmt "
-                               (0x666d7420 big-endian form).
-16        4   Subchunk1Size    16 for PCM.  This is the size of the
-                               rest of the Subchunk which follows this number.
-20        2   AudioFormat      PCM = 1 (i.e. Linear quantization)
-                               Values other than 1 indicate some
-                               form of compression.
-22        2   NumChannels      Mono = 1, Stereo = 2, etc.
-24        4   SampleRate       8000, 44100, etc.
-28        4   ByteRate         == SampleRate * NumChannels * BitsPerSample/8
-32        2   BlockAlign       == NumChannels * BitsPerSample/8
-                               The number of bytes for one sample including
-                               all channels. I wonder what happens when
-                               this number isn't an integer?
-34        2   BitsPerSample    8 bits = 8, 16 bits = 16, etc.
-
-The "data" subchunk contains the size of the data and the actual sound:
-36        4   Subchunk2ID      Contains the letters "data"
-                               (0x64617461 big-endian form).
-40        4   Subchunk2Size    == NumSamples * NumChannels * BitsPerSample/8
-                               This is the number of bytes in the data.
-                               You can also think of this as the size
-                               of the read of the subchunk following this
-                               number.
-44        *   Data             The actual sound data.
-=end
-
-class WaveFile
-  CHUNK_ID = "RIFF"
-  FORMAT = "WAVE"
-  FORMAT_CHUNK_ID = "fmt "
-  SUB_CHUNK1_SIZE = 16
-  PCM = 1
-  DATA_CHUNK_ID = "data"
-  HEADER_SIZE = 36
-
-  def initialize(num_channels, sample_rate, bits_per_sample, sample_data = [])
-    if num_channels == :mono
-      @num_channels = 1
-    elsif num_channels == :stereo
-      @num_channels = 2
-    else
-      @num_channels = num_channels
-    end
-    @sample_rate = sample_rate
-    @bits_per_sample = bits_per_sample
-    @sample_data = sample_data
-    
-    @byte_rate = sample_rate * @num_channels * (bits_per_sample / 8)
-    @block_align = @num_channels * (bits_per_sample / 8)
-  end
-  
-  def self.open(path)
-    file = File.open(path, "rb")
-    
-    begin
-      header = read_header(file)
-      errors = validate_header(header)
-
-      if errors == []
-        sample_data = read_sample_data(file,
-                                       header[:num_channels],
-                                       header[:bits_per_sample],
-                                       header[:sub_chunk2_size])
-
-        wave_file = self.new(header[:num_channels],
-                             header[:sample_rate],
-                             header[:bits_per_sample],
-                             sample_data)
-      else
-        error_msg = "#{path} can't be opened, due to the following errors:\n"
-        errors.each {|error| error_msg += "  * #{error}\n" }
-        raise StandardError, error_msg
-      end
-    rescue EOFError
-      raise StandardError, "An error occured while reading #{path}."
-    ensure
-      file.close()
-    end
-    
-    return wave_file
-  end
-
-  def save(path)
-    # All numeric values should be saved in little-endian format
-
-    sample_data_size = @sample_data.length * @num_channels * (@bits_per_sample / 8)
-
-    # Write the header
-    file_contents = CHUNK_ID
-    file_contents += [HEADER_SIZE + sample_data_size].pack("V")
-    file_contents += FORMAT
-    file_contents += FORMAT_CHUNK_ID
-    file_contents += [SUB_CHUNK1_SIZE].pack("V")
-    file_contents += [PCM].pack("v")
-    file_contents += [@num_channels].pack("v")
-    file_contents += [@sample_rate].pack("V")
-    file_contents += [@byte_rate].pack("V")
-    file_contents += [@block_align].pack("v")
-    file_contents += [@bits_per_sample].pack("v")
-    file_contents += DATA_CHUNK_ID
-    file_contents += [sample_data_size].pack("V")
-
-    # Write the sample data
-    if !mono?
-      output_sample_data = []
-      @sample_data.each{|sample|
-        sample.each{|sub_sample|
-          output_sample_data << sub_sample
-        }
-      }
-    else
-      output_sample_data = @sample_data
-    end
-    
-    if @bits_per_sample == 8
-      file_contents += output_sample_data.pack("C*")
-    elsif @bits_per_sample == 16
-      file_contents += output_sample_data.pack("s*")
-    else
-      raise StandardError, "Bits per sample is #{@bits_per_samples}, only 8 or 16 are supported"
-    end
-
-    file = File.open(path, "w")
-    file.syswrite(file_contents)
-    file.close
-  end
-  
-  def sample_data()
-    return @sample_data
-  end
-  
-  def normalized_sample_data()    
-    if @bits_per_sample == 8
-      min_value = 128.0
-      max_value = 127.0
-      midpoint = 128
-    elsif @bits_per_sample == 16
-      min_value = 32768.0
-      max_value = 32767.0
-      midpoint = 0
-    else
-      raise StandardError, "Bits per sample is #{@bits_per_samples}, only 8 or 16 are supported"
-    end
-    
-    if mono?
-      normalized_sample_data = @sample_data.map {|sample|
-        sample -= midpoint
-        if sample < 0
-          sample.to_f / min_value
-        else
-          sample.to_f / max_value
-        end
-      }
-    else
-      normalized_sample_data = @sample_data.map {|sample|
-        sample.map {|sub_sample|
-          sub_sample -= midpoint
-          if sub_sample < 0
-            sub_sample.to_f / min_value
-          else
-            sub_sample.to_f / max_value
-          end
-        }
-      }
-    end
-    
-    return normalized_sample_data
-  end
-  
-  def sample_data=(sample_data)
-    if sample_data.length > 0 && ((mono? && sample_data[0].class == Float) ||
-                                  (!mono? && sample_data[0][0].class == Float))
-      if @bits_per_sample == 8
-        # Samples in 8-bit wave files are stored as a unsigned byte
-        # Effective values are 0 to 255, midpoint at 128
-        min_value = 128.0
-        max_value = 127.0
-        midpoint = 128
-      elsif @bits_per_sample == 16
-        # Samples in 16-bit wave files are stored as a signed little-endian short
-        # Effective values are -32768 to 32767, midpoint at 0
-        min_value = 32768.0
-        max_value = 32767.0
-        midpoint = 0
-      else
-        raise StandardError, "Bits per sample is #{@bits_per_samples}, only 8 or 16 are supported"
-      end
-      
-      if mono?
-        @sample_data = sample_data.map {|sample|
-          if(sample < 0.0)
-            (sample * min_value).round + midpoint
-          else
-            (sample * max_value).round + midpoint
-          end
-        }
-      else
-        @sample_data = sample_data.map {|sample|
-          sample.map {|sub_sample|
-            if(sub_sample < 0.0)
-              (sub_sample * min_value).round + midpoint
-            else
-              (sub_sample * max_value).round + midpoint
-            end
-          }
-        }
-      end
-    else
-      @sample_data = sample_data
-    end
-  end
-
-  def mono?()
-    return num_channels == 1
-  end
-  
-  def stereo?()
-    return num_channels == 2
-  end
-  
-  def reverse()
-    sample_data.reverse!()
-  end
-  
-  def duration()
-    total_samples = sample_data.length
-    samples_per_millisecond = @sample_rate / 1000.0
-    samples_per_second = @sample_rate
-    samples_per_minute = samples_per_second * 60
-    samples_per_hour = samples_per_minute * 60
-    hours, minutes, seconds, milliseconds = 0, 0, 0, 0
-    
-    if(total_samples >= samples_per_hour)
-      hours = total_samples / samples_per_hour
-      total_samples -= samples_per_hour * hours
-    end
-    
-    if(total_samples >= samples_per_minute)
-      minutes = total_samples / samples_per_minute
-      total_samples -= samples_per_minute * minutes
-    end
-    
-    if(total_samples >= samples_per_second)
-      seconds = total_samples / samples_per_second
-      total_samples -= samples_per_second * seconds
-    end
-    
-    milliseconds = (total_samples / samples_per_millisecond).floor
-    
-    return  { :hours => hours, :minutes => minutes, :seconds => seconds, :milliseconds => milliseconds }
-  end
-
-  def bits_per_sample=(new_bits_per_sample)
-    if new_bits_per_sample != 8 && new_bits_per_sample != 16
-      raise StandardError, "Bits per sample of #{@bits_per_samples} is invalid, only 8 or 16 are supported"
-    end
-    
-    if @bits_per_sample == 16 && new_bits_per_sample == 8
-      conversion_func = lambda {|sample|
-        if(sample < 0)
-          (sample / 256) + 128
-        else
-          # Faster to just divide by integer 258?
-          (sample / 258.007874015748031).round + 128
-        end
-      }
-
-      if mono?
-        @sample_data.map! &conversion_func
-      else
-        sample_data.map! {|sample| sample.map! &conversion_func }
-      end
-    elsif @bits_per_sample == 8 && new_bits_per_sample == 16
-      conversion_func = lambda {|sample|
-        sample -= 128
-        if(sample < 0)
-          sample * 256
-        else
-          # Faster to just multiply by integer 258?
-          (sample * 258.007874015748031).round
-        end
-      }
-      
-      if mono?
-        @sample_data.map! &conversion_func
-      else
-        sample_data.map! {|sample| sample.map! &conversion_func }
-      end
-    end
-    
-    @bits_per_sample = new_bits_per_sample
-  end
-  
-  def num_channels=(new_num_channels)
-    if new_num_channels == :mono
-      new_num_channels = 1
-    elsif new_num_channels == :stereo
-      new_num_channels = 2
-    end
-    
-    # The cases of mono -> stereo and vice-versa are handled in specially,
-    # because those conversion methods are faster than the general methods,
-    # and the large majority of wave files are expected to be either mono or stereo.    
-    if @num_channels == 1 && new_num_channels == 2
-      sample_data.map! {|sample| [sample, sample]}
-    elsif @num_channels == 2 && new_num_channels == 1
-        sample_data.map! {|sample| (sample[0] + sample[1]) / 2}
-    elsif @num_channels == 1 && new_num_channels >= 2
-      sample_data.map! {|sample| [].fill(sample, 0, new_num_channels)}
-    elsif @num_channels >= 2 && new_num_channels == 1
-      sample_data.map! {|sample| sample.inject(0) {|sub_sample, sum| sum + sub_sample } / @num_channels }
-    elsif @num_channels > 2 && new_num_channels == 2
-      sample_data.map! {|sample| [sample[0], sample[1]]}
-    end
-    
-    @num_channels = new_num_channels
-  end
-
-  def inspect()
-    duration = self.duration()
-    
-    result =  "Channels:        #{@num_channels}\n" +
-              "Sample rate:     #{@sample_rate}\n" +
-              "Bits per sample: #{@bits_per_sample}\n" +
-              "Block align:     #{@block_align}\n" +
-              "Byte rate:       #{@byte_rate}\n" +
-              "Sample count:    #{@sample_data.length}\n" +
-              "Duration:        #{duration[:hours]}h:#{duration[:minutes]}m:#{duration[:seconds]}s:#{duration[:milliseconds]}ms\n"
-  end
-
-  attr_reader :num_channels, :bits_per_sample, :byte_rate, :block_align
-  attr_accessor :sample_rate
-  
-private
-
-  def self.read_header(file)
-    header = {}
-    
-    # Read RIFF header
-    riff_header = file.sysread(12).unpack("a4Va4")
-    header[:chunk_id] = riff_header[0]
-    header[:chunk_size] = riff_header[1]
-    header[:format] = riff_header[2]
-    
-    # Read format subchunk
-    header[:sub_chunk1_id], header[:sub_chunk1_size] = self.read_to_chunk(file, FORMAT_CHUNK_ID)
-    format_subchunk_str = file.sysread(header[:sub_chunk1_size])
-    format_subchunk = format_subchunk_str.unpack("vvVVvv")  # Any extra parameters are ignored
-    header[:audio_format] = format_subchunk[0]
-    header[:num_channels] = format_subchunk[1]
-    header[:sample_rate] = format_subchunk[2]
-    header[:byte_rate] = format_subchunk[3]
-    header[:block_align] = format_subchunk[4]
-    header[:bits_per_sample] = format_subchunk[5]
-    
-    # Read data subchunk
-    header[:sub_chunk2_id], header[:sub_chunk2_size] = self.read_to_chunk(file, DATA_CHUNK_ID)
-    
-    return header
-  end
-
-  def self.read_to_chunk(file, expected_chunk_id)
-    chunk_id = file.sysread(4)
-    chunk_size = file.sysread(4).unpack("V")[0]
-
-    while chunk_id != expected_chunk_id
-      # Skip chunk
-      file.sysread(chunk_size)
-      
-      chunk_id = file.sysread(4)
-      chunk_size = file.sysread(4).unpack("V")[0]
-    end
-    
-    return chunk_id, chunk_size
-  end
-
-  def self.validate_header(header)
-    errors = []
-    
-    unless header[:bits_per_sample] == 8  ||  header[:bits_per_sample] == 16
-      errors << "Invalid bits per sample of #{header[:bits_per_sample]}. Only 8 and 16 are supported."
-    end
-    
-    unless (1..65535) === header[:num_channels]
-      errors << "Invalid number of channels. Must be between 1 and 65535."
-    end
-    
-    unless header[:chunk_id] == CHUNK_ID
-      errors << "Unsupported chunk ID: '#{header[:chunk_id]}'"
-    end
-    
-    unless header[:format] == FORMAT
-      errors << "Unsupported format: '#{header[:format]}'"
-    end
-    
-    unless header[:sub_chunk1_id] == FORMAT_CHUNK_ID
-      errors << "Unsupported chunk id: '#{header[:sub_chunk1_id]}'"
-    end
-    
-    unless header[:audio_format] == PCM
-      errors << "Unsupported audio format code: '#{header[:audio_format]}'"
-    end
-    
-    unless header[:sub_chunk2_id] == DATA_CHUNK_ID
-      errors << "Unsupported chunk id: '#{header[:sub_chunk2_id]}'"
-    end
-    
-    return errors
-  end
-  
-  # Assumes that file is "queued up" to the first sample
-  def self.read_sample_data(file, num_channels, bits_per_sample, sample_data_size)
-    if(bits_per_sample == 8)
-      data = file.sysread(sample_data_size).unpack("C*")
-    elsif(bits_per_sample == 16)
-      data = file.sysread(sample_data_size).unpack("s*")
-    else
-      data = []
-    end
-    
-    if(num_channels > 1)
-      multichannel_data = []
-      
-      i = 0
-      while i < data.length
-        multichannel_data << data[i...(num_channels + i)]
-        i += num_channels
-      end
-      
-      data = multichannel_data
-    end
-    
-    return data
-  end
-end