shroom 0.0.10 → 0.0.11

data/lib/sh_database.rb

@@ -1,207 +1,196 @@
 require 'rubygems'
 require 'sequel'
-require 'sh_song'
-require 'sh_album'
-require 'sh_artist'
+require 'sh_tagreader'
+require 'sh_fingerprint'
 
 module Sh
   class Database
-    def initialize
-      @db = Sequel.sqlite(Sh::Global::PATHS[:db_file])
-
-      @db.create_table :artists do
-        primary_key :id
-        String :mbid
-        String :name
-        String :image_path
-        String :info
-      end unless @db.table_exists? :artists
+    def self.load
+      @@db = Sequel.sqlite(Global::PATHS[:db_file])
+
+      unless @@db.table_exists? :artists
+        @@db.create_table :artists do
+          primary_key :id
+          String :mbid
+          String :name
+          String :image_path
+          String :info
+        end
+        @@db[:artists].insert(:id => 1, :name => "Unknown Artist")
+        @@db[:artists].insert(:id => 2, :name => "Various Artists")
+      end
 
-      @db.create_table :albums do
-        primary_key :id
-        String :mbid
-        String :title
-        String :image_path
-        String :info
-        String :date
-      end unless @db.table_exists? :albums
+      unless @@db.table_exists? :albums
+        @@db.create_table :albums do
+          primary_key :id
+          String :mbid
+          String :title
+          String :image_path
+          String :info
+          Integer :year
+          foreign_key :artist_id, :artists
+        end
+        @@db[:albums].insert(:id => 1, :title => "Unknown Album")
+        @@db[:albums].insert(:id => 2, :title => "Non-Album Tracks")
+      end
 
-      @db.create_table :songs do
+      @@db.create_table :songs do
         primary_key :id
         String :mbid
         String :path
         String :title
         String :lyrics
         String :image_path
-        String :track_num
+        String :info
+        Integer :track_num
         foreign_key :album_id, :albums
         foreign_key :artist_id, :artists
-      end unless @db.table_exists? :songs
+      end unless @@db.table_exists? :songs
     end
 
-    def save_song song
-      begin
-        # Get artist info
-        artist = song.artist
-        artist_hash = {
-          :mbid => artist.mbid,
-          :name => artist.name,
-          :image_path => artist.image_path,
-          :info => artist.info
-        }
-
-        # Insert/update artist in database
-        artist_id = nil
-        row_artist = @db[:artists][:name => artist.name]
-        if row_artist
-          artist_hash.each do |k, v|
-            if row_artist[k] != v
-              @db[:artists].filter(:name => artist.name).update(k => v)
-            end
-          end
-          artist_id = row_artist[:id]
-        else
-          artist_id = @db[:artists].insert(artist_hash)
-        end
-        artist.db_id = artist_id
-
-        # Get album info
-        album = song.album
-        album_hash = {
-          :mbid => album.mbid,
-          :title => album.title,
-          :image_path => album.image_path,
-          :date => album.date,
-          :info => album.info,
-        }
-
-        # Insert/update artist in database
-        album_id = nil
-        row_album = @db[:albums][:title => album.title]
-        if row_album
-          album_hash.each do |k, v|
-            if row_album[k] != v
-              @db[:albums].filter(:title => album.title).update(k => v)
-            end
-          end
-          album_id = row_album[:id]
+    def self.get_or_insert_artist query
+      name = query[:name]
+      artist = Artist[Artist::UNKNOWN]
+      unless name.nil?
+        artist = case name.downcase
+        when "", "unknown", "unknown artist"
+          Artist[Artist::UNKNOWN]
+        when "various", "various artists"
+          Artist[Artist::VARIOUS]
         else
-          album_id = @db[:albums].insert(album_hash)
+          Artist.first(query) || Artist.create(query)
         end
-        album.db_id = album_id
-
-        song_hash = {
-          :path => song.path,
-          :mbid => song.mbid,
-          :title => song.title,
-          :lyrics => song.lyrics,
-          :track_num => song.track_num,
-          :album_id => album_id,
-          :artist_id => artist_id
-        }
-
-        song_id = nil
-        row_song = @db[:songs][:path => song.path]
-        if row_song
-          song_hash.each do |k, v|
-            if row_song[k] != v
-              @db[:songs].filter(:path => song.path).update(k => v)
-            end
-          end
-          song_id = row_song[:id]
+      end
+      return artist
+    end
+
+    def self.get_or_insert_album query
+      title = query[:title]
+      album = Album[Album::UNKNOWN]
+      unless title.nil?
+        album = case title.downcase
+        when "", "unknown", "unknown album"
+          Album[Artist::UNKNOWN]
+        when "[non-album tracks]", "non-album", "non-album tracks"
+          Album[Album::NON_ALBUM]
         else
-          song_id = @db[:songs].insert(song_hash)
-          row_song = @db[:songs][:id => song_id]
+          Album.first(query) || Album.create(query)
         end
-        song.db_id = song_id
-
-        return row_song
-      rescue
-        Sh::Log.warning "Couldn't save #{song.path} to database", $!
-        return
       end
+      return album
     end
 
-    def artists(params={})
-      artists = []
-      params ||= {}
-      rows = @db[:artists]
-      rows = rows.filter(params) unless params == {}
-      rows.each do |hash|
-        artists << hash_to_artist(hash)
+    def self.add_song path
+      tags = TagReader.read path
+
+      artist = get_or_insert_artist(:name => tags[:artist])
+      album = get_or_insert_album(:title => tags[:album], :artist_id => artist.id)
+
+      unless album.special_case?
+        album.year = tags[:year]
+        album.save
       end
-      return artists
-    end
 
-    def albums(params={})
-      albums = []
-      params ||= {}
-      rows = @db[:albums]
-      rows = rows.filter(params) unless params == {}
-      rows.each do |hash|
-        albums << hash_to_album(hash)
+      song = Song.create do |s|
+        s.path = path
+        s.artist = artist
+        s.album = album
+        s.title = tags[:title]
+        s.track_num = tags[:track_num]
       end
-      return albums
+
+      return song
     end
+  end
 
-    def songs(params={})
-      songs = []
-      params ||= {}
-      rows = @db[:songs]
-      rows = rows.filter(params) unless params == {}
-      rows.each do |hash|
-        songs << hash_to_song(hash)
-      end
-      return songs
+  Database.load
+  
+  class Artist < Sequel::Model
+    UNKNOWN = 1
+    VARIOUS = 2
+
+    one_to_many :albums
+    one_to_many :songs
+
+    def special_case?
+      return [UNKNOWN, VARIOUS].include?(id)
     end
 
-    def contains? path
-      @db[:songs][:path => path]
+    def to_s
+      return name
     end
 
-    def clean
-      @db[:songs].each do |hash|
-        path = hash[:path]
-        unless File.exists? path
-          Sh::Log.debug "Removing #{path} from database"
-          @db[:songs].filter(:path => path).delete
+    def_dataset_method :clean_empty_artists do
+      Artist.each do |a|
+        unless a.special_case?
+          a.delete if a.albums.empty? and a.songs.empty?
         end
       end
     end
+  end
+
+  class Album < Sequel::Model
+    UNKNOWN = 1
+    NON_ALBUM = 2
+
+    many_to_one :artist
+    one_to_many :songs
+
+    def special_case?
+      return [UNKNOWN, NON_ALBUM].include?(id)
+    end
+
+    def to_s
+      return title
+    end
 
-    private
-    def hash_to_song hash
-      song = Sh::Song.new hash[:path]
-      hash.each do |k, v|
-        assign = (k.to_s + '=').to_sym
-        song.send assign, v if song.respond_to? assign
+    def_dataset_method :clean_empty_albums do
+      Album.each do |a|
+        unless a.special_case?
+          a.delete if a.songs.empty?
+        end
       end
-      song.db_id = hash[:id]
-      song.album = hash_to_album(@db[:albums][:id => hash[:album_id]])
-      song.artist = hash_to_artist(@db[:artists][:id => hash[:artist_id]])
-      return song
     end
+  end
+
+  class Song < Sequel::Model
+    many_to_one :artist
+    many_to_one :album
 
-    def hash_to_album hash
-      album = Sh::Album.new
-      return album unless hash
-      hash.each do |k, v|
-        assign = (k.to_s + '=').to_sym
-        album.send assign, v if album.respond_to? assign
+    def to_s
+      return "%s, %s, %.2d - %s" % [artist, album, track_num, title]
+    end
+
+    def to_html
+      t = title
+      t = "Unknown" if not t or t.strip == ""
+      t = CGI.escapeHTML t
+      ar = artist.name
+      ar = "Unknown" if not ar or ar.strip == ""
+      ar = CGI.escapeHTML ar
+      al = album.title
+      al = "Unknown" if not al or al.strip == ""
+      al = CGI.escapeHTML al
+      return "<b>#{t}</b> by <i>#{ar}</i> from <i>#{al}</i>"
+    end
+
+    def lookup!
+      begin
+        return Fingerprint.identify! self
+      rescue Exception
+        Log.debug "Couldn't identify song from fingerprint", $!
+        return false
       end
-      album.db_id = hash[:id]
-      return album
     end
 
-    def hash_to_artist hash
-      artist = Sh::Artist.new
-      return artist unless hash
-      hash.each do |k, v|
-        assign = (k.to_s + '=').to_sym
-        artist.send assign, v if artist.respond_to? assign
+    def validate
+      errors[:path] << "must exist" unless path and File.exists?(path)
+    end
+
+    def_dataset_method :clean_missing_songs do
+      Song.each do |s|
+        s.delete unless File.exists?(s.path)
       end
-      artist.db_id = hash[:id]
-      return artist
     end
   end
 end

data/lib/sh_fingerprint.rb

@@ -0,0 +1,64 @@
+try_require 'earworm'
+try_require 'rbrainz'
+
+module Sh
+  class Fingerprint
+    def self.identify! song
+      Log.debug "Earworming #{song.path}"
+      ew = Earworm::Client.new(KEYS[:music_dns])
+      info = ew.identify :file => song.path
+      title = unescape_html info.title
+      artist_name = unescape_html info.artist_name
+      puids = info.puid_list || []
+      return false unless title and artist_name
+
+      query = MusicBrainz::Webservice::Query.new
+      tracks = query.get_tracks :title => title, :artist => artist_name, :puid => puids.first
+      track = tracks.first.entity
+      # Sort track matches with same score to find most appropriate one
+      all_matches = tracks.reject {|t| t.score < tracks.first.score}
+      all_matches.each do |entry|
+        t = entry.entity
+        rel = t.releases.first
+        if Album.first(:title => rel.title)
+          track = t
+          break
+        elsif rel.types.include? MusicBrainz::Model::Release::TYPE_ALBUM
+          track = t
+        end
+      end
+      artist = track.artist
+      release = track.releases.first
+      album_artist = query.get_release_by_id(release.id.uuid, :artist => true).artist
+      track_num = release.tracks.offset + 1
+
+      song.title = title
+      song.track_num = track_num
+      song.album = Database.get_or_insert_album(:title => release.title)
+      song.album.mbid = release.id.uuid
+      song.album.artist = Database.get_or_insert_artist(:name => album_artist.name)
+      song.album.artist.mbid = album_artist.id.uuid
+      song.album.artist.save
+      song.album.save
+      song.artist = Database.get_or_insert_artist(:name => artist.name)
+      song.artist.mbid = artist.id.uuid
+      song.artist.save
+      song.save
+
+      return true
+    end
+
+    def self.unescape_html str
+      entities = {
+        "&quot;" => "\"",
+        "&apos;" => "'",
+        "&amp;" => "&",
+        "&lt;" => "<",
+        "&gt;" => ">",
+        "&nbsp;" => " "
+      }
+
+      return CGI.unescapeHTML(str.gsub(/&\w*;/) {|e| entities[e] || e})
+    end
+  end
+end

data/lib/sh_main.rb

@@ -1,12 +1,17 @@
 #!/usr/bin/ruby
 
+# Problems occur when 'socket' is not required first
 require 'socket'
+require 'resolv-replace'
 require 'rubygems'
 
 require 'sh_util'
+
+# Try to require 'breakpoint' (for debugging purposes)
+try_require 'breakpoint'
+
 require 'sh_log'
 require 'sh_global'
-require 'sh_song'
 require 'sh_database'
 require 'sh_player'
 require 'sh_view'
@@ -14,22 +19,19 @@ require 'sh_view'
 module Sh
   class Main
     def initialize
-    	Sh::Log.info 'Shroom started'
-
-      # Load the database
-      $db = Sh::Database.new
+    	Log.info 'Shroom started'
       
       # See sh_player.rb for why this Wx stuff is necessary
       Wx::App.run do
-        Sh::View.new.show
+        View.new.show
       end
 
-      Sh::Log.debug 'Saving preferences...'
-      Sh::Global.save_prefs
-      Sh::Log.debug 'Global preferences saved'
+      Log.debug 'Saving preferences...'
+      Global.save_prefs
+      Log.debug 'Global preferences saved'
       Plugin.save_prefs
-      Sh::Log.debug 'Plugin preferences saved'
-      Sh::Log.info 'Shroom quit'
+      Log.debug 'Plugin preferences saved'
+      Log.info 'Shroom quit'
     end
   end
 end