mr_eko 0.2.3

data/lib/mr_eko/playlist.rb

@@ -0,0 +1,100 @@
+class MrEko::Playlist < Sequel::Model
+
+  include MrEko::Core
+  include MrEko::Presets
+
+  class NoSongsError < Exception; end
+
+  plugin :validation_helpers
+  many_to_many :songs
+  FORMATS = [:pls, :m3u, :text]
+
+  # Creates and returns a new Playlist from the passed <tt>options</tt>.
+  # <tt>options</tt> should be finder options you pass to Song plus (optionally) :name.
+  def self.create_from_options(options)
+    # TODO: Is a name (or persisting) even necessary?
+    pl = create(:name => options.delete(:name) || "Playlist #{rand(10000)}")
+    prepare_options!(options)
+
+    songs = MrEko::Song.where(options).all
+    if songs.size > 0
+      songs.each{ |song| pl.add_song(song) }
+      pl.save
+    else
+      pl.delete # TODO: Look into not creating Playlist in the 1st place
+      raise NoSongsError.new("No songs match that criteria!")
+    end
+  end
+
+  # Organize and transform!
+  def self.prepare_options!(options)
+    if preset = options.delete(:preset)
+      options.replace load_preset(preset)
+    else
+      unless options[:tempo].is_a? Range
+        min_tempo = options.delete(:min_tempo) || 0
+        max_tempo = options.delete(:max_tempo) || 500
+        options[:tempo] = min_tempo..max_tempo
+      end
+
+      unless options[:duration].is_a? Range
+        min_duration = options.delete(:min_duration) || 10 # worthless jams
+        max_duration = options.delete(:max_duration) || 1200 # 20 min.
+        options[:duration] = min_duration..max_duration
+      end
+
+      if options.has_key?(:mode)
+        options[:mode] = MrEko.mode_lookup(options[:mode])
+      end
+
+      if options.has_key?(:key)
+        options[:key] = MrEko.key_lookup(options[:key])
+      end
+    end
+  end
+
+  # Return the formatted playlist.
+  def output(format = :pls)
+    format = format.to_sym
+    raise ArgumentError.new("Format must be one of #{FORMATS.join(', ')}") unless FORMATS.include? format
+
+    case format
+    when :pls
+      create_pls
+    when :m3u
+      create_m3u
+    else
+     create_text
+    end
+  end
+
+  # Returns a text representation of the Playlist.
+  def create_text
+    songs.inject("") do |list, song|
+      list << "#{song.filename}, #{song.title}\n"
+    end
+  end
+
+  # Returns a PLS representation of the Playlist.
+  def create_pls
+    pls = "[playlist]\n"
+    pls << "NumberOfEntries=#{songs.size}\n\n"
+
+    i = 0
+    while i < songs.size do
+      num = i+1
+      pls << "File#{num}=#{songs[i].filename}\n"
+      pls << "Title#{num}=#{songs[i].title || songs[i].filename}\n"
+      pls << "Length#{num}=#{songs[i].duration.round}\n\n"
+      i+=1
+    end
+
+    pls << "Version=2"
+  end
+
+  def create_m3u
+    "TBD"
+  end
+end
+
+MrEko::Playlist.plugin :timestamps

data/lib/mr_eko/presets.rb

@@ -0,0 +1,29 @@
+module MrEko::Presets
+  FACTORY = {
+    :gym => {
+      :tempo    => 125..300, # sweat, sweat, sweat!
+      :mode     => 'major',  # bring the HappyHappy
+      :duration => 180..300,  # shorter, poppier tunes
+      :energy   => 0.5..1.0,
+      :danceability => 0.4..1.0
+    },
+    :chill => {
+      :tempo    => 60..120,  # mellow
+      :duration => 180..600, # bring the epic, long-players
+      :energy   => 0.2..0.5,
+      :danceability => 0.1..0.5
+    }
+  }
+
+  module ClassMethods
+
+    def load_preset(name)
+      FACTORY[name.to_sym]
+    end
+
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+end

data/lib/mr_eko/song.rb

@@ -0,0 +1,122 @@
+class MrEko::Song < Sequel::Model
+  include MrEko::Core
+  plugin :validation_helpers
+  many_to_many :playlists
+
+  # IDEA: This probably won't work since it's creating a new file,
+  # but could try uploading a sample of the song (faster).
+  # ffmpeg -y -i mogwai.mp3 -ar 22050 -ac 1 -ss 30 -t 30 output.mp3
+  # or
+  # sox mogwai.mp3 output.mp3 30 60
+
+  # Using the Echonest Musical Fingerprint lib in the hopes
+  # of sidestepping the mp3 upload process.
+  def self.enmfp_data(filename, md5)
+    unless File.exists?(fp_location(md5))
+      log 'Running ENMFP'
+      `#{File.join(MrEko::HOME_DIR, 'ext', 'enmfp', enmfp_binary)} "#{File.expand_path(filename)}" > #{fp_location(md5)}`
+    end
+
+    File.read fp_location(md5)
+  end
+
+  # Return the file path of the EN fingerprint JSON file
+  def self.fp_location(md5)
+    File.expand_path File.join(MrEko::FINGERPRINTS_DIR, "#{md5}.json")
+  end
+
+  # Use the platform-specific binary.
+  def self.enmfp_binary
+    case RUBY_PLATFORM
+    when /darwin/
+      'codegen.Darwin'
+    when /686/
+      'codegen.Linux-i686'
+    when /x86/
+      'codegen.Linux-x86_64'
+    else
+      'codegen.windows.exe'
+    end
+  end
+
+  # Returns the analysis and profile data from Echonest for the given track.
+  def self.get_datapoints_by_filename(filename)
+    analysis = MrEko.nest.track.analysis(filename)
+    profile  = MrEko.nest.track.profile(:md5 => MrEko.md5(filename)).body.track
+
+    return [analysis, profile]
+  end
+
+  # TODO: Cleanup - This method is prety ugly now.
+  def self.create_from_file!(filename)
+    md5 = MrEko.md5(filename)
+    existing = where(:md5 => md5).first
+    return existing unless existing.nil?
+
+    fingerprint_data = enmfp_data(filename, md5)
+    fingerprint_json_data = Hashie::Mash.new(JSON.parse(fingerprint_data).first)
+
+    if fingerprint_json_data.keys.include?('error')
+      analysis, profile = get_datapoints_by_filename(filename)
+    else
+      log "Identifying with ENMFP code"
+      identify_options = {:code => fingerprint_data}
+      identify_options[:artist]   = fingerprint_json_data.metadata.artist  if fingerprint_json_data.metadata.artist
+      identify_options[:title]    = fingerprint_json_data.metadata.title   if fingerprint_json_data.metadata.title
+      identify_options[:release]  = fingerprint_json_data.metadata.release if fingerprint_json_data.metadata.release
+      profile = MrEko.nest.song.identify(identify_options)
+
+      if profile.songs.empty? 
+        # ENMFP wasn't recognized, so upload.
+        log "ENMP returned nothing, uploading"
+        analysis, profile = get_datapoints_by_filename(filename)
+      else
+        begin
+          profile = profile.songs.first
+          analysis = MrEko.nest.song.profile(:id => profile.id, :bucket => 'audio_summary').songs.first.audio_summary
+        rescue Exception => e
+          log "Issues using ENMP data, uploading \"(#{e})\""
+          analysis, profile = get_datapoints_by_filename(filename)
+        end
+      end
+    end
+
+    # TODO: add ruby-mp3info as fallback for parsing ID3 tags
+    # since Echonest seems a bit flaky in that dept.
+    song                = new()
+    song.filename       = File.expand_path(filename)
+    song.md5            = md5
+    song.code           = fingerprint_json_data.code
+    song.tempo          = analysis.tempo
+    song.duration       = analysis.duration
+    song.fade_in        = analysis.end_of_fade_in
+    song.fade_out       = analysis.start_of_fade_out
+    song.key            = analysis.key
+    song.mode           = analysis.mode
+    song.loudness       = analysis.loudness
+    song.time_signature = analysis.time_signature
+    song.echonest_id    = profile.id
+    song.bitrate        = profile.bitrate
+    song.title          = profile.title
+    song.artist         = profile.artist || profile.artist_name
+    song.album          = profile.release
+    song.danceability   = profile.audio_summary? ? profile.audio_summary.danceability : analysis.danceability
+    song.energy         = profile.audio_summary? ? profile.audio_summary.energy       : analysis.energy
+
+    song.save
+  end
+
+  def validate
+    super
+    set_md5 # no Sequel callback for this?
+    validates_unique :md5
+  end
+
+  private
+  def set_md5
+    self.md5 ||= MrEko.md5(filename)
+  end
+
+end
+
+MrEko::Song.plugin :timestamps

data/lib/mr_eko.rb

@@ -0,0 +1,101 @@
+require "rubygems"
+require "bundler"
+Bundler.setup
+
+require "sqlite3"
+require "sequel"
+require "logger"
+require "hashie"
+require "digest/md5"
+require "echonest"
+
+STDOUT.sync = true
+
+EKO_ENV = ENV['EKO_ENV'] || 'development'
+Sequel.default_timezone = :utc
+
+module MrEko
+  VERSION = '0.2.3'
+  USER_DIR = File.join(ENV['HOME'], ".mreko")
+  FINGERPRINTS_DIR = File.join(USER_DIR, 'fingerprints')
+  HOME_DIR = File.join(File.dirname(__FILE__), '..')
+
+  MODES = %w(minor major)
+  CHROMATIC_SCALE = %w(C C# D D# E F F# G G# A A# B).freeze
+
+  class << self
+    attr_accessor :logger
+
+    def env
+      EKO_ENV
+    end
+
+    def connection
+      @connection
+    end
+
+    def nest
+      @nest
+    end
+
+    def md5(filename)
+      Digest::MD5.hexdigest(open(filename).read)
+    end
+
+    def setup!
+      @logger ||= Logger.new(STDOUT)
+      setup_directories!
+      setup_db!
+      setup_echonest!
+    end
+
+    def setup_directories!
+      Dir.mkdir(USER_DIR) unless File.directory?(USER_DIR)
+      Dir.mkdir(FINGERPRINTS_DIR) unless File.directory?(FINGERPRINTS_DIR)
+    end
+
+    def setup_db!
+      return @connection if @connection
+      @connection = Sequel.sqlite(db_name)
+      @connection.loggers << @logger
+    end
+
+    def setup_echonest!
+      @nest ||= Echonest(File.read(api_key))
+    end
+
+    def db_name
+      env == 'test' ? 'db/eko_test.db' : 'db/eko.db'
+    end
+
+    def api_key
+      [File.join(USER_DIR, 'echonest_api.key'), File.join(HOME_DIR, 'echonest_api.key')].each do |file|
+        return file if File.exists?(file)
+      end
+      raise "You need to create an echonest_api.key file in #{USER_DIR}"
+    end
+
+    # Takes 'minor' or 'major' and returns its integer representation.
+    def mode_lookup(mode)
+      MODES.index(mode.downcase)
+    end
+
+    # Takes a chromatic key (eg: G#) and returns its integer representation.
+    def key_lookup(key_letter)
+      CHROMATIC_SCALE.index(key_letter.upcase)
+    end
+
+    # Takes an integer and returns its standard (chromatic) representation.
+    def key_letter(key)
+      CHROMATIC_SCALE[key]
+    end
+  end
+end
+
+
+MrEko.setup!
+
+require "lib/mr_eko/core"
+require "lib/mr_eko/presets"
+require "lib/mr_eko/playlist"
+require "lib/mr_eko/song"

data/mr_eko.gemspec

@@ -0,0 +1,97 @@
+## This is the rakegem gemspec template. Make sure you read and understand
+## all of the comments. Some sections require modification, and others can
+## be deleted if you don't need them. Once you understand the contents of
+## this file, feel free to delete any comments that begin with two hash marks.
+## You can find comprehensive Gem::Specification documentation, at
+## http://docs.rubygems.org/read/chapter/20
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = '1.3.5'
+
+  ## Leave these as is they will be modified for you by the rake gemspec task.
+  ## 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.2.3'
+  s.date              = '2011-02-08'
+  s.rubyforge_project = 'mr_eko'
+
+  ## Make sure your summary is short. The description may be as long
+  ## as you like.
+  s.summary     = "Catalogs music file data and exposes a playlist interface"
+  s.description = "Catalogs music file data and exposes a playlist interface"
+
+  ## List the primary authors. If there are a bunch of authors, it's probably
+  ## better to set the email to an email list or something. If you don't have
+  ## a custom homepage, consider using your GitHub URL or the like.
+  s.authors  = ["Ed Hickey"]
+  s.email    = 'bassnode@gmail.com'
+  s.homepage = 'http://github.com/bassnode/mreko'
+
+  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
+  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
+  s.require_paths = %w[lib]
+
+
+  ## If your gem includes any executables, list them here.
+  s.executables = ["mreko"]
+  s.default_executable = 'mreko'
+
+  ## Specify any RDoc options here. You'll want to add your README and
+  ## LICENSE files to the extra_rdoc_files list.
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[README.md]
+
+  ## List your runtime dependencies here. Runtime dependencies are those
+  ## that are needed for an end user to actually USE your code.
+  s.add_dependency('sequel', "= 3.15")
+  s.add_dependency('sqlite3-ruby', "~> 1.3")
+  s.add_dependency('hashie')
+  s.add_dependency('httpclient', "~> 2.1")
+  s.add_dependency('json', "= 1.4.6")
+
+  ## List your development dependencies here. Development dependencies are
+  ## those that are only needed during development
+  s.add_development_dependency('mocha', "= 0.9.8")
+  s.add_development_dependency('shoulda', "~> 2.11")
+  s.add_development_dependency('test-unit', "~> 2.1")
+  s.add_development_dependency("ruby-debug", "~> 0.10.3")
+  
+  ## Leave this section as-is. It will be automatically generated from the
+  ## contents of your Git repository via the gemspec task. DO NOT REMOVE
+  ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
+  # = MANIFEST =
+  s.files = %w[
+    Gemfile
+    README.md
+    Rakefile
+    TODO
+    bin/mreko
+    db/migrate/001_add_playlists.rb
+    db/migrate/002_add_songs.rb
+    db/migrate/003_add_useful_song_fields.rb
+    db/migrate/04_add_code_to_songs.rb
+    ext/enmfp/LICENSE
+    ext/enmfp/README
+    ext/enmfp/RELEASE_NOTES
+    ext/enmfp/codegen.Darwin
+    ext/enmfp/codegen.Linux-i686
+    ext/enmfp/codegen.Linux-x86_64
+    ext/enmfp/codegen.windows.exe
+    lib/mr_eko.rb
+    lib/mr_eko/core.rb
+    lib/mr_eko/playlist.rb
+    lib/mr_eko/presets.rb
+    lib/mr_eko/song.rb
+    mr_eko.gemspec
+    test/mr_eko_test.rb
+    test/playlist_test.rb
+    test/test.rb
+  ]
+  # = MANIFEST =
+
+  ## Test files will be grabbed from the file list. Make sure the path glob
+  ## matches what you actually use.
+  s.test_files = s.files.select { |path| path =~ /^test\/*_test\.rb/ }
+end

data/test/mr_eko_test.rb

@@ -0,0 +1,25 @@
+class MrEkoTest < Test::Unit::TestCase  
+
+  context "the module" do
+    
+    should "return an Echonest API instance for nest" do
+      assert_instance_of Echonest::Api, MrEko.nest
+    end
+    
+    should "return a Sequel instance for connection" do
+      assert_instance_of Sequel::SQLite::Database, MrEko.connection
+    end
+    
+    # should "raise an error when there is no api.key found" do
+      # File.expects(:exists?).with(File.join(MrEko::USER_DIR, 'echonest_api.key')).returns(false)
+      # File.expects(:exists?).with(File.join(MrEko::HOME_DIR, 'echonest_api.key')).returns(false)
+      # assert_raise(RuntimeError){ MrEko.setup_echonest! }
+    # end
+    
+    should "return the MD5 of the passed filename" do
+      md5 = Digest::MD5.hexdigest(open(__FILE__).read)
+      assert_equal md5, MrEko.md5(__FILE__)
+    end
+  end
+
+end

data/test/playlist_test.rb

@@ -0,0 +1,135 @@
+class PlaylistTest < Test::Unit::TestCase  
+  
+  context "a new playlist" do
+    setup do
+      @playlist = MrEko::Playlist.new
+    end
+    
+    should "have no songs" do
+      assert_equal 0, @playlist.songs.size
+    end
+  end
+  
+  context "create_from_options" do
+    
+    setup do
+      @options = {:tempo => 100..200}
+      MrEko::Song.delete
+      @playlist_count = MrEko::Playlist.count
+    end
+
+    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_equal @playlist_count, MrEko::Playlist.count
+    end
+    
+    should "create a playlist when there are songs found" do
+      assert MrEko::Song.insert(  :tempo => @options[:tempo].max, 
+                                :filename => 'third_eye.mp3',
+                                :artist => 'Tool', 
+                                :title => 'Third Eye',
+                                :md5 => Digest::MD5.hexdigest(Time.now.to_s),
+                                :created_on => Time.now,
+                                :duration => 567
+                              )
+                              
+      assert MrEko::Playlist.create_from_options(@options)
+      assert_equal @playlist_count + 1, MrEko::Playlist.count
+    end
+    
+    should "filter out certain options before querying for songs" do
+      unfiltered_options = {:name => "Rock You in Your Face mix #{rand(1000)}", :time_signature => 4}
+      MrEko::Song.expects(:where).with(Not(has_key(:name))).once.returns(sequel_dataset_stub)
+      assert_raise(MrEko::Playlist::NoSongsError){ MrEko::Playlist.create_from_options(unfiltered_options) }
+    end
+  end 
+  
+  context "prepare_options!" do
+    
+    context "when passed a preset option" do
+      
+      should "only use the presets' options, not the others passed" do
+        opts = { :time_signature => 4, :preset => :gym }
+        MrEko::Playlist.prepare_options!(opts)
+        assert !opts.has_key?(:time_signature)
+        assert_equal MrEko::Presets::FACTORY[:gym][:tempo], opts[:tempo]
+      end
+    end
+    
+    context "for tempo" do
+      
+      should "not transform when tempo is a Range" do
+        opts = {:tempo => 160..180}
+        MrEko::Playlist.prepare_options!(opts)
+        assert_equal 160..180, opts[:tempo]
+      end
+      
+      should "transform even when there aren't any passed tempo opts" do
+        opts = {:time_signature => 4}
+        MrEko::Playlist.prepare_options!(opts)
+        assert opts.has_key? :tempo
+      end
+
+      should "remove min and max keys" do
+        opts = {:min_tempo => 100, :max_tempo => 200}
+        MrEko::Playlist.prepare_options!(opts)
+        assert !opts.has_key?(:min_tempo)
+        assert !opts.has_key?(:max_tempo)
+      end
+      
+      should "create a range with the passed min and max tempos" do
+        opts = {:min_tempo => 100, :max_tempo => 200}
+        MrEko::Playlist.prepare_options!(opts)
+        assert_equal 100..200, opts[:tempo]
+      end
+    end
+    
+    context "for duration" do
+      
+      should "not transform when duration is a Range" do
+        opts = {:duration => 200..2010}
+        MrEko::Playlist.prepare_options!(opts)
+        assert_equal 200..2010, opts[:duration]
+      end
+      
+      should "transform even when there aren't any passed duration opts" do
+        opts = {:time_signature => 4}
+        MrEko::Playlist.prepare_options!(opts)
+        assert opts.has_key? :duration
+      end
+
+      should "remove min and max keys" do
+        opts = {:min_duration => 100, :max_duration => 2000}
+        MrEko::Playlist.prepare_options!(opts)
+        assert !opts.has_key?(:min_duration)
+        assert !opts.has_key?(:max_duration)
+      end
+
+      should "create a range with the passed min and max durations" do
+        opts = {:min_duration => 100, :max_duration => 2000}
+        MrEko::Playlist.prepare_options!(opts)
+        assert_equal 100..2000, opts[:duration]
+      end
+    end
+    
+    context "for mode" do
+      
+      should "transform into numeric representation" do
+        opts = {:mode => 'minor'}
+        MrEko::Playlist.prepare_options!(opts)
+        assert_equal 0, opts[:mode]
+      end
+    end
+
+    context "for key" do
+      
+      should "transform into numeric representation" do
+        opts = {:key => 'C#'}
+        MrEko::Playlist.prepare_options!(opts)
+        assert_equal 1, opts[:key]
+      end
+    end
+
+  end
+end

data/test/test.rb

@@ -0,0 +1,22 @@
+ENV['EKO_ENV'] = 'test'
+require "bundler/setup"
+Bundler.setup
+
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require "mr_eko"
+
+require 'sequel/extensions/migration'
+Sequel::Migrator.apply(MrEko.connection, File.join(File.dirname(__FILE__), "..", "db", "migrate"))
+
+class Test::Unit::TestCase
+  
+  # Could be fleshed out some more.
+  def sequel_dataset_stub
+    data = mock()
+    data.stubs(:all).returns( [] )
+    data
+  end
+
+end