beats 2.1.0 → 2.1.1

data/lib/beats/song.rb

@@ -18,8 +18,8 @@ module Beats
     end
 
     # Adds a new pattern to the song, with the specified name.
-    def pattern(name)
-      @patterns[name] = Pattern.new(name)
+    def pattern(name, tracks=[])
+      @patterns[name] = Pattern.new(name, tracks)
     end
 
 
@@ -75,15 +75,14 @@ module Beats
       track_names.each do |track_name|
         new_song = copy_ignoring_patterns_and_flow
 
-        @patterns.each do |name, original_pattern|
-          new_pattern = new_song.pattern(name)
-
+        @patterns.each do |pattern_name, original_pattern|
           if original_pattern.tracks.has_key?(track_name)
-            original_track = original_pattern.tracks[track_name]
-            new_pattern.track(original_track.name, original_track.rhythm)
+            new_track = original_pattern.tracks[track_name]
           else
-            new_pattern.track(track_name, "." * original_pattern.step_count)
+            new_track = Track.new(track_name, Track::REST * original_pattern.step_count)
           end
+
+          new_song.pattern(pattern_name, [new_track])
         end
 
         new_song.flow = @flow

data/lib/beats/{songoptimizer.rb → song_optimizer.rb}

@@ -57,7 +57,7 @@ module Beats
     # Note that if a track in a sub-divided pattern has no triggers (such as track2 in the
     # 2nd pattern above), it will not be included in the new pattern.
     def subdivide_song_patterns(original_song, optimized_song, max_pattern_length)
-      blank_track_pattern = '.' * max_pattern_length
+      blank_track_rhythm = Track::REST * max_pattern_length
 
       # For each pattern, add a new pattern to new song every max_pattern_length steps
       optimized_flow = {}
@@ -68,23 +68,26 @@ module Beats
         while(pattern.tracks.values.first.rhythm[step_index] != nil) do
           # TODO: Is this pattern 100% sufficient to prevent collisions between subdivided
           #       pattern names and existing patterns with numeric suffixes?
-          new_pattern = optimized_song.pattern("#{pattern.name}_#{step_index}".to_sym)
-          optimized_flow[pattern.name] << new_pattern.name
+          new_pattern_name = "#{pattern.name}_#{step_index}".to_sym
+          new_tracks = []
+          optimized_flow[pattern.name] << new_pattern_name
           pattern.tracks.values.each do |track|
-            sub_track_pattern = track.rhythm[step_index...(step_index + max_pattern_length)]
+            sub_track_rhythm = track.rhythm[step_index...(step_index + max_pattern_length)]
 
-            if sub_track_pattern != blank_track_pattern
-              new_pattern.track(track.name, sub_track_pattern)
+            if sub_track_rhythm != blank_track_rhythm
+              new_tracks << Track.new(track.name, sub_track_rhythm)
             end
           end
 
           # If no track has a trigger during this step pattern, add a blank track.
           # Otherwise, this pattern will have no steps, and no sound will be generated,
           # causing the pattern to be "compacted away".
-          if new_pattern.tracks.empty?
-            new_pattern.track(Kit::PLACEHOLDER_TRACK_NAME, blank_track_pattern)
+          if new_tracks.empty?
+            new_tracks << Track.new(Kit::PLACEHOLDER_TRACK_NAME, blank_track_rhythm)
           end
 
+          optimized_song.pattern(new_pattern_name, new_tracks)
+
           step_index += max_pattern_length
         end
       end

data/lib/beats/{songparser.rb → song_parser.rb}

@@ -6,23 +6,10 @@ module Beats
   # 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
-    class ParseError < RuntimeError; end
-
-    NO_SONG_HEADER_ERROR_MSG =
-  "Song must have a header. Here's an example:
-
-  Song:
-    Tempo: 120
-    Flow:
-      - Verse: x2
-      - Chorus: x2"
-
-    def initialize
-    end
-
+    class ParseError < StandardError; end
 
     # Parses a raw YAML song definition and converts it into a Song and Kit object.
-    def parse(base_path, raw_yaml_string)
+    def self.parse(base_path, raw_yaml_string)
       raw_song_components = hashify_raw_yaml(raw_yaml_string)
 
       unless raw_song_components[:folder].nil?
@@ -85,8 +72,16 @@ module Beats
 
   private
 
+    NO_SONG_HEADER_ERROR_MSG =
+"Song must have a header. Here's an example:
+
+Song:
+  Tempo: 120
+  Flow:
+    - Verse: x2
+    - Chorus: x2"
 
-    def hashify_raw_yaml(raw_yaml_string)
+    def self.hashify_raw_yaml(raw_yaml_string)
       begin
         raw_song_definition = YAML.load(raw_yaml_string)
       rescue Psych::SyntaxError => detail
@@ -95,38 +90,39 @@ module Beats
         raise ParseError, "Syntax error in YAML file: #{detail}"
       end
 
-      raw_song_components = {}
-      raw_song_components[:full_definition] = downcase_hash_keys(raw_song_definition)
+      header_keys = raw_song_definition.keys.select {|key| key.downcase == "song" }
 
-      unless raw_song_components[:full_definition]["song"].nil?
-        raw_song_components[:header] = downcase_hash_keys(raw_song_components[:full_definition]["song"])
-      else
+      if header_keys.empty?
         raise ParseError, NO_SONG_HEADER_ERROR_MSG
+      elsif header_keys.length > 1
+        # In theory, this branch should never be reached, due the YAML hash mappings
+        # not allowing duplicate keys?
+        raise ParseError, "Song has multiple 'Song' sections, it should only have 1."
+      else
+        header = downcase_hash_keys(raw_song_definition.delete(header_keys.first))
       end
-      raw_song_components[:tempo]     = raw_song_components[:header]["tempo"]
-      raw_song_components[:folder]    = raw_song_components[:header]["folder"]
-      raw_song_components[:kit]       = raw_song_components[:header]["kit"]
 
-      raw_song_components[:flow] = raw_song_components[:header]["flow"]
-
-      raw_song_components[:swing]   = raw_song_components[:header]["swing"]
-      raw_song_components[:patterns]  = raw_song_components[:full_definition].reject {|k, v| k == "song"}
-
-      return raw_song_components
+      {
+        tempo: header["tempo"],
+        folder: header["folder"],
+        kit: header["kit"],
+        flow: header["flow"],
+        swing: header["swing"],
+        patterns: raw_song_definition,
+      }
     end
 
-    def add_kit_sounds_from_kit(kit_builder, raw_kit)
+    def self.add_kit_sounds_from_kit(kit_builder, raw_kit)
+      return if raw_kit.nil?
+
       # 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|
-          kit_builder.add_item(kit_item.keys.first, kit_item.values.first)
-        end
+      raw_kit.each do |kit_item|
+        kit_builder.add_item(kit_item.keys.first, kit_item.values.first)
       end
     end
 
-    def add_kit_sounds_from_patterns(kit_builder, patterns)
+    def self.add_kit_sounds_from_patterns(kit_builder, patterns)
       # Add sounds not defined in Kit section, but used in individual tracks
       patterns.each do |pattern_name, pattern|
         pattern.tracks.each do |track_name, track|
@@ -139,15 +135,14 @@ module Beats
       end
     end
 
-    def add_patterns_to_song(song, kit_builder, raw_patterns)
+    def self.add_patterns_to_song(song, kit_builder, raw_patterns)
       raw_patterns.each do |pattern_name, raw_tracks|
         if raw_tracks.nil?
-          # TODO: Use correct capitalization of pattern name in error message
           # TODO: Possibly allow if pattern not referenced in the Flow, or has 0 repeats?
           raise ParseError, "Pattern '#{pattern_name}' has no tracks. It needs at least one."
         end
 
-        new_pattern = song.pattern(pattern_name.to_sym)
+        tracks = []
 
         raw_tracks.each do |raw_track|
           track_names = raw_track.keys.first
@@ -158,7 +153,7 @@ module Beats
 
           track_names = Array(track_names)
           if track_names.empty?
-            raise ParseError, "Pattern '#{pattern_name}' has an empty composite pattern (i.e. \"[]\"), which is not valid."
+            raise ParseError, "Pattern '#{pattern_name}' uses an empty composite sound (i.e. \"[]\"), which is not valid."
           end
 
           track_names.map! do |track_name|
@@ -170,17 +165,19 @@ module Beats
           track_names.flatten!
 
           track_names.each do |track_name|
-            new_pattern.track track_name, rhythm
+            tracks << Track.new(track_name, rhythm)
           end
         end
+
+        song.pattern(pattern_name.downcase.to_sym, tracks)
       end
     end
 
 
-    def set_song_flow(song, raw_flow)
+    def self.set_song_flow(song, raw_flow)
       flow = []
 
-      raw_flow.each{|pattern_item|
+      raw_flow.each do |pattern_item|
         if pattern_item.class == String
           pattern_item = {pattern_item => "x1"}
         end
@@ -203,19 +200,20 @@ module Beats
             # 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 flow with "x0" repeats.
             # This can be convenient for defining the flow before all patterns have been added to the song file.
-            raise ParseError, "Song flow includes non-existent pattern: #{pattern_name}."
+            raise ParseError, "Song flow includes non-existent pattern: '#{pattern_name}'"
           end
         end
 
         multiples.times { flow << pattern_name_sym }
-      }
+      end
+
       song.flow = flow
     end
 
 
     # Converts all hash keys to be lowercase
-    def downcase_hash_keys(hash)
-      return hash.inject({}) do |new_hash, pair|
+    def self.downcase_hash_keys(hash)
+      hash.inject({}) do |new_hash, pair|
           new_hash[pair.first.downcase] = pair.last
           new_hash
       end

data/lib/beats/track.rb

@@ -5,38 +5,35 @@ module Beats
   # 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
-    class InvalidRhythmError < RuntimeError; end
+    class InvalidRhythmError < ArgumentError; end
 
     REST = "."
     BEAT = "X"
     BARLINE = "|"
     SPACE = " "
-    DISALLOWED_CHARACTERS = /[^X\.]/   # I.e., anything not an 'X' or a '.'
+    DISALLOWED_CHARACTERS = /[^X\.| ]/   # I.e., anything not an 'X', '.', '|', or ' '
 
     def initialize(name, rhythm)
-      @name = name
-      self.rhythm = rhythm
-    end
+      unless name.is_a?(String)
+        raise ArgumentError, "Track name '#{name.inspect}' is invalid, must be a String"
+      end
 
-    def rhythm=(rhythm)
-      @rhythm = rhythm.delete(BARLINE)
-      @rhythm = @rhythm.delete(SPACE)
-      @trigger_step_lengths = calculate_trigger_step_lengths
-    end
+      unless rhythm.is_a?(String) && rhythm.match(DISALLOWED_CHARACTERS) == nil
+        raise InvalidRhythmError, "Track '#{name}' has an invalid rhythm: '#{rhythm.inspect}'. Can only contain '#{BEAT}', '#{REST}', '#{BARLINE}', or ' '"
+      end
 
-    def step_count
-      @rhythm.length
+      @name = name.dup.freeze
+      @rhythm = rhythm.delete(BARLINE + SPACE).freeze
+
+      @step_count = @rhythm.length
+      @trigger_step_lengths = calculate_trigger_step_lengths.freeze
     end
 
-    attr_reader :name, :rhythm, :trigger_step_lengths
+    attr_reader :name, :rhythm, :step_count, :trigger_step_lengths
 
     private
 
     def calculate_trigger_step_lengths
-      if @rhythm.match(DISALLOWED_CHARACTERS)
-        raise InvalidRhythmError, "Track #{@name} has an invalid rhythm: '#{rhythm}'. Can only contain '#{BEAT}', '#{REST}', '#{BARLINE}', or ' '"
-      end
-
       trigger_step_lengths = @rhythm.scan(/X?\.*/)[0..-2].map(&:length)
       trigger_step_lengths.unshift(0) unless @rhythm.start_with?(REST)
 

data/lib/beats/transforms/song_swinger.rb

@@ -1,19 +1,21 @@
 module Beats
   module Transforms
     class SongSwinger
-      class InvalidSwingRateError < RuntimeError; end
+      class InvalidSwingRateError < ArgumentError; end
 
       def self.transform(song, swing_rate)
         validate_swing_rate(swing_rate)
 
-        song.patterns.values.each do |pattern|
-          pattern.tracks.values.each do |track|
+        song.patterns.each do |pattern_name, pattern|
+          swung_tracks = pattern.tracks.map do |track_name, track|
             if swing_rate == 8
-              track.rhythm = swing_8(track.rhythm)
+              Track.new(track.name, swing_8(track.rhythm))
             elsif swing_rate == 16
-              track.rhythm = swing_16(track.rhythm)
+              Track.new(track.name, swing_16(track.rhythm))
             end
           end
+
+          song.patterns[pattern_name] = Pattern.new(pattern_name, swung_tracks)
         end
 
         song.tempo *= 1.5

data/lib/wavefile/{cachingwriter.rb → caching_writer.rb}

@@ -3,7 +3,7 @@ module WaveFile
   # If the Buffer is written again, it will write the version from cache instead of re-doing
   # a String.pack() call.
   class CachingWriter < Writer
-    def initialize(file_name, format)
+    def initialize(io_or_file_name, format)
       super
 
       @buffer_cache = {}
@@ -25,7 +25,7 @@ module WaveFile
           data = samples.pack(@pack_code)
         end
 
-        packed_buffer_data = { :data => data, :sample_count => samples.length }
+        packed_buffer_data = { data: data, sample_count: samples.length }
         @buffer_cache[key] = packed_buffer_data
       end
 

data/test/{audioengine_test.rb → audio_engine_test.rb}

@@ -27,12 +27,11 @@ class AudioEngineTest < Minitest::Test
   def load_fixtures
     test_engines = {}
     base_path = File.dirname(__FILE__) + "/.."
-    song_parser = SongParser.new
 
     test_engines[:blank] = AudioEngine.new(Song.new, KitBuilder.new(base_path).build_kit)
 
     FIXTURES.each do |fixture_name|
-      song, kit = song_parser.parse(base_path, File.read("test/fixtures/valid/#{fixture_name}.txt"))
+      song, kit = SongParser.parse(base_path, File.read("test/fixtures/valid/#{fixture_name}.txt"))
       test_engines[fixture_name] = AudioEngine.new(song, kit)
     end
 
@@ -92,24 +91,24 @@ class AudioEngineTest < Minitest::Test
       # 1.) Tick sample length is equal to the length of the sound sample data.
       #     When this is the case, overflow should never occur.
       #     In practice, this will probably not occur often, but these tests act as a form of sanity check.
-      helper_generate_track_sample_data kit, "",       4, []
-      helper_generate_track_sample_data kit, "X",      4, s
-      helper_generate_track_sample_data kit, "X.",     4, s + te
-      helper_generate_track_sample_data kit, ".X",     4, te + s
-      helper_generate_track_sample_data kit, "...X.",  4, (te * 3) + s + te
-      helper_generate_track_sample_data kit, ".X.XX.", 4, te + s + te + s + s + te
-      helper_generate_track_sample_data kit, "...",    4, te * 3
+      helper_generate_track_sample_data(kit, "",       4, [])
+      helper_generate_track_sample_data(kit, "X",      4, s)
+      helper_generate_track_sample_data(kit, "X.",     4, s + te)
+      helper_generate_track_sample_data(kit, ".X",     4, te + s)
+      helper_generate_track_sample_data(kit, "...X.",  4, (te * 3) + s + te)
+      helper_generate_track_sample_data(kit, ".X.XX.", 4, te + s + te + s + s + te)
+      helper_generate_track_sample_data(kit, "...",    4, te * 3)
 
       # 2A.) Tick sample length is longer than the sound sample data. This is similar to (1), except that there should
       #     be some extra silence after the end of each trigger.
       #     Like (1), overflow should never occur.
-      helper_generate_track_sample_data kit, "",       6, []
-      helper_generate_track_sample_data kit, "X",      6, sl
-      helper_generate_track_sample_data kit, "X.",     6, sl + tl
-      helper_generate_track_sample_data kit, ".X",     6, tl + sl
-      helper_generate_track_sample_data kit, "...X.",  6, (tl * 3) + sl + tl
-      helper_generate_track_sample_data kit, ".X.XX.", 6, tl + sl + tl + sl + sl + tl
-      helper_generate_track_sample_data kit, "...",    6, (te + ts) * 3
+      helper_generate_track_sample_data(kit, "",       6, [])
+      helper_generate_track_sample_data(kit, "X",      6, sl)
+      helper_generate_track_sample_data(kit, "X.",     6, sl + tl)
+      helper_generate_track_sample_data(kit, ".X",     6, tl + sl)
+      helper_generate_track_sample_data(kit, "...X.",  6, (tl * 3) + sl + tl)
+      helper_generate_track_sample_data(kit, ".X.XX.", 6, tl + sl + tl + sl + sl + tl)
+      helper_generate_track_sample_data(kit, "...",    6, (te + ts) * 3)
 
       # 2B.) Tick sample length is longer than the sound sample data, but not by an integer amount.
       #
@@ -117,22 +116,22 @@ class AudioEngineTest < Minitest::Test
       # Tick:               1,     2,     3,     4,     5,     6
       # Raw:        0.0, 5.83, 11.66, 17.49, 23.32, 29.15, 34.98
       # Quantized:    0,    5,    11,    17,    23,    29,    34
-      helper_generate_track_sample_data kit, "",       5.83, []
-      helper_generate_track_sample_data kit, "X",      5.83, sl[0..4]
-      helper_generate_track_sample_data kit, "X.",     5.83, sl[0..4] + tl
-      helper_generate_track_sample_data kit, ".X",     5.83, tl[0..4] + sl
-      helper_generate_track_sample_data kit, "...X.",  5.83, (z * 17) + sl + tl
-      helper_generate_track_sample_data kit, ".X.XX.", 5.83, tl[0..4] + sl + tl + sl + sl + tl[0..4]
-      helper_generate_track_sample_data kit, "...",    5.83, z * 17
+      helper_generate_track_sample_data(kit, "",       5.83, [])
+      helper_generate_track_sample_data(kit, "X",      5.83, sl[0..4])
+      helper_generate_track_sample_data(kit, "X.",     5.83, sl[0..4] + tl)
+      helper_generate_track_sample_data(kit, ".X",     5.83, tl[0..4] + sl)
+      helper_generate_track_sample_data(kit, "...X.",  5.83, (z * 17) + sl + tl)
+      helper_generate_track_sample_data(kit, ".X.XX.", 5.83, tl[0..4] + sl + tl + sl + sl + tl[0..4])
+      helper_generate_track_sample_data(kit, "...",    5.83, z * 17)
 
       # 3A.) Tick sample length is shorter than the sound sample data. Overflow will now occur!
-      helper_generate_track_sample_data kit, "",       2, [],              []
-      helper_generate_track_sample_data kit, "X",      2, ss,              so
-      helper_generate_track_sample_data kit, "X.",     2, s,               []
-      helper_generate_track_sample_data kit, ".X",     2, ts + ss,         so
-      helper_generate_track_sample_data kit, "...X.",  2, (ts * 3) + s,    []
-      helper_generate_track_sample_data kit, ".X.XX.", 2, ts + s + ss + s, []
-      helper_generate_track_sample_data kit, "...",    2, z * 6,         []
+      helper_generate_track_sample_data(kit, "",       2, [],              [])
+      helper_generate_track_sample_data(kit, "X",      2, ss,              so)
+      helper_generate_track_sample_data(kit, "X.",     2, s,               [])
+      helper_generate_track_sample_data(kit, ".X",     2, ts + ss,         so)
+      helper_generate_track_sample_data(kit, "...X.",  2, (ts * 3) + s,    [])
+      helper_generate_track_sample_data(kit, ".X.XX.", 2, ts + s + ss + s, [])
+      helper_generate_track_sample_data(kit, "...",    2, z * 6,         [])
 
       # 3B.) Tick sample length is shorter than sound sample data, such that a beat other than the final one
       #      would extend past the end of the rhythm if not cut off. Make sure that the sample data array doesn't
@@ -145,13 +144,13 @@ class AudioEngineTest < Minitest::Test
       # Tick:               1,    2,    3,    4,    5,     6
       # Raw:        0.0, 1.83, 3.66, 5.49, 7.32, 9.15, 10.98
       # Quantized:    0,    1,    3,    5,    7,    9,    10
-      helper_generate_track_sample_data kit, "",       1.83,                         []
-      helper_generate_track_sample_data kit, "X",      1.83, s[0..0],                s[1..3]
-      helper_generate_track_sample_data kit, "X.",     1.83, s[0..2],                s[3..3]
-      helper_generate_track_sample_data kit, ".X",     1.83, z + s[0..1],            s[2..3]
-      helper_generate_track_sample_data kit, "...X.",  1.83, (z * 5) + s,            []
-      helper_generate_track_sample_data kit, ".X.XX.", 1.83, z + s + ss + s[0..2],   s[3..3]
-      helper_generate_track_sample_data kit, "...",    1.83, z * 5,                  []
+      helper_generate_track_sample_data(kit, "",       1.83,                         [])
+      helper_generate_track_sample_data(kit, "X",      1.83, s[0..0],                s[1..3])
+      helper_generate_track_sample_data(kit, "X.",     1.83, s[0..2],                s[3..3])
+      helper_generate_track_sample_data(kit, ".X",     1.83, z + s[0..1],            s[2..3])
+      helper_generate_track_sample_data(kit, "...X.",  1.83, (z * 5) + s,            [])
+      helper_generate_track_sample_data(kit, ".X.XX.", 1.83, z + s + ss + s[0..2],   s[3..3])
+      helper_generate_track_sample_data(kit, "...",    1.83, z * 5,                  [])
     end
   end
 
@@ -168,15 +167,19 @@ class AudioEngineTest < Minitest::Test
   end
 
   def test_composite_pattern_tracks
-    no_overflow_pattern = Pattern.new("no_overflow")
-    no_overflow_pattern.track "S",  "X..."
-    no_overflow_pattern.track "SO", "X.X."
-    no_overflow_pattern.track "S",  "X.XX"
-
-    overflow_pattern = Pattern.new("overflow")
-    overflow_pattern.track "S",  "X..X"
-    overflow_pattern.track "SO", "XX.X"
-    overflow_pattern.track "SL", ".X.X"
+    no_overflow_tracks = [
+      Track.new("S",  "X..."),
+      Track.new("SO", "X.X."),
+      Track.new("S",  "X.XX"),
+    ]
+    no_overflow_pattern = Pattern.new("no_overflow", no_overflow_tracks)
+
+    overflow_tracks = [
+      Track.new("S",  "X..X"),
+      Track.new("SO", "XX.X"),
+      Track.new("SL", ".X.X"),
+    ]
+    overflow_pattern = Pattern.new("overflow", overflow_tracks)
 
 
     # Simple case, no overflow (stereo)