mr_eko 0.3.4 → 0.4.1

data/Rakefile

@@ -1,7 +1,8 @@
 require 'rubygems'
 require 'rake'
 require 'date'
-# require "bundler"
+require "yard"
+
 #############################################################################
 #
 # Helper functions
@@ -63,20 +64,14 @@ task :coverage do
   sh "open coverage/index.html"
 end
 
-require 'rdoc/task'
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "#{name} #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
 #############################################################################
 #
 # Custom tasks (add your own tasks here)
 #
 #############################################################################
-
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb','README.md']   # optional
+end
 
 
 #############################################################################

data/db/migrate/05_remove_fades_from_song.rb

@@ -0,0 +1,15 @@
+class AddCodeToSongs < Sequel::Migration
+  def up
+    alter_table(:songs) do
+      drop_column :fade_in
+      drop_column :fade_out
+    end
+  end
+
+  def down
+    alter_table(:songs) do
+      add_column :fade_in, Float
+      add_column :fade_out, Float
+    end
+  end
+end

data/db/migrate/06_add_song_position.rb

@@ -0,0 +1,16 @@
+class AddSongPosition < Sequel::Migration
+  def up
+    alter_table(:playlists_songs) do
+      add_column :position, Integer
+    end
+
+    rename_table :playlists_songs, :playlist_entries
+  end
+
+  def down
+    alter_table(:playlists_songs) do
+      drop_column :position
+    end
+    rename_table :playlist_entries, :playlists_songs
+  end
+end

data/lib/mr_eko/exceptions.rb

@@ -0,0 +1,11 @@
+module MrEko
+
+  class NoSongsError < Exception; end
+
+  class EnmfpError < Exception; end
+
+  class InvalidAttributes < Exception; end
+
+end
+
+

data/lib/mr_eko/ext/array.rb

@@ -0,0 +1,24 @@
+class Array
+
+  # Ripped from ActiveSupport
+  def in_groups_of(number, fill_with = nil)
+    if fill_with == false
+      collection = self
+    else
+      # size % number gives how many extra we have;
+      # subtracting from number gives how many to add;
+      # modulo number ensures we don't add group of just fill.
+      padding = (number - size % number) % number
+      collection = dup.concat([fill_with] * padding)
+    end
+
+    if block_given?
+      collection.each_slice(number) { |slice| yield(slice) }
+    else
+      [].tap do |groups|
+        collection.each_slice(number) { |group| groups << group }
+      end
+    end
+  end
+
+end

data/lib/mr_eko/playlist.rb

@@ -3,10 +3,8 @@ class MrEko::Playlist < Sequel::Model
   include MrEko::Core
   include MrEko::Presets
 
-  class NoSongsError < Exception; end
-
   plugin :validation_helpers
-  many_to_many :songs
+  many_to_many :songs, :join_table => :playlist_entries, :order => :playlist_entries__position.asc
   FORMATS = [:pls, :m3u, :text].freeze
   DEFAULT_OPTIONS = [ {:tempo => 0..500}, {:duration => 10..1200} ].freeze
 
@@ -25,7 +23,7 @@ class MrEko::Playlist < Sequel::Model
         songs.each{ |song| pl.add_song(song) }
         pl.save
       else
-        raise NoSongsError.new("No songs match those criteria!")
+        raise MrEko::NoSongsError.new("No songs match those criteria!")
       end
     end
   end
@@ -128,5 +126,3 @@ class MrEko::Playlist < Sequel::Model
     "TBD"
   end
 end
-
-MrEko::Playlist.plugin :timestamps

data/lib/mr_eko/playlist_entry.rb

@@ -0,0 +1,4 @@
+class MrEko::PlaylistEntry < Sequel::Model
+  many_to_one :playlists
+  many_to_one :songs
+end

data/lib/mr_eko/song.rb

@@ -2,12 +2,10 @@
 class MrEko::Song < Sequel::Model
   include MrEko::Core
   plugin :validation_helpers
-  many_to_many :playlists
+  many_to_many :playlists, :through => :playlist_entries
 
   REQUIRED_ID3_TAGS = [:artist, :title]
 
-  class EnmfpError < Exception; end
-
   # A wrapper which gets called by the bin file.
   # By default will try to extract the needed song info from the ID3 tags and
   # if fails, will analyze via ENMFP/upload.
@@ -46,7 +44,7 @@ class MrEko::Song < Sequel::Model
     begin
       fingerprint_json = enmfp_data(filename, md5)
       profile = identify_from_enmfp_data(fingerprint_json)
-    rescue EnmfpError => e
+    rescue MrEko::EnmfpError => e
       log %Q{Issues using ENMFP data "(#{e})" #{e.backtrace.join("\n")}}
       analysis, profile = get_datapoints_by_upload(filename)
     end
@@ -115,13 +113,11 @@ class MrEko::Song < Sequel::Model
       song.echonest_id    = analysis.id
       song.title          = tags.title
       song.artist         = tags.artist
+      song.album          = tags.album
       song.danceability   = analysis.audio_summary.danceability
       song.energy         = analysis.audio_summary.energy
       # XXX: Won't have these from tags - worth getting from EN?
       # song.code           = fingerprint_json.code
-      # song.album          = album
-      # song.fade_in        = analysis.end_of_fade_in
-      # song.fade_out       = analysis.start_of_fade_out
       # XXX: ID3Lib doesn't return these - worth parsing?
       # song.bitrate        =  profile.bitrate
     end if analysis
@@ -153,11 +149,11 @@ class MrEko::Song < Sequel::Model
       hash.raw_data = raw_json
 
       if hash.keys.include?('error')
-        raise EnmfpError, "Errors returned in the ENMFP fingerprint data: #{hash.error.inspect}"
+        raise MrEko::EnmfpError, "Errors returned in the ENMFP fingerprint data: #{hash.error.inspect}"
       end
 
     rescue JSON::ParserError => e
-      raise EnmfpError, e.message
+      raise MrEko::EnmfpError, e.message
     end
 
     hash
@@ -206,7 +202,7 @@ class MrEko::Song < Sequel::Model
     end
 
     profile = MrEko.nest.song.identify(identify_options)
-    raise EnmfpError, "Nothing returned from song/identify API call" if profile.songs.empty?
+    raise MrEko::EnmfpError, "Nothing returned from song/identify API call" if profile.songs.empty?
 
     profile.songs.first
   end
@@ -227,7 +223,7 @@ class MrEko::Song < Sequel::Model
     REQUIRED_ID3_TAGS.each do |rt|
       decoded = begin
         ic.iconv(tags.send(rt))
-      rescue Iconv::InvalidCharacter
+      rescue Iconv::InvalidCharacter, Iconv::IllegalSequence
         tags.send(rt)
       end
       decoded = nil if decoded.blank?
@@ -237,5 +233,3 @@ class MrEko::Song < Sequel::Model
     tags
   end
 end
-
-MrEko::Song.plugin :timestamps

data/lib/mr_eko/timed_playlist.rb

@@ -1,154 +1,109 @@
-class MrEko::TimedPlaylist
-
-  #
-  attr_reader :songs
+class MrEko::TimedPlaylist < MrEko::Playlist
 
   # The number of seconds the playlist should be.
-  attr_reader :length
-
-  attr_reader :name
-
-  # The hash which holds all the controlling parameters for the Playlist.
-  attr_reader :attributes
+  attr_accessor :length
 
-  # Hash keyed by the attribute w/ a value of the number of steps to reach the
-  # final setting.
-  attr_reader :step_map
-
-  class InvalidAttributes < Exception; end
+  # The name of the Song attribute to build on (tempo, key, etc.).
+  attr_accessor :facet
 
+  # The start and end value for the facet
+  attr_accessor :initial, :final
 
   def initialize(opts={})
-    @attributes = Hash.new{ |hsh, key| hsh[key] = {} }
-    @step_map   = Hash.new
-    @songs = []
-
-    handle_opts(opts)
-
-    yield self if block_given?
+    @facet = opts.delete(:facet)
+    @length = opts.delete(:length)
 
+    super
   end
 
-  def save
-    validate_attributes
-    determine_steps
-    find_songs
+  # Have to add songs after save due to the Playlist needing to have a primary
+  # key (generated at time of save). Lame.
+  def after_save
+    prepare_attributes
+    find_song_groups!
 
-    self
-  end
-
-  def initial(opt, value)
-    add_attribute(:initial, opt, value)
-  end
+    songs = @song_groups.sort_by{ |group| cost_of group }.first
 
-  def final(opt, value)
-    add_attribute(:final, opt, value)
-  end
+    # Sort em
+    direction = final - initial > 0 ? :asc : :desc
+    songs = songs.sort_by(&facet)
+    songs = songs.reverse if direction == :desc
 
-  def static(opt, value)
-    add_attribute(:static, opt, value)
+    songs.each_with_index do |song, position|
+      MrEko::PlaylistEntry.create(:playlist_id => self.id, :song_id => song.id, :position => position)
+    end
   end
 
-
   private
 
-  def handle_opts(opts)
-    @length = opts.delete(:length)
-    @name   = opts.delete(:name)
-  end
+  def prepare_attributes
+    unless initial && final
+      raise MrEko::InvalidAttributes, "You must provide values for both the initial and final settings, not just one."
+    end
 
-  def add_attribute(att_type, opt, value)
-    attributes[att_type][opt] = value
+    case facet
+    when :danceability, :energy
+      @initial = (intial * 10).round
+      @final = (final * 10).round
+    when :mode
+      @initial = MrEko.mode_lookup(initial)
+      @final = MrEko.mode_lookup(final)
+    when :key
+      @initial = MrEko.key_lookup(initial)
+      @final = MrEko.key_lookup(final)
+    end
   end
 
-  def validate_attributes
-    init_atts  = attributes[:initial]
-    final_atts = attributes[:final]
+  def find_song_groups!(iterations=50)
+
+    sorted = [initial, final].sort
+    # Get every song in the required range
+    all_songs = MrEko::Song.where({facet => Range.new(*sorted)} & ~{:duration => nil}).all
+    raise MrEko::NoSongsError, "no songs with those '#{facet}' parameters" if all_songs.blank?
+
+    # Populate a number of potential playlists
+    @song_groups = Array.new(iterations) do
+      seconds_used = 0
+      group = []
+      until seconds_used >= @length do
+        random_index = rand(all_songs.length - 1)
+        song = all_songs.delete_at(random_index)
+        seconds_used += song.duration
+        group << song
+      end
 
-    unless init_atts.keys.map(&:to_s).sort == final_atts.keys.map(&:to_s).sort
-      raise InvalidAttributes, "You must provide values for both the initial and final settings, not just one."
+      group
     end
+
   end
 
-  def determine_steps
+  private
 
-    attributes[:initial].each_pair do |attr, val|
+  # How bad is the passed group of songs with respect to the TimedPlaylist's
+  # facet and length contraints?
+  #
+  # @param [Array<MrEko::Song>] the songs
+  # @return [Float] the score - the lower, the better
+  def cost_of(song_group)
 
-      denominator = case attr
-      when :tempo, :loudness
-        attributes[:final][attr] - attributes[:initial][attr]
-      when :danceability, :energy
-        ( ( attributes[:final][attr] - attributes[:initial][attr] ) * 10 ).round
-      when :mode
-        2
-      when :key
-        MrEko.key_lookup(attributes[:final][attr]) - MrEko.key_lookup(attributes[:initial][attr])
-      end
+    # Make sure we're sorted by the facet
+    song_group.sort!{ |a,b| a[facet] <=> b[facet] }
 
-      step_length = @length.to_f / denominator
-      step_length = 4.minutes if step_length.in_minutes < 4
+    first_song_distance_to_target = song_group.first[facet] - initial
+    last_song_distance_to_target = final - song_group.last[facet]
 
-      step_map[attr] = [denominator, step_length.round]
+    # Calculate the facet differences between each song
+    diffs = []
+    song_group.in_groups_of(2) do |x,y|
+      diffs << ( (x.nil? || y.nil?) ? 0 : x[facet] - y[facet])
     end
 
-    step_map
-  end
+    diff_cost = diffs.inject(0){ |sum, n| sum + n }.abs
 
-  # XXX Just sketching this part out at the moment...
-  # needs tests and to work with attributes other than tempo!
-  def find_songs
-    step_count, step_length = step_map[:tempo]
-    return unless step_count && step_length
-    direction = step_count > 0 ? :asc : :desc
-    sorted_tempos = [attributes[:initial][:tempo], attributes[:final][:tempo]].sort
-    tempo_range = Range.new(*sorted_tempos)
-    all_songs = MrEko::Song.where({:tempo => tempo_range} & ~{:duration => nil}).order("tempo #{direction}".lit).all
-
-    songs_to_examine_per_step = step_count > all_songs.size ? 1 : all_songs.size / step_count
-
-    overall_seconds_used = 0
-    all_songs.each_slice(songs_to_examine_per_step).each do |step_songs|
-      break if overall_seconds_used >= @length
-
-      song_length_proximity = 0
-      length_map = step_songs.inject({}) do |hsh, song|
-        song_length_proximity = (song.duration - step_length).abs
-        hsh[song_length_proximity] = song
-        hsh
-      end
-
-      step_seconds_used = 0
-      song_set = []
-      length_map.sort_by{ |key, song| key }.each do |length, song|
-        song_set << song
-        step_seconds_used += song.duration
-        overall_seconds_used += song.duration
-        break if step_seconds_used >= step_length
-      end
+    # Penalty if the playlist is 20% longer than it should be
+    total_length = song_group.inject(0.0){ |sum, song| sum + song.duration }
+    length_penalty = total_length / @length > 0.20 ? 1.25 : 1
 
-      # Make sure the songs are added the required order as they have been
-      # sorted by duration and thus may be in an odd order.
-      song_set = direction == :asc ? song_set.sort_by(&:tempo) : song_set.sort_by(&:tempo).reverse
-      @songs = @songs + song_set
-    end
-    # Might need to make a cluster map here instead of just choosing enough
-    # songs to fulfill the step_length.  This is because the
-    # Playlist#length can be fulfilled even before we reach the target/final
-    # target.  I think a better rule would be to pluck a song having the
-    # initial and final values and then try to evenly spread out the remaining
-    # time with the songs in the middle...hence the map of the clusters of
-    # songs.  Then we can make selections more intelliegently.
-
-    @songs
+    (first_song_distance_to_target + last_song_distance_to_target + diff_cost) * length_penalty
   end
 end
-
-# @length = 3600 # 1hr
-# tempo range 20bpm
-#
-# get count of all songs with the params, eg: tempo => 120..140
-# => 100
-
-# so take 100songs / 20steps = 5 songs per step
-# out of the first 5 songs, select 3min worth using the first
-

data/lib/mr_eko.rb

@@ -19,7 +19,7 @@ EKO_ENV = ENV['EKO_ENV'] || 'development'
 Sequel.default_timezone = :utc
 
 module MrEko
-  VERSION = '0.3.4'
+  VERSION = '0.4.1'
   USER_DIR = File.join(ENV['HOME'], ".mreko")
   FINGERPRINTS_DIR = File.join(USER_DIR, 'fingerprints')
   LOG_DIR = File.join(USER_DIR, 'logs')
@@ -126,10 +126,13 @@ end
 
 MrEko.setup!
 
-require "mr_eko/ext/numeric"
-require "mr_eko/ext/object"
+Dir.glob('lib/mr_eko/ext/*.rb').each do |f|
+  require f
+end
+require "mr_eko/exceptions"
 require "mr_eko/core"
 require "mr_eko/presets"
 require "mr_eko/playlist"
 require "mr_eko/timed_playlist"
 require "mr_eko/song"
+require "mr_eko/playlist_entry"

data/mr_eko.gemspec

@@ -13,8 +13,8 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'mr_eko'
-  s.version           = '0.3.4'
-  s.date              = '2011-12-02'
+  s.version           = '0.4.1'
+  s.date              = '2012-01-01'
   s.rubyforge_project = 'mr_eko'
 
   ## Make sure your summary is short. The description may be as long
@@ -61,6 +61,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency("ruby-debug")
   s.add_development_dependency("autotest")
   s.add_development_dependency("pry")
+  s.add_development_dependency("yard")
 
   ## Leave this section as-is. It will be automatically generated from the
   ## contents of your Git repository via the gemspec task. DO NOT REMOVE
@@ -76,6 +77,8 @@ Gem::Specification.new do |s|
     db/migrate/002_add_songs.rb
     db/migrate/003_add_useful_song_fields.rb
     db/migrate/04_add_code_to_songs.rb
+    db/migrate/05_remove_fades_from_song.rb
+    db/migrate/06_add_song_position.rb
     ext/enmfp/LICENSE
     ext/enmfp/README
     ext/enmfp/RELEASE_NOTES
@@ -89,9 +92,12 @@ Gem::Specification.new do |s|
     ext/enmfp/old/codegen.windows.exe
     lib/mr_eko.rb
     lib/mr_eko/core.rb
+    lib/mr_eko/exceptions.rb
+    lib/mr_eko/ext/array.rb
     lib/mr_eko/ext/numeric.rb
     lib/mr_eko/ext/object.rb
     lib/mr_eko/playlist.rb
+    lib/mr_eko/playlist_entry.rb
     lib/mr_eko/presets.rb
     lib/mr_eko/song.rb
     lib/mr_eko/timed_playlist.rb

data/test/playlist_test.rb

@@ -20,7 +20,7 @@ class PlaylistTest < Test::Unit::TestCase
 
     should "not create a playlist when there no songs found" do
       assert_equal 0, MrEko::Song.count
-      assert_raise(MrEko::Playlist::NoSongsError){ MrEko::Playlist.create_from_options(@options) }
+      assert_raise(MrEko::NoSongsError){ MrEko::Playlist.create_from_options(@options) }
       assert_equal @playlist_count, MrEko::Playlist.count
     end
 

data/test/song_test.rb

@@ -77,7 +77,7 @@ class SongTest < Test::Unit::TestCase
   context 'catalog_via_enmfp' do
 
     should 'try uploading if the ENMFP fingerprint contains errors' do
-      MrEko::Song.stubs(:enmfp_data).raises(MrEko::Song::EnmfpError)
+      MrEko::Song.stubs(:enmfp_data).raises(MrEko::EnmfpError)
       MrEko::Song.expects(:get_datapoints_by_upload).with(TEST_MP3).returns([stub_everything, stub_everything(:audio_summary => stub_everything, :id => 'yu82')])
       MrEko::Song.catalog_via_enmfp(TEST_MP3)
     end
@@ -90,7 +90,7 @@ class SongTest < Test::Unit::TestCase
 
     should 'try to upload when no songs are returned from the Song#identify call' do
       MrEko::Song.stubs(:enmfp_data).returns(enmfp_data_stub)
-      MrEko::Song.expects(:identify_from_enmfp_data).with(enmfp_data_stub).raises(MrEko::Song::EnmfpError.new("no songs"))
+      MrEko::Song.expects(:identify_from_enmfp_data).with(enmfp_data_stub).raises(MrEko::EnmfpError.new("no songs"))
       MrEko::Song.expects(:get_datapoints_by_upload).returns([stub_everything, stub_everything(:audio_summary => stub_everything, :id => 'yu82')])
 
       MrEko::Song.catalog_via_enmfp(TEST_MP3)

data/test/timed_playlist_test.rb

@@ -2,14 +2,10 @@ class TimedPlaylistTest < Test::Unit::TestCase
 
   context 'a new TimedPlaylist' do
 
-    should 'accept a hash of options' do
-      assert MrEko::TimedPlaylist.new(:length => 600, :name => 'whatever')
-    end
-
-    should 'set those options as expected' do
-      pl = MrEko::TimedPlaylist.new(:length => 600, :name => 'Awesome')
+    should 'set the passed options as expected' do
+      pl = MrEko::TimedPlaylist.new(:length => 600, :facet => :tempo)
       assert_equal 600, pl.length
-      assert_equal 'Awesome', pl.name
+      assert_equal :tempo, pl.facet
     end
 
   end
@@ -17,9 +13,9 @@ class TimedPlaylistTest < Test::Unit::TestCase
   context 'initial' do
 
     should 'add the attribute to the list of initial attributes' do
-      MrEko::TimedPlaylist.new(:length => 600, :name => 'sad shit') do |pl|
-        assert pl.initial(:mode, :minor)
-        assert_equal :minor, pl.attributes[:initial][:mode]
+      MrEko::TimedPlaylist.new(:length => 600, :name => 'sad shit', :facet => :mode) do |pl|
+        assert pl.initial = :minor
+        assert_equal :minor, pl.initial
       end
     end
   end
@@ -27,103 +23,35 @@ class TimedPlaylistTest < Test::Unit::TestCase
   context 'final' do
 
     should 'add the attribute to the list of final attributes' do
-      MrEko::TimedPlaylist.new(:length => 200, :name => 'Rock') do |pl|
-        assert pl.final(:tempo, 120)
-        assert_equal 120, pl.attributes[:final][:tempo]
-      end
-    end
-  end
-
-  context 'static' do
-
-    should 'add the attribute to the list of static attributes' do
-      MrEko::TimedPlaylist.new(:length => 1000, :name => 'Bump') do |pl|
-        assert pl.static(:genre, 'HipHop')
-        assert_equal 'HipHop',  pl.attributes[:static][:genre]
+      MrEko::TimedPlaylist.new(:length => 200, :name => 'Rock', :facet => :tempo) do |pl|
+        assert pl.final = 120
+        assert_equal 120, pl.final
       end
     end
   end
 
   context 'save' do
 
-    should 'populate the step_map' do
-      list = MrEko::TimedPlaylist.new(:length => 360) do |pl|
-        pl.initial(:tempo, 100)
-        pl.final(:tempo, 106)
-      end
-
-      assert list.step_map.empty?
-      assert list.save
-      assert !list.step_map.empty?
-    end
-
-    should 'increase the step length to 4.minutes if value is less than that' do
-      list = MrEko::TimedPlaylist.new(:length => 300) do |pl|
-        pl.initial(:tempo, 60)
-        pl.final(:tempo, 80)
-      end
-
-      assert list.save
-      assert_equal [20, 240], list.step_map[:tempo]
-    end
-
-    should 'populate the step_map with the proper mode step data' do
-      list = MrEko::TimedPlaylist.new(:length => 3060) do |pl|
-        pl.initial(:mode, :major)
-        pl.final(:mode, :minor)
-      end
-
-      assert list.save
-      assert_equal [2, 3060.to_f/2], list.step_map[:mode]
-    end
-
-    should 'populate the step_map with the proper tempo and loudness step data' do
-      list = MrEko::TimedPlaylist.new(:length => 3600) do |pl|
-        pl.initial(:tempo, 60)
-        pl.final(:tempo, 70)
-
-        pl.initial(:loudness, -13)
-        pl.final(:loudness, -9)
-      end
-
-      assert list.save
-      assert_equal [10, 3600.to_f/10], list.step_map[:tempo]
-      assert_equal [4, 3600.to_f/4], list.step_map[:loudness]
-    end
+    should 'raise an exception when there are no songs for the parameters' do
 
-    should 'populate the step_map with the proper energy and danceability fractional step data' do
-      list = MrEko::TimedPlaylist.new(:length => 3600) do |pl|
-        pl.initial(:energy, 0.622)
-        pl.final(:energy, 0.888)
+      # No moar songs!
+      MrEko::Song.delete
 
-        pl.initial(:danceability, 0.22)
-        pl.final(:danceability, 0.88)
+      list = MrEko::TimedPlaylist.new(:length => 360, :facet => :tempo) do |pl|
+        pl.initial = 100
+        pl.final = 106
       end
 
-      assert list.save
-      assert_equal [3, (3600.to_f/3).round], list.step_map[:energy]
-      assert_equal [7, (3600.to_f/7).round], list.step_map[:danceability]
+      assert_raises(MrEko::NoSongsError){ list.save }
     end
 
-    should 'populate the step_map with the proper key step data' do
-      list = MrEko::TimedPlaylist.new(:length => 3060) do |pl|
-        pl.initial(:key, 'C#')
-        pl.final(:key, 'A#')
-      end
-
-      step = MrEko.key_lookup('A#') - MrEko.key_lookup('C#')
-      assert list.save
-      assert_equal [step, 3060.to_f/step], list.step_map[:key]
-    end
-
-
     context 'validation' do
       should "raise an exception when initial and final attribute keys don't match" do
-        pl = MrEko::TimedPlaylist.new(:length => 1000) do |pl|
-          assert pl.initial(:tempo, 66)
+        pl = MrEko::TimedPlaylist.new(:length => 1000, :facet => :tempo) do |pl|
+          assert pl.initial = 66
         end
 
-        assert_raise(MrEko::TimedPlaylist::InvalidAttributes){ pl.save }
+        assert_raise(MrEko::InvalidAttributes){ pl.save }
       end
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mr_eko
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 13
   prerelease: 
   segments: 
   - 0
-  - 3
   - 4
-  version: 0.3.4
+  - 1
+  version: 0.4.1
 platform: ruby
 authors: 
 - Ed Hickey
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-02 00:00:00 Z
+date: 2012-01-01 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sequel
@@ -208,6 +208,20 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id013
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id014 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id014
 description: Catalogs music file data and exposes a playlist interface
 email: bassnode@gmail.com
 executables: 
@@ -226,6 +240,8 @@ files:
 - db/migrate/002_add_songs.rb
 - db/migrate/003_add_useful_song_fields.rb
 - db/migrate/04_add_code_to_songs.rb
+- db/migrate/05_remove_fades_from_song.rb
+- db/migrate/06_add_song_position.rb
 - ext/enmfp/LICENSE
 - ext/enmfp/README
 - ext/enmfp/RELEASE_NOTES
@@ -239,9 +255,12 @@ files:
 - ext/enmfp/old/codegen.windows.exe
 - lib/mr_eko.rb
 - lib/mr_eko/core.rb
+- lib/mr_eko/exceptions.rb
+- lib/mr_eko/ext/array.rb
 - lib/mr_eko/ext/numeric.rb
 - lib/mr_eko/ext/object.rb
 - lib/mr_eko/playlist.rb
+- lib/mr_eko/playlist_entry.rb
 - lib/mr_eko/presets.rb
 - lib/mr_eko/song.rb
 - lib/mr_eko/timed_playlist.rb