beats 1.0.0 → 1.1.0

data/README.markdown

@@ -10,18 +10,23 @@ BEATS is a drum machine written in pure Ruby. Feed it a song notated in YAML, an
         - Chorus:  x4
         - Verse:   x2
         - Chorus:  x4
+      Kit:
+        - bass:       sounds/bass.wav
+		- snare:      sounds/snare.wav
+		- hh_closed:  sounds/hh_closed.wav
+		- agogo:      sounds/agogo_high.wav
 
     Verse:
-      - bass.wav:       X...X...X...X...
-      - snare.wav:      ..............X.
-      - hh_closed.wav:  X.XXX.XXX.X.X.X.
-      - agogo_high.wav: ..............XX
+      - bass:             X...X...X...X...
+      - snare:            ..............X.
+      - hh_closed:        X.XXX.XXX.X.X.X.
+      - agogo:            ..............XX
 
     Chorus:
-      - bass.wav:       X...X...X...X...
-      - snare.wav:      ....X.......X...
-      - hh_closed.wav:  X.XXX.XXX.XX..X.
-      - tom4.wav:       ...........X....
-      - tom2.wav:       ..............X.
+      - bass:             X...X...X...X...
+      - snare:            ....X.......X...
+      - hh_closed:        X.XXX.XXX.XX..X.
+	  - sounds/tom4.wav:  ...........X....
+	  - sounds/tom2.wav:  ..............X.
 
 For installation and usage instructions, visit the BEATS website at [http://beatsdrummachine.com](http://beatsdrummachine.com).

data/bin/beats

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + "/../lib/song"
+require File.dirname(__FILE__) + "/../lib/songparser"
 require File.dirname(__FILE__) + "/../lib/kit"
 require File.dirname(__FILE__) + "/../lib/pattern"
 require File.dirname(__FILE__) + "/../lib/track"
@@ -9,7 +10,7 @@ require "optparse"
 require "yaml"
 require "wavefile"
 
-BEATS_VERSION = "1.0.0"
+BEATS_VERSION = "1.1.0"
 SAMPLE_RATE = 44100
 
 def parse_options
@@ -63,7 +64,8 @@ end
 
 begin
   parse_start_time = Time.now
-  song_from_file = Song.new(File.dirname(input_file), YAML.load_file(input_file))
+  song_parser = SongParser.new()
+  song_from_file = song_parser.parse(File.dirname(input_file), YAML.load_file(input_file))
   
   generate_samples_start = Time.now
   sample_data = song_from_file.sample_data(options[:pattern], options[:split])
@@ -90,12 +92,6 @@ rescue Errno::ENOENT => detail
   puts ""
   puts "Song file '#{input_file}' not found."
   puts ""
-rescue ArgumentError => detail
-  puts ""
-  puts "Song file '#{input_file}' has an error:"
-  puts "  Syntax error in YAML file:"
-  puts "  #{detail}"
-  puts ""
 rescue SongParseError => detail
   puts ""
   puts "Song file '#{input_file}' has an error:"

data/lib/kit.rb

@@ -1,5 +1,10 @@
+class SoundNotFoundError < RuntimeError; end
+
 class Kit
-  def initialize()
+  PATH_SEPARATOR = File.const_get("SEPARATOR")
+  
+  def initialize(base_path)
+    @base_path = base_path
     @sounds = {}
     @num_channels = 0
     @bits_per_sample = 0
@@ -7,28 +12,37 @@ class Kit
   
   def add(name, path)
     if(!@sounds.has_key? name)
-      w = WaveFile.open(path)
-      @sounds[name] = w
+      if(!path.start_with?(PATH_SEPARATOR))
+        path = @base_path + PATH_SEPARATOR + path
+      end
+      
+      begin
+        wavefile = WaveFile.open(path)
+      rescue
+        raise SoundNotFoundError, "Sound file #{name} not found."
+      end
+      
+      @sounds[name] = wavefile
     
-      if w.num_channels > @num_channels
-        @num_channels = w.num_channels
+      if wavefile.num_channels > @num_channels
+        @num_channels = wavefile.num_channels
       end
-      if w.bits_per_sample > @bits_per_sample
-        @bits_per_sample = w.bits_per_sample
+      if wavefile.bits_per_sample > @bits_per_sample
+        @bits_per_sample = wavefile.bits_per_sample
       end
     end
   end
   
   def get_sample_data(name)
-    w = @sounds[name]
+    wavefile = @sounds[name]
     
-    if w == nil
+    if wavefile == nil
       raise StandardError, "Kit doesn't contain sound '#{name}'."
     else
-      w.num_channels = @num_channels
-      w.bits_per_sample = @bits_per_sample
+      wavefile.num_channels = @num_channels
+      wavefile.bits_per_sample = @bits_per_sample
 
-      return w.sample_data
+      return wavefile.sample_data
     end
   end
   
@@ -36,5 +50,5 @@ class Kit
     return @sounds.length
   end
   
-  attr_reader :bits_per_sample, :num_channels
+  attr_reader :base_path, :bits_per_sample, :num_channels
 end

data/lib/pattern.rb

@@ -1,6 +1,7 @@
 class Pattern
   def initialize(name)
     @name = name
+    @cache = {}
     @tracks = {}
   end
   
@@ -47,6 +48,12 @@ class Pattern
 private
 
   def combined_sample_data(tick_sample_length, num_channels, num_tracks_in_song, incoming_overflow)
+    # If we've already encountered this pattern with the same incoming overflow before,
+    # return the pre-mixed down version from the cache.
+    if(@cache.member?(incoming_overflow))
+      return @cache[incoming_overflow]
+    end
+    
     fill_value = (num_channels == 1) ? 0 : [].fill(0, 0, num_channels)
     track_names = @tracks.keys
     primary_sample_data = []
@@ -64,8 +71,8 @@ private
           (0...track_samples.length).each {|i| primary_sample_data[i] += track_samples[i] }
         else
           (0...track_samples.length).each {|i|
-            primary_sample_data[i] = [primary_sample_data[i][0] + track_samples[i][0],
-                                      primary_sample_data[i][1] + track_samples[i][1]]
+            primary_sample_data[i][0] += track_samples[i][0]
+            primary_sample_data[i][1] += track_samples[i][1]
           }
         end
 
@@ -86,14 +93,18 @@ private
       end
     }
     
-    # Mix down the tracks into one
+    # Mix down the pattern's tracks into one single track
     if(num_channels == 1)
       primary_sample_data = primary_sample_data.map {|sample| (sample / num_tracks_in_song).round }
     else
       primary_sample_data = primary_sample_data.map {|sample| [(sample[0] / num_tracks_in_song).round, (sample[1] / num_tracks_in_song).round] }
     end
     
-    return {:primary => primary_sample_data, :overflow => overflow_sample_data}
+    # Add the result to the cache so we don't have to go through all of this the next time...
+    mixdown_sample_data = {:primary => primary_sample_data, :overflow => overflow_sample_data}
+    @cache[incoming_overflow] = mixdown_sample_data
+    
+    return mixdown_sample_data
   end
 
   def split_sample_data(tick_sample_length, num_channels, incoming_overflow)

data/lib/song.rb

@@ -1,20 +1,16 @@
-class SongParseError < RuntimeError; end
+class InvalidTempoError < RuntimeError; end
 
 class Song
   SAMPLE_RATE = 44100
   SECONDS_PER_MINUTE = 60.0
-  PATH_SEPARATOR = File.const_get("SEPARATOR")
+  SAMPLES_PER_MINUTE = SAMPLE_RATE * SECONDS_PER_MINUTE
+  DEFAULT_TEMPO = 120
 
-  def initialize(input_path, definition = nil)
-    self.tempo = 120
-    @input_path = input_path
-    @kit = Kit.new()
+  def initialize(base_path)
+    self.tempo = DEFAULT_TEMPO
+    @kit = Kit.new(base_path)
     @patterns = {}
     @structure = []
-
-    if(definition != nil)
-      parse(definition)
-    end
   end
 
   def pattern(name)
@@ -86,15 +82,15 @@ class Song
 
   def tempo=(new_tempo)
     if(new_tempo.class != Fixnum || new_tempo <= 0)
-      raise SongParseError, "Invalid tempo: '#{new_tempo}'. Tempo must be a number greater than 0."
+      raise InvalidTempoError, "Invalid tempo: '#{new_tempo}'. Tempo must be a number greater than 0."
     end
     
     @tempo = new_tempo
-    @tick_sample_length = (SAMPLE_RATE * SECONDS_PER_MINUTE) / new_tempo / 4.0
+    @tick_sample_length = SAMPLES_PER_MINUTE / new_tempo / 4.0
   end
 
-  attr_reader :input_path, :tick_sample_length
-  attr_accessor :structure
+  attr_reader :tick_sample_length, :patterns
+  attr_accessor :structure, :kit
 
 private
 
@@ -117,102 +113,6 @@ private
 
     return merged_sample_data
   end
-
-  # Converts all hash keys to be lowercase
-  def downcase_hash_keys(hash)
-    return hash.inject({}) {|new_hash, pair|
-        new_hash[pair.first.downcase] = pair.last
-        new_hash
-    }
-  end
-
-  def parse(definition)
-    if(definition.class == String)
-      song_definition = YAML.load(definition)
-    elsif(definition.class == Hash)
-      song_definition = definition
-    else
-      raise StandardError, "Invalid song input"
-    end
-
-    @kit = build_kit(song_definition)
-
-    song_definition = downcase_hash_keys(song_definition)
-    
-    # Process each pattern
-    song_definition.keys.each{|key|
-      if(key != "song")
-        new_pattern = self.pattern key.to_sym
-
-        track_list = song_definition[key]
-        track_list.each{|track_definition|
-          track_name = track_definition.keys.first
-          new_pattern.track track_name, @kit.get_sample_data(track_name), track_definition[track_name]
-        }
-      end
-    }
-    
-    # Process song header
-    parse_song_header(downcase_hash_keys(song_definition["song"]))
-  end
-  
-  def parse_song_header(header_data)
-    self.tempo = header_data["tempo"]
-
-    pattern_list = header_data["structure"]
-    structure = []
-    pattern_list.each{|pattern_item|
-      if(pattern_item.class == String)
-        pattern_item = {pattern_item => "x1"}
-      end
-      
-      pattern_name = pattern_item.keys.first
-      pattern_name_sym = pattern_name.downcase.to_sym
-      
-      if(!@patterns.has_key?(pattern_name_sym))
-        raise SongParseError, "Song structure includes non-existant pattern: #{pattern_name}."
-      end
-      
-      multiples_str = pattern_item[pattern_name]
-      multiples_str.slice!(0)
-      multiples = multiples_str.to_i
-      
-      if(multiples_str.match(/[^0-9]/) != nil)
-        raise SongParseError, "'#{multiples_str}' is an invalid number of repeats for pattern '#{pattern_name}'. Number of repeats should be a whole number."
-      elsif(multiples < 0)
-        raise SongParseError, "'#{multiples_str}' is an invalid number of repeats for pattern '#{pattern_name}'. Must be 0 or greater."
-      end
-      
-      multiples.times { structure << pattern_name_sym }
-    }
-
-    @structure = structure
-  end
-  
-  def build_kit(song_definition)
-    kit = Kit.new()
-    
-    song_definition.keys.each{|key|
-      if(key.downcase != "song")
-        track_list = song_definition[key]
-        track_list.each{|track_definition|
-          track_name = track_definition.keys.first
-          track_path = track_name
-          if(!track_path.start_with?(PATH_SEPARATOR))
-            track_path = @input_path + PATH_SEPARATOR + track_path
-          end
-          
-          if(!File.exists? track_path)
-            raise SongParseError, "File '#{track_name}' not found for pattern '#{key}'"
-          end
-          
-          kit.add(track_name, track_path)
-        }
-      end
-    }
-    
-    return kit
-  end
   
   def sample_data_split_all_patterns(fill_value, num_tracks_in_song)
     output_data = {}

data/lib/songparser.rb

@@ -0,0 +1,169 @@
+class SongParseError < RuntimeError; end
+
+class SongParser
+  NO_SONG_HEADER_ERROR_MSG =
+"Song must have a header. Here's an example:
+
+  Song:
+    Tempo: 120
+    Structure:
+      - Verse: x2
+      - Chorus: x2"
+  
+  def initialize()
+  end
+  
+  def parse(base_path, definition = nil)
+    raw_song_definition = canonicalize_definition(definition)
+    raw_song_components = split_raw_yaml_into_components(raw_song_definition)
+    
+    song = Song.new(base_path)
+    
+    # 1.) Set tempo
+    begin
+      if raw_song_components[:tempo] != nil
+        song.tempo = raw_song_components[:tempo]
+      end
+    rescue InvalidTempoError => detail
+      raise SongParseError, "#{detail}"
+    end
+    
+    # 2.) Build the kit
+    begin
+      kit = build_kit(base_path, raw_song_components[:kit], raw_song_components[:patterns])
+    rescue SoundNotFoundError => detail
+      raise SongParseError, "#{detail}"
+    end
+    song.kit = kit
+    
+    # 3.) Load patterns
+    add_patterns_to_song(song, raw_song_components[:patterns])
+    
+    # 4.) Set structure
+    if(raw_song_components[:structure] == nil)
+      raise SongParseError, "Song must have a Structure section in the header."
+    else
+      set_song_structure(song, raw_song_components[:structure])
+    end
+    
+    return song
+  end
+  
+private
+
+  # This is basically a factory. Don't see a benefit to extracting to a full class.
+  # Also, is "canonicalize" a word?
+  def canonicalize_definition(definition)
+    if(definition.class == String)
+      begin
+        raw_song_definition = YAML.load(definition)
+      rescue ArgumentError => detail
+        raise SongParseError, "Syntax error in YAML file"
+      end
+    elsif(definition.class == Hash)
+      raw_song_definition = definition
+    else
+      raise SongParseError, "Invalid song input"
+    end
+    
+    return raw_song_definition
+  end
+
+  def split_raw_yaml_into_components(raw_song_definition)
+    raw_song_components = {}
+    raw_song_components[:full_definition] = downcase_hash_keys(raw_song_definition)
+    
+    if(raw_song_components[:full_definition]["song"] != nil)
+      raw_song_components[:header] = downcase_hash_keys(raw_song_components[:full_definition]["song"])
+    else
+      raise SongParseError, NO_SONG_HEADER_ERROR_MSG
+    end
+    raw_song_components[:tempo]     = raw_song_components[:header]["tempo"]
+    raw_song_components[:kit]       = raw_song_components[:header]["kit"]
+    raw_song_components[:structure] = raw_song_components[:header]["structure"]
+    raw_song_components[:patterns]  = raw_song_components[:full_definition].reject {|k, v| k == "song"}
+  
+    return raw_song_components
+  end
+      
+  def build_kit(base_path, raw_kit, raw_patterns)
+    kit = Kit.new(base_path)
+    
+    # Add sounds defined in the Kit section of the song header
+    if(raw_kit != nil)
+      raw_kit.each {|kit_item|
+        kit.add(kit_item.keys.first, kit_item.values.first)
+      }
+    end
+    
+    # Add sounds not defined in Kit section, but used in individual tracks
+    # TODO Investigate detecting duplicate keys already defined in the Kit section, as this could possibly
+    # result in a performance improvement when the sound has to be converted to a different bit rate/num channels,
+    # as well as use less memory.
+    raw_patterns.keys.each{|key|
+      track_list = raw_patterns[key]
+      track_list.each{|track_definition|
+        track_name = track_definition.keys.first
+        track_path = track_name
+        
+        kit.add(track_name, track_path)
+      }
+    }
+    
+    return kit
+  end
+  
+  def add_patterns_to_song(song, raw_patterns)
+    raw_patterns.keys.each{|key|
+      new_pattern = song.pattern key.to_sym
+
+      track_list = raw_patterns[key]
+      track_list.each{|track_definition|
+        track_name = track_definition.keys.first
+       new_pattern.track track_name, song.kit.get_sample_data(track_name), track_definition[track_name]
+      }
+    }
+  end
+  
+  def set_song_structure(song, raw_structure)
+    structure = []
+
+    raw_structure.each{|pattern_item|
+      if(pattern_item.class == String)
+        pattern_item = {pattern_item => "x1"}
+      end
+      
+      pattern_name = pattern_item.keys.first
+      pattern_name_sym = pattern_name.downcase.to_sym
+      
+      # Convert the number of repeats from a String such as "x4" into an integer such as 4.
+      multiples_str = pattern_item[pattern_name]
+      multiples_str.slice!(0)
+      multiples = multiples_str.to_i
+      
+      if(multiples_str.match(/[^0-9]/) != nil)
+        raise SongParseError, "'#{multiples_str}' is an invalid number of repeats for pattern '#{pattern_name}'. Number of repeats should be a whole number."
+      else
+        if(multiples < 0)
+          raise SongParseError, "'#{multiples_str}' is an invalid number of repeats for pattern '#{pattern_name}'. Must be 0 or greater."
+        elsif(multiples > 0 && !song.patterns.has_key?(pattern_name_sym))
+          # This test is purposefully designed to only throw an error if the number of repeats is greater
+          # than 0. This allows you to specify an undefined pattern in the structure with "x0" repeats.
+          # This can be convenient for defining the structure before all patterns have been added to the song file.
+          raise SongParseError, "Song structure includes non-existent pattern: #{pattern_name}."
+        end
+      end
+      
+      multiples.times { structure << pattern_name_sym }
+    }
+    song.structure = structure
+  end
+    
+  # Converts all hash keys to be lowercase
+  def downcase_hash_keys(hash)
+    return hash.inject({}) {|new_hash, pair|
+        new_hash[pair.first.downcase] = pair.last
+        new_hash
+    }
+  end
+end

data/test/includes.rb

@@ -1,6 +1,7 @@
 require 'test/unit'
 require 'yaml'
 require 'song'
+require 'songparser'
 require 'pattern'
 require 'track'
 require 'kit'

data/test/kit_test.rb

@@ -6,50 +6,55 @@ class SongTest < Test::Unit::TestCase
   MIN_SAMPLE_8BIT = 0
   MAX_SAMPLE_8BIT = 255
   
-  def test_add
+  def test_valid_add
     # Test adding sounds with progressively higher bits per sample and num channels.
     # Verify that kit.bits_per_sample and kit.num_channels is ratcheted up.
-    kit = Kit.new()
+    kit = Kit.new("test/sounds")
     assert_equal(kit.bits_per_sample, 0)
     assert_equal(kit.num_channels, 0)
     assert_equal(kit.size, 0)
-    kit.add("mono8", "test/sounds/bass_mono_8.wav")
+    kit.add("mono8", "bass_mono_8.wav")
     assert_equal(kit.bits_per_sample, 8)
     assert_equal(kit.num_channels, 1)
     assert_equal(kit.size, 1)
-    kit.add("mono16", "test/sounds/bass_mono_16.wav")
+    kit.add("mono16", "bass_mono_16.wav")
     assert_equal(kit.bits_per_sample, 16)
     assert_equal(kit.num_channels, 1)
     assert_equal(kit.size, 2)
-    kit.add("stereo16", "test/sounds/bass_stereo_16.wav")
+    kit.add("stereo16", "bass_stereo_16.wav")
     assert_equal(kit.bits_per_sample, 16)
     assert_equal(kit.num_channels, 2)
     assert_equal(kit.size, 3)
     
     # Test adding sounds with progressively lower bits per sample and num channels.
     # Verify that kit.bits_per_sample and kit.num_channels doesn't change.
-    kit = Kit.new()
+    kit = Kit.new("test/sounds")
     assert_equal(kit.bits_per_sample, 0)
     assert_equal(kit.num_channels, 0)
-    kit.add("stereo16", "test/sounds/bass_stereo_16.wav")
+    kit.add("stereo16", "bass_stereo_16.wav")
     assert_equal(kit.bits_per_sample, 16)
     assert_equal(kit.num_channels, 2)
-    kit.add("mono16", "test/sounds/bass_mono_16.wav")
+    kit.add("mono16", "bass_mono_16.wav")
     assert_equal(kit.bits_per_sample, 16)
     assert_equal(kit.num_channels, 2)
-    kit.add("mono8", "test/sounds/bass_mono_8.wav")
+    kit.add("mono8", "bass_mono_8.wav")
     assert_equal(kit.bits_per_sample, 16)
     assert_equal(kit.num_channels, 2)
   end
   
+  def test_invalid_add
+    kit = Kit.new("test/sounds")
+    assert_raise(SoundNotFoundError) { kit.add("i_do_not_exist", "i_do_not_exist.wav") }
+  end
+
   def test_get_sample_data
-    kit = Kit.new()
+    kit = Kit.new("test/sounds")
     
     assert_raise(StandardError) { kit.get_sample_data("nonexistant") }
     
     # Test adding sounds with progressively higher bits per sample and num channels.
     # Verify that sample data bits per sample and num channels is ratcheted up.
-    kit.add("mono8", "test/sounds/bass_mono_8.wav")
+    kit.add("mono8", "bass_mono_8.wav")
     sample_data = kit.get_sample_data("mono8")
     assert(sample_data.max <= MAX_SAMPLE_8BIT)
     assert(sample_data.min >= MIN_SAMPLE_8BIT)
@@ -59,7 +64,7 @@ class SongTest < Test::Unit::TestCase
     }
     assert(all_are_fixnums)
     
-    kit.add("mono16", "test/sounds/bass_mono_16.wav")
+    kit.add("mono16", "bass_mono_16.wav")
     sample_data = kit.get_sample_data("mono8")
     assert(sample_data.max > MAX_SAMPLE_8BIT)
     assert(sample_data.min < MIN_SAMPLE_8BIT)
@@ -69,7 +74,7 @@ class SongTest < Test::Unit::TestCase
     }
     assert(all_are_fixnums)
     
-    kit.add("stereo16", "test/sounds/bass_stereo_16.wav")
+    kit.add("stereo16", "bass_stereo_16.wav")
     sample_data = kit.get_sample_data("stereo16")
     assert(sample_data.flatten.max > MAX_SAMPLE_8BIT)
     assert(sample_data.flatten.min < MIN_SAMPLE_8BIT)
@@ -83,9 +88,9 @@ class SongTest < Test::Unit::TestCase
     
     # Test adding sounds with progressively lower bits per sample and num channels.
     # Verify that sample data bits per sample and num channels doesn't go down.
-    kit = Kit.new()
+    kit = Kit.new("test/sounds")
     
-    kit.add("stereo16", "test/sounds/bass_stereo_16.wav")
+    kit.add("stereo16", "bass_stereo_16.wav")
     sample_data = kit.get_sample_data("stereo16")
     assert(sample_data.flatten.max > MAX_SAMPLE_8BIT)
     assert(sample_data.flatten.min < MIN_SAMPLE_8BIT)
@@ -96,7 +101,7 @@ class SongTest < Test::Unit::TestCase
     assert(all_are_arrays)
     assert(sample_data.first.length == 2)
     
-    kit.add("mono16", "test/sounds/bass_mono_16.wav")
+    kit.add("mono16", "bass_mono_16.wav")
     sample_data = kit.get_sample_data("mono16")
     assert(sample_data.flatten.max > MAX_SAMPLE_8BIT)
     assert(sample_data.flatten.min < MIN_SAMPLE_8BIT)
@@ -107,7 +112,7 @@ class SongTest < Test::Unit::TestCase
     assert(all_are_arrays)
     assert(sample_data.first.length == 2)
     
-    kit.add("mono8", "test/sounds/bass_mono_8.wav")
+    kit.add("mono8", "bass_mono_8.wav")
     sample_data = kit.get_sample_data("mono8")
     assert(sample_data.flatten.max > MAX_SAMPLE_8BIT)
     assert(sample_data.flatten.min < MIN_SAMPLE_8BIT)

data/test/pattern_test.rb

@@ -7,11 +7,11 @@ class PatternTest < Test::Unit::TestCase
   SECONDS_IN_MINUTE = 60.0
 
   def generate_test_data
-    kit = Kit.new()
-    kit.add("bass.wav",      "test/sounds/bass_mono_8.wav")
-    kit.add("snare.wav",     "test/sounds/snare_mono_8.wav")
-    kit.add("hh_closed.wav", "test/sounds/hh_closed_mono_8.wav")
-    kit.add("hh_open.wav",   "test/sounds/hh_open_mono_8.wav")
+    kit = Kit.new("test/sounds")
+    kit.add("bass.wav",      "bass_mono_8.wav")
+    kit.add("snare.wav",     "snare_mono_8.wav")
+    kit.add("hh_closed.wav", "hh_closed_mono_8.wav")
+    kit.add("hh_open.wav",   "hh_open_mono_8.wav")
     
     test_patterns = []
     

data/test/song_test.rb

@@ -2,41 +2,26 @@ $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
 require 'test/includes'
 
-class MockSong < Song
-  attr_reader :patterns
-  attr_accessor :kit
-end
-
 class SongTest < Test::Unit::TestCase
   DEFAULT_TEMPO = 120
   
   def generate_test_data
-    kit = Kit.new()
-    kit.add("bass.wav",      "test/sounds/bass_mono_8.wav")
-    kit.add("snare.wav",     "test/sounds/snare_mono_8.wav")
-    kit.add("hh_closed.wav", "test/sounds/hh_closed_mono_8.wav")
-    kit.add("ride.wav",      "test/sounds/ride_mono_8.wav")
+    kit = Kit.new("test/sounds")
+    kit.add("bass.wav",      "bass_mono_8.wav")
+    kit.add("snare.wav",     "snare_mono_8.wav")
+    kit.add("hh_closed.wav", "hh_closed_mono_8.wav")
+    kit.add("ride.wav",      "ride_mono_8.wav")
     
-    test_songs = {}
+    test_songs = SongParserTest.generate_test_data()
     
-    test_songs[:blank] = MockSong.new(File.dirname(__FILE__) + "/..")
+    test_songs[:blank] = Song.new("test/sounds")
     
-    test_songs[:no_structure] = MockSong.new(File.dirname(__FILE__) + "/..")
+    test_songs[:no_structure] = Song.new("test/sounds")
     verse = test_songs[:no_structure].pattern :verse
     verse.track "bass.wav",      kit.get_sample_data("bass.wav"),      "X.......X......."
     verse.track "snare.wav",     kit.get_sample_data("snare.wav"),     "....X.......X..."
     verse.track "hh_closed.wav", kit.get_sample_data("hh_closed.wav"), "X.X.X.X.X.X.X.X."
     
-    repeats_not_specified_yaml = "
-Song:
-  Tempo: 100
-  Structure:
-    - Verse
-    
-Verse:
-  - test/sounds/bass_mono_8.wav: X"
-    test_songs[:repeats_not_specified] = MockSong.new(File.dirname(__FILE__) + "/..", repeats_not_specified_yaml)
-    
     overflow_yaml = "
 Song:
   Tempo: 100
@@ -45,9 +30,9 @@ Song:
 
 Verse:
   - test/sounds/snare_mono_8.wav: ...X"
-    test_songs[:overflow] = MockSong.new(File.dirname(__FILE__) + "/..", overflow_yaml)
+    test_songs[:overflow] = SongParser.new().parse(File.dirname(__FILE__) + "/..", overflow_yaml)
     
-    test_songs[:from_code] = MockSong.new(File.dirname(__FILE__) + "/..")
+    test_songs[:from_code] = Song.new("test/sounds")
     verse = test_songs[:from_code].pattern :verse
     verse.track "bass.wav",      kit.get_sample_data("bass.wav"),      "X.......X......."
     verse.track "snare.wav",     kit.get_sample_data("snare.wav"),     "....X.......X..."
@@ -59,91 +44,20 @@ Verse:
     test_songs[:from_code].structure = [:verse, :chorus, :verse, :chorus, :chorus]
     test_songs[:from_code].kit = kit
     
-    valid_yaml_string = "# An example song
-
-Song:
-  Tempo: 99
-  Structure:
-    - Verse:  x2
-    - Chorus: x2
-    - Verse:  x2
-    - Chorus: x4
-    - Bridge: x1
-    - Chorus: x4
-
-Verse:
-  - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X...
-  - test/sounds/snare_mono_8.wav:     ..X...X...X...X.X...X...X...X...
-# Here is a comment
-  - test/sounds/hh_closed_mono_8.wav: X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.
-  - test/sounds/hh_open_mono_8.wav:   X...............X..............X
-# Here is another comment
-Chorus:
-  - test/sounds/bass_mono_8.wav:      X...X...XXXXXXXXX...X...X...X...
-  - test/sounds/snare_mono_8.wav:     ...................X...X...X...X
-  - test/sounds/hh_closed_mono_8.wav: X.X.XXX.X.X.XXX.X.X.XXX.X.X.XXX. # It's comment time
-  - test/sounds/hh_open_mono_8.wav:   ........X.......X.......X.......
-  - test/sounds/ride_mono_8.wav:      ....X...................X.......
-
-
-Bridge:
-  - test/sounds/hh_closed_mono_8.wav: XX.XXX.XXX.XXX.XXX.XXX.XXX.XXX.X"
-    
-    test_songs[:from_valid_yaml_string] = MockSong.new(File.dirname(__FILE__) + "/..", valid_yaml_string)
-    
     return test_songs
   end
     
   def test_initialize
-    test_songs = generate_test_data
+    test_songs = generate_test_data()
     
     assert_equal(test_songs[:blank].structure, [])
     assert_equal(test_songs[:blank].tick_sample_length, (Song::SAMPLE_RATE * Song::SECONDS_PER_MINUTE) / DEFAULT_TEMPO / 4.0)
+    
     assert_equal(test_songs[:no_structure].structure, [])
     assert_equal(test_songs[:no_structure].tick_sample_length, (Song::SAMPLE_RATE * Song::SECONDS_PER_MINUTE) / DEFAULT_TEMPO / 4.0)
+    
     assert_equal(test_songs[:from_code].structure, [:verse, :chorus, :verse, :chorus, :chorus])
     assert_equal(test_songs[:from_code].tick_sample_length, (Song::SAMPLE_RATE * Song::SECONDS_PER_MINUTE) / DEFAULT_TEMPO / 4.0)
-    
-    assert_equal(test_songs[:from_valid_yaml_string].structure, [:verse, :verse, :chorus, :chorus, :verse, :verse, :chorus, :chorus, :chorus, :chorus, :bridge, :chorus, :chorus, :chorus, :chorus])
-    assert_equal(test_songs[:from_valid_yaml_string].tempo, 99)
-    assert_equal(test_songs[:from_valid_yaml_string].tick_sample_length, (Song::SAMPLE_RATE * Song::SECONDS_PER_MINUTE) / 99 / 4.0)
-    assert_equal(test_songs[:from_valid_yaml_string].patterns.keys.map{|key| key.to_s}.sort, ["bridge", "chorus", "verse"])
-    assert_equal(test_songs[:from_valid_yaml_string].patterns[:verse].tracks.length, 4)
-    assert_equal(test_songs[:from_valid_yaml_string].patterns[:chorus].tracks.length, 5)
-    assert_equal(test_songs[:from_valid_yaml_string].patterns[:bridge].tracks.length, 1)
-  end
-  
-  def test_invalid_initialize
-    invalid_tempo_yaml_string = "# Invalid tempo song
-    Song:
-      Tempo: 100a
-      Structure:
-        - Verse:  x2
-
-    Verse:
-      - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X..."
-    assert_raise(SongParseError) { song = MockSong.new(File.dirname(__FILE__) + "/..", invalid_tempo_yaml_string) }
-    
-    invalid_structure_yaml_string = "# Invalid structure song
-    Song:
-      Tempo: 100
-      Structure:
-        - Verse:  x2
-        - Chorus: x1
-
-    Verse:
-      - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X..."
-    assert_raise(SongParseError) { song = MockSong.new(File.dirname(__FILE__) + "/..", invalid_structure_yaml_string) }
-    
-    invalid_repeats_yaml_string = "    # Invalid structure song
-    Song:
-      Tempo: 100
-      Structure:
-        - Verse:  x2a
-
-    Verse:
-      - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X..."
-    assert_raise(SongParseError) { song = MockSong.new(File.dirname(__FILE__) + "/..", invalid_repeats_yaml_string) }
   end
   
   def test_total_tracks

data/test/songparser_test.rb

@@ -0,0 +1,207 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/includes'
+
+class SongParserTest < Test::Unit::TestCase
+  def self.generate_test_data
+    kit = Kit.new("test/sounds")
+    kit.add("bass.wav",      "bass_mono_8.wav")
+    kit.add("snare.wav",     "snare_mono_8.wav")
+    kit.add("hh_closed.wav", "hh_closed_mono_8.wav")
+    kit.add("ride.wav",      "ride_mono_8.wav")
+
+    test_songs = {}
+    base_path = File.dirname(__FILE__) + "/.."
+
+    no_tempo_yaml = "
+Song:
+  Structure:
+    - Verse: x1
+
+Verse:
+  - test/sounds/bass_mono_8.wav: X"
+    test_songs[:no_tempo] = SongParser.new().parse(base_path, no_tempo_yaml)
+
+    repeats_not_specified_yaml = "
+Song:
+  Tempo: 100
+  Structure:
+    - Verse
+
+Verse:
+  - test/sounds/bass_mono_8.wav: X"
+    test_songs[:repeats_not_specified] = SongParser.new().parse(base_path, repeats_not_specified_yaml)
+
+    overflow_yaml = "
+Song:
+  Tempo: 100
+  Structure:
+    - Verse: x2
+
+Verse:
+  - test/sounds/snare_mono_8.wav: ...X"
+    test_songs[:overflow] = SongParser.new().parse(base_path, overflow_yaml)
+
+    valid_yaml_string = "# An example song
+  
+Song:
+  Tempo: 99
+  Structure:
+    - Verse:     x2
+    - Chorus:    x2
+    - Verse:     x2
+    - Chorus:    x4
+    - Bridge:    x1
+    - Undefined: x0  # This is legal as long as num repeats is 0.
+    - Chorus:    x4
+
+Verse:
+  - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X...
+  - test/sounds/snare_mono_8.wav:     ..X...X...X...X.X...X...X...X...
+# Here is a comment
+  - test/sounds/hh_closed_mono_8.wav: X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.
+  - test/sounds/hh_open_mono_8.wav:   X...............X..............X
+# Here is another comment
+Chorus:
+  - test/sounds/bass_mono_8.wav:      X...X...XXXXXXXXX...X...X...X...
+  - test/sounds/snare_mono_8.wav:     ...................X...X...X...X
+  - test/sounds/hh_closed_mono_8.wav: X.X.XXX.X.X.XXX.X.X.XXX.X.X.XXX. # It's comment time
+  - test/sounds/hh_open_mono_8.wav:   ........X.......X.......X.......
+  - test/sounds/ride_mono_8.wav:      ....X...................X.......
+
+
+Bridge:
+  - test/sounds/hh_closed_mono_8.wav: XX.XXX.XXX.XXX.XXX.XXX.XXX.XXX.X"
+    test_songs[:from_valid_yaml_string] = SongParser.new().parse(base_path, valid_yaml_string)
+
+    valid_yaml_string_with_kit = "# An example song
+
+Song:
+  Tempo: 99
+  Kit:
+    - bass:     test/sounds/bass_mono_8.wav
+    - snare:    test/sounds/snare_mono_8.wav
+    - hhclosed: test/sounds/hh_closed_mono_8.wav
+    - hhopen:   test/sounds/hh_open_mono_8.wav
+  Structure:
+    - Verse:  x2
+    - Chorus: x2
+    - Verse:  x2
+    - Chorus: x4
+    - Bridge: x1
+    - Undefined: x0  # This is legal as long as num repeats is 0.
+    - Chorus: x4
+
+Verse:
+  - base:      X...X...X...XX..X...X...XX..X...
+  - snare:     ..X...X...X...X.X...X...X...X...
+# Here is a comment
+  - hhclosed:  X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.
+  - hhopen:    X...............X..............X
+# Here is another comment
+Chorus:
+  - bass:      X...X...XXXXXXXXX...X...X...X...
+  - snare:     ...................X...X...X...X
+  - test/sounds/hh_closed_mono_8.wav: X.X.XXX.X.X.XXX.X.X.XXX.X.X.XXX. # It's comment time
+  - hhopen:    ........X.......X.......X.......
+  - test/sounds/ride_mono_8.wav:      ....X...................X.......
+
+Bridge:
+  - hhclosed: XX.XXX.XXX.XXX.XXX.XXX.XXX.XXX.X"
+    test_songs[:from_valid_yaml_string_with_kit] = SongParser.new().parse(base_path, valid_yaml_string)
+
+    return test_songs
+  end
+
+  def test_valid_initialize
+    test_songs = SongParserTest.generate_test_data()
+    
+    assert_equal(test_songs[:no_tempo].tempo, 120)
+    assert_equal(test_songs[:no_tempo].structure, [:verse])
+    
+    assert_equal(test_songs[:repeats_not_specified].tempo, 100)
+    assert_equal(test_songs[:repeats_not_specified].structure, [:verse])
+    
+    # These two songs should be the same, except that one uses a kit in the song header
+    # and the other doesn't.
+    [:from_valid_yaml_string, :from_valid_yaml_string_with_kit].each {|song_key|
+      song = test_songs[song_key]
+      assert_equal(song.structure, [:verse, :verse, :chorus, :chorus, :verse, :verse, :chorus, :chorus, :chorus, :chorus, :bridge, :chorus, :chorus, :chorus, :chorus])
+      assert_equal(song.tempo, 99)
+      assert_equal(song.tick_sample_length, (Song::SAMPLE_RATE * Song::SECONDS_PER_MINUTE) / 99 / 4.0)
+      assert_equal(song.patterns.keys.map{|key| key.to_s}.sort, ["bridge", "chorus", "verse"])
+      assert_equal(song.patterns[:verse].tracks.length, 4)
+      assert_equal(song.patterns[:chorus].tracks.length, 5)
+      assert_equal(song.patterns[:bridge].tracks.length, 1)
+    }
+  end
+  
+  def test_invalid_initialize
+    no_header_yaml_string = "# Song with no header
+    Verse:
+      - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X..."
+    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", no_header_yaml_string) }
+    
+    sound_doesnt_exist_yaml_string = "# Song with non-existent sound
+    Song:
+      Tempo: 100
+      Structure:
+        - Verse: x1
+        
+    Verse:
+      - test/sounds/i_do_not_exist.wav: X...X..."
+    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", sound_doesnt_exist_yaml_string) }
+    
+    
+    sound_doesnt_exist_in_kit_yaml_string = "# Song with non-existent sound in Kit
+    Song:
+      Tempo: 100
+      Structure:
+        - Verse: x1
+      Kit:
+        - bad: test/sounds/i_do_not_exist.wav
+      
+    Verse:
+      - bad: X...X..."
+    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", sound_doesnt_exist_in_kit_yaml_string) }
+    
+    invalid_tempo_yaml_string = "# Song with invalid tempo
+    Song:
+      Tempo: 100a
+      Structure:
+        - Verse:  x2
+
+    Verse:
+      - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X..."
+    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", invalid_tempo_yaml_string) }
+
+    invalid_structure_yaml_string = "# Song whose structure references non-existent pattern
+    Song:
+      Tempo: 100
+      Structure:
+        - Verse:  x2
+        - Chorus: x1
+
+    Verse:
+      - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X..."
+    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", invalid_structure_yaml_string) }
+    
+    no_structure_yaml_string = "# Song without a structure section in the header
+    Song:
+      Tempo: 100
+
+    Verse:
+      - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X..."
+    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", no_structure_yaml_string) }
+    
+    invalid_repeats_yaml_string = "# Song with invalid number of repeats for pattern
+    Song:
+      Tempo: 100
+      Structure:
+        - Verse:  x2a
+
+    Verse:
+      - test/sounds/bass_mono_8.wav:      X...X...X...XX..X...X...XX..X..."
+    assert_raise(SongParseError) { song = SongParser.new().parse(File.dirname(__FILE__) + "/..", invalid_repeats_yaml_string) }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: beats
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Joel Strait
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-13 00:00:00 -05:00
+date: 2010-04-12 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -36,12 +36,14 @@ files:
 - lib/kit.rb
 - lib/pattern.rb
 - lib/song.rb
+- lib/songparser.rb
 - lib/track.rb
 - bin/beats
 - test/includes.rb
 - test/kit_test.rb
 - test/pattern_test.rb
 - test/song_test.rb
+- test/songparser_test.rb
 - test/sounds/bass_mono_16.wav
 - test/sounds/bass_mono_8.wav
 - test/sounds/bass_stereo_16.wav
@@ -83,6 +85,7 @@ test_files:
 - test/kit_test.rb
 - test/pattern_test.rb
 - test/song_test.rb
+- test/songparser_test.rb
 - test/sounds/bass_mono_16.wav
 - test/sounds/bass_mono_8.wav
 - test/sounds/bass_stereo_16.wav