beats 1.2.3 → 1.2.4

data/LICENSE

@@ -1,6 +1,6 @@
 == BEATS
 
-# Copyright (c) 2010-11 Joel Strait
+# Copyright (c) 2010-12 Joel Strait
 #
 # Permission is hereby granted, free of charge, to any person
 # obtaining a copy of this software and associated documentation

data/README.markdown

@@ -1,66 +1,64 @@
-BEATS Drum Machine
+Beats Drum Machine
 ------------------
 
-BEATS is a command-line drum machine written in pure Ruby. Feed it a song notated in YAML, and it will produce a precision-milled *.wav file of impeccable timing and feel. Here's an example song:
+Beats is a command-line drum machine written in pure Ruby. Feed it a song notated in YAML, and it will produce a precision-milled *.wav file of impeccable timing and feel. Here's an example song:
 
     Song:
-      Tempo: 120
+      Tempo: 105
       Flow:
-        - Verse:   x2
-        - Chorus:  x4
-        - Verse:   x2
-        - Chorus:  x4
+        - Verse:  x4
+        - Chorus: x4
       Kit:
-        - bass:       sounds/bass.wav
-        - snare:      sounds/snare.wav
-        - hh_closed:  sounds/hh_closed.wav
-        - agogo:      sounds/agogo_high.wav
-
+        - bass:     house_2_1.wav
+        - snare:    roland_tr_909_2.wav
+        - hihat:    house_2_5.wav
+        - cowbell:  big_beat_5.wav
+        - deep:     house_2_2.wav  
+    
     Verse:
-      - bass:             X...X...X...X...
-      - snare:            ..............X.
-      - hh_closed:        X.XXX.XXX.X.X.X.
-      - agogo:            ..............XX
-
+      - bass:     X..X...X..X.....
+      - snare:    ....X.......X...
+      - hihat:    ..X...X...X...X.
+    
     Chorus:
-      - bass:             X...X...X...X...
-      - snare:            ....X.......X...
-      - hh_closed:        X.XXX.XXX.XX..X.
-      - sounds/tom4.wav:  ...........X....
-      - sounds/tom2.wav:  ..............X.
+      - bass:     X..X...X..X.....
+      - snare:    ....X.......X...
+      - hihat:    XXXXXXXXXXXXX...
+      - cowbell:  ....XX.X..X.X...
+      - deep:     .............X..
 
-And [here's what it sounds like](http://beatsdrummachine.com/beat.mp3) after getting the BEATS treatment. What a glorious groove!
+And [here's what it sounds like](http://beatsdrummachine.com/media/beat.mp3) after getting the Beats treatment. What a glorious groove!
 
 
 Current Status
 --------------
 
-The latest stable version of BEATS is 1.2.3, released on December 31, 2011. This is a minor release which includes two improvements:
+The latest stable version of Beats is 1.2.4, released on December 22, 2012. This is a minor release which includes two improvements:
 
-* Bug fix: You can now use `~` in sound file paths, and it will correctly expand to your home folder. (At least on UNIX OSes, I'm not sure if that works on Windows).
-* The new `--path` option allows setting the base path from which relative sound file paths are searched for.
+* Now works in MRI 1.9.3
+* Now supports 32-bit PCM Wave files, due to upgrading to WaveFile 0.4.0. Previously, only 8-bit and 16-bit PCM files were supported.
 
 
 Installation
 ------------
 
-To install the latest stable version (1.2.3) from [rubygems.org](http://rubygems.org/gems/beats), run the following from the command line:
+To install the latest stable version (1.2.4) from [rubygems.org](http://rubygems.org/gems/beats), run the following from the command line:
 
     gem install beats
 
 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.
 
-Once installed, you can then run BEATS from the command-line using the `beats` command.
+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).
+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
 -----
 
-BEATS runs from the command-line. Run `beats -h` to see the available options. For more detailed instructions, visit [https://github.com/jstrait/beats/wiki/Usage](https://github.com/jstrait/beats/wiki/Usage) on the [BEATS Wiki](https://github.com/jstrait/beats/wiki).
+Beats runs from the command-line. Run `beats -h` to see the available options. For more detailed instructions, visit [https://github.com/jstrait/beats/wiki/Usage](https://github.com/jstrait/beats/wiki/Usage) on the [Beats Wiki](https://github.com/jstrait/beats/wiki).
 
-The BEATS wiki also has a [Getting Started](https://github.com/jstrait/beats/wiki/Getting-Started) tutorial which shows how to create an example beat from scratch.
+The Beats wiki also has a [Getting Started](https://github.com/jstrait/beats/wiki/Getting-Started) tutorial which shows how to create an example beat from scratch.
 
 
 Found a Bug? Have a Suggestion? Want to Contribute?
@@ -71,5 +69,5 @@ Contact me (Joel Strait) by sending a GitHub message or opening a GitHub issue.
 
 License
 -------
-BEATS is released under the MIT license.
+Beats is released under the MIT license.
 

data/bin/beats

@@ -9,7 +9,7 @@ require "wavefile"
 require "lib/audioengine"
 require "lib/audioutils"
 require "lib/beats"
-require "lib/beatswavefile"
+require "lib/wavefile/cachingwriter"
 require "lib/kit"
 require "lib/pattern"
 require "lib/song"
@@ -18,6 +18,7 @@ require "lib/songparser"
 require "lib/track"
 
 USAGE_INSTRUCTIONS = ""
+YAML::ENGINE.yamler = 'syck' if defined?(YAML::ENGINE)
 
 def parse_options()
   options = {:split => false}

data/lib/audioengine.rb

@@ -24,11 +24,10 @@ class AudioEngine
   def write_to_file(output_file_name)
     packed_pattern_cache = {}
     num_tracks_in_song = @song.total_tracks
-    samples_written = 0
-    
-    # Open output wave file and preparing it for writing sample data.
-    wave_file = BeatsWaveFile.new(@kit.num_channels, SAMPLE_RATE, @kit.bits_per_sample)
-    file = wave_file.open_for_appending(output_file_name)
+ 
+    # Open output wave file and prepare it for writing sample data.
+    format = WaveFile::Format.new(@kit.num_channels, @kit.bits_per_sample, SAMPLE_RATE)
+    writer = WaveFile::CachingWriter.new(output_file_name, format)
 
     # Generate each pattern's sample data, or pull it from cache, and append it to the wave file.
     incoming_overflow = {}
@@ -37,40 +36,22 @@ class AudioEngine
       unless packed_pattern_cache.member?(key)
         sample_data = generate_pattern_sample_data(@song.patterns[pattern_name], incoming_overflow)
 
-        if @kit.num_channels == 1
-          # Don't flatten the sample data Array, since it is already flattened. That would be a waste of time, yo.
-          packed_pattern_cache[key] = {:primary        => sample_data[:primary].pack(PACK_CODE),
-                                       :overflow       => sample_data[:overflow],
-                                       :primary_length => sample_data[:primary].length}
-        else
-          packed_pattern_cache[key] = {:primary        => sample_data[:primary].flatten.pack(PACK_CODE),
-                                       :overflow       => sample_data[:overflow],
-                                       :primary_length => sample_data[:primary].length}
-        end
+        packed_pattern_cache[key] = { :primary => WaveFile::Buffer.new(sample_data[:primary], format),
+                                      :overflow => WaveFile::Buffer.new(sample_data[:overflow], format) }
       end
 
-      file.syswrite(packed_pattern_cache[key][:primary])
-      incoming_overflow = packed_pattern_cache[key][:overflow]
-      samples_written += packed_pattern_cache[key][:primary_length]
+      writer.write(packed_pattern_cache[key][:primary])
+      incoming_overflow = packed_pattern_cache[key][:overflow].samples
     end
 
     # Write any remaining overflow from the final pattern
-    final_overflow_composite = AudioUtils.composite(incoming_overflow.values, @kit.num_channels)
-    final_overflow_composite = AudioUtils.scale(final_overflow_composite, @kit.num_channels, num_tracks_in_song)
-    if @kit.num_channels == 1
-      file.syswrite(final_overflow_composite.pack(PACK_CODE))
-    else
-      file.syswrite(final_overflow_composite.flatten.pack(PACK_CODE))
-    end
-    samples_written += final_overflow_composite.length
-    
-    # Now that we know how many samples have been written, go back and re-write the correct header.
-    file.sysseek(0)
-    wave_file.write_header(file, samples_written)
+    final_overflow_composite = AudioUtils.composite(incoming_overflow.values, format.channels)
+    final_overflow_composite = AudioUtils.scale(final_overflow_composite, format.channels, num_tracks_in_song)
+    writer.write(WaveFile::Buffer.new(final_overflow_composite, format))
 
-    file.close()
+    writer.close()
 
-    return wave_file.calculate_duration(SAMPLE_RATE, samples_written)
+    return WaveFile::Reader.info(output_file_name).duration
   end
 
   attr_reader :step_sample_length

data/lib/beats.rb

@@ -1,5 +1,5 @@
 class Beats
-  BEATS_VERSION = "1.2.3"
+  BEATS_VERSION = "1.2.4"
  
   # 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

data/lib/kit.rb

@@ -37,7 +37,7 @@ class Kit
     @bits_per_sample = 16  # Only use 16-bit files as output. Supporting 8-bit output
                            # means extra complication for no real gain (I'm skeptical
                            # anyone would explicitly want 8-bit output instead of 16-bit).
-                           
+
     load_sounds(base_path, kit_items)
   end
   
@@ -123,17 +123,16 @@ private
     end
     
     kit_items = make_file_names_absolute(kit_items)
-    raw_sounds = load_raw_sounds(kit_items)
+    sound_buffers = load_raw_sounds(kit_items)
     
+    canonical_format = WaveFile::Format.new(@num_channels, @bits_per_sample, 44100)
+
     # Convert each sound to a common format
-    raw_sounds.values.each do |wavefile|
-      wavefile.num_channels = @num_channels
-      wavefile.bits_per_sample = @bits_per_sample
-    end
-    
+    sound_buffers.each {|file_name, buffer| sound_buffers[file_name] = buffer.convert(canonical_format) }
+
     # If necessary, mix component sounds into a composite
     kit_items.each do |label, sound_file_names|
-      @sound_bank[label] = mixdown(sound_file_names, raw_sounds)
+      @sound_bank[label] = mixdown(sound_file_names, sound_buffers)
     end
   end
   
@@ -157,24 +156,26 @@ private
     raw_sounds = {}
     kit_items.values.flatten.each do |sound_file_name|
       begin
-        wavefile = WaveFile.open(sound_file_name)
+        info = WaveFile::Reader.info(sound_file_name)
+        WaveFile::Reader.new(sound_file_name).each_buffer(info.sample_count) do |buffer|
+          raw_sounds[sound_file_name] = buffer
+          @num_channels = [@num_channels, buffer.channels].max
+        end
       rescue Errno::ENOENT
         raise SoundFileNotFoundError, "Sound file #{sound_file_name} not found."
       rescue StandardError
         raise InvalidSoundFormatError, "Sound file #{sound_file_name} is either not a sound file, " +
-                                       "or is in an unsupported format. BEATS can handle 8 or 16-bit *.wav files."
+                                       "or is in an unsupported format. BEATS can handle 8, 16, or 32-bit PCM *.wav files."
       end
-      @num_channels = [@num_channels, wavefile.num_channels].max
-      raw_sounds[sound_file_name] = wavefile
     end
     
     return raw_sounds
   end
   
   def mixdown(sound_file_names, raw_sounds)
-    sample_arrays = []    
+    sample_arrays = []
     sound_file_names.each do |sound_file_name|
-      sample_arrays << raw_sounds[sound_file_name].sample_data
+      sample_arrays << raw_sounds[sound_file_name].samples
     end
 
     composited_sample_data = AudioUtils.composite(sample_arrays, @num_channels)

data/lib/pattern.rb

@@ -31,7 +31,7 @@ class Pattern
   end
   
   def step_count
-    return @tracks.values.collect {|track| track.rhythm.length }.max || 0
+    @tracks.values.collect {|track| track.rhythm.length }.max || 0
   end
   
   # Returns whether or not this pattern has the same number of tracks as other_pattern, and that

data/lib/song.rb

@@ -11,7 +11,7 @@ class InvalidTempoError < RuntimeError; end
 class Song
   DEFAULT_TEMPO = 120
 
-  def initialize()
+  def initialize
     self.tempo = DEFAULT_TEMPO
     @patterns = {}
     @flow = []
@@ -50,10 +50,6 @@ class Song
     @patterns.values.inject([]) {|track_names, pattern| track_names | pattern.tracks.keys }.sort
   end
 
-  def tempo
-    return @tempo
-  end
-
   def tempo=(new_tempo)
     unless new_tempo.class == Fixnum && new_tempo > 0
       raise InvalidTempoError, "Invalid tempo: '#{new_tempo}'. Tempo must be a number greater than 0."
@@ -73,7 +69,7 @@ class Song
   # 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
   # a hash of 5 songs, each with one of the original Song's tracks.
-  def split()
+  def split
     split_songs = {}
     track_names = track_names()
     
@@ -122,7 +118,7 @@ class Song
     return yaml_output
   end
 
-  attr_reader :patterns
+  attr_reader :patterns, :tempo
   attr_accessor :flow
 
 private

data/lib/songoptimizer.rb

@@ -12,7 +12,7 @@
 # Note that step #1 actually performs double duty, because breaking Patterns into smaller
 # pieces increases the likelihood there will be duplicates that can be combined.
 class SongOptimizer
-  def initialize()
+  def initialize
   end
   
   # Returns a Song that will produce the same output as original_song, but should be

data/lib/songparser.rb

@@ -23,7 +23,7 @@ class SongParser
       - Verse: x2
       - Chorus: x2"
   
-  def initialize()
+  def initialize
   end
 
 

data/lib/track.rb

@@ -47,7 +47,7 @@ class Track
   end
   
   def step_count
-    return @rhythm.length
+    @rhythm.length
   end
    
   attr_accessor :name

data/lib/wavefile/cachingwriter.rb

@@ -0,0 +1,36 @@
+module WaveFile
+  # Implementation of Writer that caches the raw wave data for each buffer that it has written.
+  # 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)
+      super
+
+      @buffer_cache = {}
+    end
+
+    def write(buffer)
+      packed_buffer_data = {}
+      
+      key = buffer.hash
+      if @buffer_cache.member?(key)
+        packed_buffer_data = @buffer_cache[key]
+      else
+        samples = buffer.convert(@format).samples
+
+        if @format.channels > 1
+          data = samples.flatten.pack(@pack_code)
+        else
+          # Flattening an already flat array is a waste of time.
+          data = samples.pack(@pack_code)
+        end
+
+        packed_buffer_data = { :data => data, :sample_count => samples.length }
+        @buffer_cache[key] = packed_buffer_data
+      end
+
+      @file.syswrite(packed_buffer_data[:data])
+      @samples_written += packed_buffer_data[:sample_count]
+    end
+  end
+end

data/test/cachingwriter_test.rb

@@ -0,0 +1,63 @@
+require 'includes'
+
+# Makes @file writable so it can be replaced with StringIO for testing
+class StringCachingWriter < WaveFile::CachingWriter
+  attr_writer :file
+end
+
+# Basic tests for CachingWriter; the integration tests test it more thoroughly.
+class CachingWriterTest < Test::Unit::TestCase
+  def test_mono
+    buffer1_bytes = [0, 0, 1, 0, 2, 0]
+    buffer2_bytes = [3, 0, 4, 0, 5, 0]
+
+    format = WaveFile::Format.new(:mono, 16, 44100)
+    writer = StringCachingWriter.new("does_not_matter", format)
+    string_io = StringIO.new
+    writer.file = string_io
+
+    assert_equal(format, writer.format)
+
+    buffer = WaveFile::Buffer.new([0, 1, 2], format)
+    writer.write(buffer)
+    assert_equal(buffer1_bytes, get_bytes(string_io))
+    
+    buffer = WaveFile::Buffer.new([3, 4, 5], format)
+    writer.write(buffer)
+    assert_equal(buffer1_bytes + buffer2_bytes, get_bytes(string_io))
+
+    buffer = WaveFile::Buffer.new([0, 1, 2], format)
+    writer.write(buffer)
+    assert_equal(buffer1_bytes + buffer2_bytes + buffer1_bytes, get_bytes(string_io))
+  end
+
+  def test_stereo
+    buffer1_bytes = [0, 0, 3, 0, 1, 0, 2, 0]
+    buffer2_bytes = [9, 0, 6, 0, 8, 0, 7, 0]
+
+    format = WaveFile::Format.new(:stereo, 16, 44100)
+    writer = StringCachingWriter.new("does_not_matter", format)
+    string_io = StringIO.new
+    writer.file = string_io
+
+    assert_equal(format, writer.format)
+
+    buffer = WaveFile::Buffer.new([[0, 3], [1, 2]], format)
+    writer.write(buffer)
+    assert_equal(buffer1_bytes, get_bytes(string_io))
+
+    buffer = WaveFile::Buffer.new([[9, 6], [8, 7]], format)
+    writer.write(buffer)
+    assert_equal(buffer1_bytes + buffer2_bytes, get_bytes(string_io))
+
+    buffer = WaveFile::Buffer.new([[0, 3], [1, 2]], format)
+    writer.write(buffer)
+    assert_equal(buffer1_bytes + buffer2_bytes + buffer1_bytes, get_bytes(string_io))
+  end
+
+private
+
+  def get_bytes(string_io)
+    string_io.string.each_byte.inject([]) {|arr, element| arr << element }
+  end
+end

data/test/includes.rb

@@ -4,17 +4,19 @@ require 'yaml'
 require 'rubygems'
 
 # External gems
+gem 'wavefile', "=0.4.0"
 require 'wavefile'
 
 # BEATS classes
 require 'audioengine'
 require 'audioutils'
 require 'beats'
-require 'beatswavefile'
+require 'wavefile/cachingwriter'
 require 'kit'
 require 'pattern'
-require 'patternexpander'
 require 'song'
 require 'songparser'
 require 'songoptimizer'
 require 'track'
+
+YAML::ENGINE.yamler = 'syck' if defined?(YAML::ENGINE)

data/test/integration_test.rb

@@ -44,7 +44,7 @@ class IntegrationTest < Test::Unit::TestCase
   
   def run_combined_test(num_channels, bits_per_sample, suffix="", base_path=nil)
     # Make sure no output from previous tests is still around
-    assert_equal([".", ".."], Dir.new(OUTPUT_FOLDER).entries)
+    assert_directory_is_empty OUTPUT_FOLDER
     
     song_fixture         = "test/fixtures/valid/example_#{num_channels}_#{bits_per_sample}#{suffix}.txt"
     actual_output_file   = "#{OUTPUT_FOLDER}/example_combined_#{num_channels}_#{bits_per_sample}#{suffix}.wav"
@@ -77,7 +77,7 @@ class IntegrationTest < Test::Unit::TestCase
   
   def run_split_test(num_channels, bits_per_sample, suffix="", base_path=nil)
     # Make sure no output from previous tests is still around
-    assert_equal([".", ".."], Dir.new(OUTPUT_FOLDER).entries)
+    assert_directory_is_empty OUTPUT_FOLDER
     
     song_fixture         = "test/fixtures/valid/example_#{num_channels}_#{bits_per_sample}#{suffix}.txt"
     actual_output_prefix   = "#{OUTPUT_FOLDER}/example_split_#{num_channels}_#{bits_per_sample}#{suffix}"
@@ -107,6 +107,10 @@ class IntegrationTest < Test::Unit::TestCase
       File.delete(actual_output_file)
     end
   end
+
+  def assert_directory_is_empty dir
+    assert_equal([".", ".."].sort, Dir.new(dir).entries.sort)
+  end
   
   def clean_output_folder()
     # Make the folder if it doesn't already exist

metadata

@@ -1,55 +1,57 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: beats
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 1.2.4
   prerelease: 
-  version: 1.2.3
 platform: ruby
-authors: 
+authors:
 - Joel Strait
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-01-01 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: wavefile
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - "="
-      - !ruby/object:Gem::Version 
-        version: 0.3.0
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.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.
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+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: joel dot strait at Google's popular web mail service
-executables: 
+executables:
 - beats
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - LICENSE
 - README.markdown
 - Rakefile
 - lib/audioengine.rb
 - lib/audioutils.rb
 - lib/beats.rb
-- lib/beatswavefile.rb
 - lib/kit.rb
 - lib/pattern.rb
-- lib/patternexpander.rb
 - lib/song.rb
 - lib/songoptimizer.rb
 - lib/songparser.rb
 - lib/track.rb
+- lib/wavefile/cachingwriter.rb
 - bin/beats
-- bin/example_song.wav
 - test/audioengine_test.rb
 - test/audioutils_test.rb
+- test/cachingwriter_test.rb
 - test/fixtures/expected_output/example_combined_mono_16.wav
 - test/fixtures/expected_output/example_combined_mono_8.wav
 - test/fixtures/expected_output/example_combined_stereo_16.wav
@@ -113,7 +115,6 @@ files:
 - test/integration_test.rb
 - test/kit_test.rb
 - test/pattern_test.rb
-- test/patternexpander_test.rb
 - test/song_test.rb
 - test/songoptimizer_test.rb
 - test/songparser_test.rb
@@ -206,34 +207,33 @@ files:
 - test/track_test.rb
 homepage: http://beatsdrummachine.com/
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.13
+rubygems_version: 1.8.24
 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.
-test_files: 
+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.
+test_files:
 - test/audioengine_test.rb
 - test/audioutils_test.rb
+- test/cachingwriter_test.rb
 - test/fixtures/expected_output/example_combined_mono_16.wav
 - test/fixtures/expected_output/example_combined_mono_8.wav
 - test/fixtures/expected_output/example_combined_stereo_16.wav
@@ -297,7 +297,6 @@ test_files:
 - test/integration_test.rb
 - test/kit_test.rb
 - test/pattern_test.rb
-- test/patternexpander_test.rb
 - test/song_test.rb
 - test/songoptimizer_test.rb
 - test/songparser_test.rb
@@ -388,4 +387,3 @@ test_files:
 - test/sounds/tom4_stereo_8.wav
 - test/sounds/tone.wav
 - test/track_test.rb
-has_rdoc: 

data/lib/beatswavefile.rb

@@ -1,73 +0,0 @@
-# Adds some functionality to the WaveFile gem that allows for improved performance. The 
-# use of open_for_appending() allows a wave file to be written to disk in chunks, instead
-# of all at once. This improves performance (and I would assume memory usage) by eliminating
-# the need to store the entire sample data for the song in memory in a giant (i.e. millions
-# of elements) array.
-#
-# I'm not sure these methods in their current form are suitable for the WaveFile gem.
-# If I figure out a better API I might add it to the WaveFile gem in the future, but until
-# then I'm just putting it here. Since BEATS is a stand-alone app and not a re-usable library,
-# I don't think this should be a problem.
-class BeatsWaveFile < WaveFile
-  
-  # Writes the header for the wave file to path, and returns an open File object that
-  # can be used outside the method to append the sample data. WARNING: The header contains
-  # a field for the total number of samples in the file. This number of samples (and exactly
-  # 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, "wb")
-    write_header(file, 0)
-    
-    return file
-  end
-
-  def write_header(file, sample_length)
-    bytes_per_sample = (@bits_per_sample / 8)
-    sample_data_size = sample_length * bytes_per_sample * @num_channels
-
-    # Write the header
-    header = CHUNK_ID
-    header += [HEADER_SIZE + sample_data_size].pack("V")
-    header += FORMAT
-    header += FORMAT_CHUNK_ID
-    header += [SUB_CHUNK1_SIZE].pack("V")
-    header += [PCM].pack("v")
-    header += [@num_channels].pack("v")
-    header += [@sample_rate].pack("V")
-    header += [@byte_rate].pack("V")
-    header += [@block_align].pack("v")
-    header += [@bits_per_sample].pack("v")
-    header += DATA_CHUNK_ID
-    header += [sample_data_size].pack("V")
-
-    file.syswrite(header)
-  end
-  
-  def calculate_duration(sample_rate, total_samples)
-    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
-end

data/lib/patternexpander.rb

@@ -1,111 +0,0 @@
-class InvalidFlowError < RuntimeError; end
-
-# This class is used for an experimental feature that allows specifying repeats inside of
-# individual patterns, instead of the song flow. This feature is currently disabled, so for
-# the time being this class is dead code.
-#
-# TODO: The expand_pattern method in this class should probably be moved to the Pattern class.
-# This class would then go away.
-class PatternExpander
-  BARLINE = "|"
-  TICK = "-"
-  REPEAT_FRAME_REGEX = /:[-]*:[0-9]*/
-  NUMBER_REGEX = /[0-9]+/
-  
-  # TODO: What should happen if flow is longer than pattern?
-  # Either ignore extra flow, or add trailing .... to each track to match up?
-  def self.expand_pattern(flow, pattern)
-    unless self.valid_flow? flow
-      raise InvalidFlowError, "Invalid flow"
-    end
-    
-    flow = flow.delete(BARLINE)
-    
-    # Count number of :
-    # If odd, then there's an implicit : at the beginning of the pattern.
-    # TODO: What if the first character in the flow is already :
-    #       That means repeat the first step twice, right?
-    number_of_colons = flow.scan(/:/).length
-    if number_of_colons % 2 == 1
-      # TODO: What if flow[0] is not '-'
-      flow[0] = ":"  # Make the implicit : at the beginning explicit
-    end
-    
-    repeat_frames = parse_flow_for_repeat_frames(flow)
-    
-    repeat_frames.reverse.each do |frame|
-      pattern.tracks.each do |name, track|
-        range = frame[:range]
-        
-        # WARNING: Don't change the three lines below to:
-        #   track.rhythm[range] = whatever
-        # When changing the rhythm like this, rhythm=() won't be called,
-        # and Track.beats won't be updated as a result.
-        new_rhythm = track.rhythm
-        new_rhythm[range] = new_rhythm[range] * frame[:repeats]
-        track.rhythm = new_rhythm
-      end
-    end
-    
-    return pattern
-  end
-  
-  # TODO: Return more specific info on why flow isn't valid
-  def self.valid_flow?(flow)
-    flow = flow.delete(BARLINE)
-    flow = flow.delete(TICK)
-    
-    # If flow contains any characters other than : and [0-9], it's invalid.
-    if flow.match(/[^:0-9]/) != nil
-      return false
-    end
-    
-    # If flow contains nothing but :, it's always valid.
-    if flow == ":" * flow.length
-      return true
-    end
-    
-    # If flow DOESN'T contain a :, it's not valid.
-    if flow.match(/:/) == nil
-      return false
-    end
-    
-    segments = flow.split(/[0-9]+/)
-    
-    # Ignore first segment
-    segments[1...segments.length].each do |segment|
-      if segment.length % 2 == 1
-        return false
-      end
-    end
-    
-    return true
-  end
-  
-private
-
-  def self.parse_flow_for_repeat_frames(flow)
-    repeat_frames = []
-    lower_bound = 0
-    frame_start_index = flow[lower_bound...flow.length] =~ REPEAT_FRAME_REGEX
-    while frame_start_index != nil do
-      str = flow[lower_bound...flow.length].match(REPEAT_FRAME_REGEX).to_s
-      
-      range_start = lower_bound + frame_start_index
-      range_end = range_start + str.length - 1
-      
-      num_repeats = str.match(NUMBER_REGEX).to_s
-      num_repeats = (num_repeats == "") ? 2 : num_repeats.to_i
-      
-      repeat_frame = {}
-      repeat_frame[:range] = range_start..range_end
-      repeat_frame[:repeats] = num_repeats
-      repeat_frames << repeat_frame
-      
-      lower_bound += frame_start_index + str.length
-      frame_start_index = flow[lower_bound...flow.length] =~ REPEAT_FRAME_REGEX
-    end
-    
-    return repeat_frames
-  end
-end

data/test/patternexpander_test.rb

@@ -1,140 +0,0 @@
-require 'includes'
-
-class PatternExpanderTest < Test::Unit::TestCase  
-  def test_expand_pattern_no_repeats
-    expected_pattern = Pattern.new :verse
-    expected_pattern.track "bass",  "X...X.X."
-    expected_pattern.track "snare", "....X..."
-        
-    # All of these should result in no expansion, since there are no repeats.
-    # In other words, the pattern shouldn't change.
-    # TODO: Add test for when flow is longer than longest track in pattern
-    ["", "|----|----|", "|----", "----:-:1"].each do |flow|
-      actual_pattern = Pattern.new :verse
-      actual_pattern.track "bass",  "|X...|X.X.|"
-      actual_pattern.track "snare", "|....|X...|"
-      actual_pattern = PatternExpander.expand_pattern(flow, actual_pattern)
-      assert(expected_pattern.same_tracks_as?(actual_pattern))
-    end
-  end
-  
-  def test_expand_pattern_single_repeats
-    expected_pattern = Pattern.new :verse
-    expected_pattern.track "bass",  "X...X.X.X...X.X."
-    expected_pattern.track "snare", "....X.......X..."
-    
-    ["|----|---:|", "|----|---:2|", ":------:"].each do |flow|
-      actual_pattern = Pattern.new :verse
-      actual_pattern.track "bass",  "|X...|X.X.|"
-      actual_pattern.track "snare", "|....|X...|"
-      actual_pattern = PatternExpander.expand_pattern(flow, actual_pattern)
-      assert(expected_pattern.same_tracks_as?(actual_pattern))
-    end
-    
-    
-    expected_pattern = Pattern.new :verse
-    expected_pattern.track "bass",  "X...X.X.X.X.X.X.X.X...X."
-    expected_pattern.track "snare", "....X...X...X...X...XXXX"
-    
-    ["|----|:-:4|----|"].each do |flow|
-      actual_pattern = Pattern.new :verse
-      actual_pattern.track "bass",  "|X...|X.X.|..X.|"
-      actual_pattern.track "snare", "|....|X...|XXXX|"
-      actual_pattern = PatternExpander.expand_pattern(flow, actual_pattern)  
-      assert(expected_pattern.same_tracks_as?(actual_pattern))
-    end
-    
-    
-    # Zero repeats, so section gets removed from pattern
-    expected_pattern = Pattern.new :verse
-    expected_pattern.track "bass",  "X.....X."
-    expected_pattern.track "snare", "....XXXX"
-    
-    ["|----|:-:0|----|"].each do |flow|
-      actual_pattern = Pattern.new :verse
-      actual_pattern.track "bass",  "|X...|X.X.|..X.|"
-      actual_pattern.track "snare", "|....|X...|XXXX|"
-      actual_pattern = PatternExpander.expand_pattern(flow, actual_pattern)  
-      assert(expected_pattern.same_tracks_as?(actual_pattern))
-    end
-  end
-  
-  def test_expand_pattern_multiple_repeats
-    expected_pattern = Pattern.new :verse
-    expected_pattern.track "bass",  "X...X...X.X.X.X."
-    expected_pattern.track "snare", "........X...X..."
-    
-    [":--::--:", ":-:2:--:", ":-:2:-:2"].each do |flow|
-      actual_pattern = Pattern.new :verse
-      actual_pattern.track "bass",  "|X...|X.X.|"
-      actual_pattern.track "snare", "|....|X...|"
-      actual_pattern = PatternExpander.expand_pattern(flow, actual_pattern)
-      assert(expected_pattern.same_tracks_as?(actual_pattern))
-    end
-    
-    
-    expected_pattern = Pattern.new :verse
-    expected_pattern.track "bass",  "X...X.X.X.X.X.X..XXX..XX.."
-    expected_pattern.track "snare", "....X...X...X...X...XX..XX"
-    
-    ["----:-:3--:--:", "|----|:-:3|--|:-:2|"].each do |flow|
-      actual_pattern = Pattern.new :verse
-      actual_pattern.track "bass",  "|X...|X.X.|.X|XX..|"
-      actual_pattern.track "snare", "|....|X...|X.|..XX|"
-      actual_pattern = PatternExpander.expand_pattern(flow, actual_pattern)
-      assert(expected_pattern.same_tracks_as?(actual_pattern))
-    end
-  end
-  
-  def test_expand_pattern_invalid
-    pattern = Pattern.new :verse
-    pattern.track "bass",  "|X...|X.X.|"
-    pattern.track "snare", "|....|X...|"
-    
-    # Patterns with an invalid character
-    ["a", "|---!---|", "|....|....|"].each do |invalid_flow|
-      assert_raise(InvalidFlowError) do
-        PatternExpander.expand_pattern(invalid_flow, pattern)
-      end
-    end
-    
-    ["----4:--", ":-:-:4-:", ":4-:-:-:"].each do |invalid_flow|
-      assert_raise(InvalidFlowError) do
-        PatternExpander.expand_pattern(invalid_flow, pattern)
-      end
-    end
-  end
-  
-  def test_valid_flow?
-    # Contains nothing but :, always valid
-    assert_equal(true, PatternExpander.valid_flow?(""))
-    assert_equal(true, PatternExpander.valid_flow?(":"))
-    assert_equal(true, PatternExpander.valid_flow?("::"))
-    assert_equal(true, PatternExpander.valid_flow?(":::"))
-    assert_equal(true, PatternExpander.valid_flow?("::::"))
-    assert_equal(true, PatternExpander.valid_flow?("|:--:|----|:--:|"))
-    
-    # Contains characters other than :|- and [0-9]
-    assert_equal(false, PatternExpander.valid_flow?("a"))
-    assert_equal(false, PatternExpander.valid_flow?("1"))
-    assert_equal(false, PatternExpander.valid_flow?(":--:z---"))
-    assert_equal(false, PatternExpander.valid_flow?(":   :"))
-    
-    assert_equal(true, PatternExpander.valid_flow?(":0"))
-    assert_equal(true, PatternExpander.valid_flow?(":1"))
-    assert_equal(true, PatternExpander.valid_flow?(":4"))
-    assert_equal(true, PatternExpander.valid_flow?(":4"))
-    assert_equal(true, PatternExpander.valid_flow?(":16"))
-    assert_equal(true, PatternExpander.valid_flow?("::4"))
-    assert_equal(true, PatternExpander.valid_flow?(":::4"))
-    assert_equal(true, PatternExpander.valid_flow?(":2::4"))
-    assert_equal(true, PatternExpander.valid_flow?("::2::4"))
-    
-    assert_equal(false, PatternExpander.valid_flow?(":4:"))
-    assert_equal(false, PatternExpander.valid_flow?("::4:"))
-    assert_equal(false, PatternExpander.valid_flow?(":4:4"))
-    assert_equal(false, PatternExpander.valid_flow?("::2:4"))
-    assert_equal(false, PatternExpander.valid_flow?("::2:"))
-    assert_equal(false, PatternExpander.valid_flow?("::2:::"))
-  end
-end