shroom 0.0.1

data/README

@@ -0,0 +1,16 @@
+Shroom
+======
+
+Dependencies
+------------
+
+ruby-gnome2
+ruby-gstreamer
+ruby-sqlite3
+
+Repository
+----------
+
+The latest source code should be available at:
+ http://bitbucket.org/dismal_denizen/shroom/
+

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'shroom'
+  s.version = '0.0.1'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README', 'LICENSE']
+  s.summary = 'Shroom is a music player and organizer'
+  s.description = s.summary
+  s.author = 'Aiden Nibali'
+  s.email = 'dismal.denizen@gmail.com'
+  s.rubyforge_project = 'shroom'
+  s.homepage = 'http://shroom.rubyforge.org'
+  s.add_dependency('ruby-mp3info', '>= 0.6.13')
+  s.add_dependency('ruby-ogginfo', '>= 0.3.2')
+  s.add_dependency('flacinfo-rb', '>= 0.4')
+  s.add_dependency('earworm', '>= 0.0.2')
+  s.add_dependency('sequel', '>= 3.2.0')
+  s.requirements << 'libgstreamer0.10-ruby'
+  s.requirements << 'libgnome2-ruby'
+  s.requirements << 'libsqlite3-ruby'
+  s.requirements << 'libglade2-ruby'
+  s.executables = ['shroom']
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{bin,lib,spec}/**/*")
+  s.require_path = "lib"
+  s.bindir = "bin"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "Shroom Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end

data/bin/shroom

@@ -0,0 +1,4 @@
+#!/usr/bin/ruby
+
+require 'sh_main.rb'
+Sh::Main.new

data/lib/sh_browse.rb

@@ -0,0 +1,122 @@
+module Sh
+  class Browse
+    def initialize view
+      @tree = TreeView.new
+      @tree.selection.mode = Gtk::SELECTION_MULTIPLE
+
+      ren_artist = CellRendererText.new
+      col_artist = TreeViewColumn.new('Songs', ren_artist)
+      col_artist.set_cell_data_func(ren_artist) do |tvc, cell, model, iter|
+        cell.text = ''
+        data = iter[0]
+        cell.text = data if data.is_a? String
+        if data.is_a? Sh::Song
+          if data.title
+            cell.text = sprintf("%.2d\t%s", data.track_num, data.title)
+          else
+            cell.text = data.path.split('/').last
+          end
+        end
+      end
+      @tree.append_column col_artist
+
+      @model = TreeStore.new(Object)
+      @tree.model = @model
+
+      GLib::Timeout.add(1000) do
+        fill_model
+        false
+      end
+
+      @tree.signal_connect('button-press-event') do |widget, event|
+        # Right-click
+        if event.button == 3
+          path = @tree.get_path_at_pos(event.x, event.y).first
+          data = @tree.model.get_iter(path)[0]
+          selection = @tree.selection
+          selected_rows = selection.selected_rows
+          clicked_in_selection = false
+          selected_rows.each do |sel|
+            clicked_in_selection = sel.indices == path.indices
+            break if clicked_in_selection
+          end
+
+          unless clicked_in_selection
+            # Change the selection
+            selection.unselect_all
+            selection.select_path(path)
+            selected_rows = selection.selected_rows
+          end
+
+          puts selected_rows
+
+          if data.is_a? Sh::Song
+            song = data
+            menu = Menu.new
+
+            pbtn_lookup = MenuItem.new 'Lookup metadata automatically'
+            menu.append pbtn_lookup
+            pbtn_lookup.signal_connect('activate') do |widget|
+              song.lookup!
+              $db.save_song song
+              @model.clear
+              fill_model
+            end
+            
+            menu.show_all
+            menu.popup(nil, nil, event.button, event.time)
+          end
+        end
+      end
+      @tree.signal_connect('row_activated') do |widget, path, col|
+        iter = @tree.model.get_iter(path)
+        parent = iter.parent
+        song = iter[0]
+        if song.is_a? Sh::Song
+          view.stop
+          queue = []
+          while iter.parent == parent
+            queue << iter[0]
+            iter.next!
+          end
+          view.queue = queue
+          view.play
+        end
+      end
+
+      @scroll = ScrolledWindow.new(nil, nil)
+      @scroll.set_policy(POLICY_AUTOMATIC, POLICY_AUTOMATIC)
+      @scroll.add @tree
+    end
+
+    def fill_model
+      artist_node = album_node = track_node = nil
+      $db.songs.sort_by {|a| a.to_s}.each do |song|
+        artist = song.artist || '!Unknown Artist!'
+        if not artist_node or artist_node[0] != artist
+          artist_node = @model.append nil
+          artist_node[0] = artist
+          # Required for proper handling of multiple artists with on album
+          album_node = nil
+          #artist_node[1] = []
+        end
+        #artist_node[1] << song
+        
+        album = song.album || '!Unknown Album!'
+        if not album_node or album_node[0] != album
+          album_node = @model.append artist_node
+          album_node[0] = album
+          #album_node[1] = []
+        end
+        #album_node[1] << song
+
+        track_node = @model.append album_node
+        track_node[0] = song
+      end
+    end
+
+    def widget
+      @scroll
+    end
+  end
+end

data/lib/sh_cover_art.rb

@@ -0,0 +1,34 @@
+require 'open-uri'
+require 'rexml/document'
+require 'cgi'
+
+module Sh
+  class CoverArt
+    def CoverArt.get_cover song
+      if $prefs[:cover_art]
+        artist, album = song.artist, song.album
+        path = "#{$cover_dir}/#{artist} - #{album}"
+        return path if File.exists? path
+        doc = lastfm("album.getInfo", {:artist => artist, :album => album})
+        img_url = REXML::XPath.first(doc, '//image[@size="extralarge"]').text
+        if img_url
+          open(path, 'w') do |output|
+            open(img_url) do |input|
+              output << input.read
+            end
+          end
+          return path
+        end
+      end
+      return nil
+    end
+
+    private
+    def CoverArt.lastfm(method, arg_map = {}.freeze)
+      args = arg_map.collect { |k, v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v)}"}.join('&')
+      url = "http://ws.audioscrobbler.com/2.0/?method=#{method}&api_key=#{Sh::KEYS[:lastfm]}&#{args}"
+      doc = REXML::Document.new(open(url).read)
+    end
+  end
+end
+

data/lib/sh_database.rb

@@ -0,0 +1,86 @@
+require 'rubygems'
+require 'sequel'
+require 'sh_song'
+
+module Sh
+  class Database
+    def initialize
+      @db = Sequel.sqlite("#{$config_dir}/songs.db")
+
+      @db.create_table :songs do
+        primary_key :id
+        String :path
+        String :title
+        String :lyrics
+        String :image
+        String :year
+        String :album
+        String :artist
+        String :track_num
+      end unless @db.table_exists? :songs
+    end
+
+    def save_song song
+      hash = {
+        :path => song.path,
+        :title => song.title,
+        :lyrics => song.lyrics,
+        :image => song.image,
+        :year => song.year,
+        :album => song.album,
+        :artist => song.artist,
+        :track_num => song.track_num
+      }
+
+      song_id = nil
+      row_song = @db[:songs][:path => song.path]
+      if row_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]
+      else
+        # Create row in db for song
+        song_id = @db[:songs].insert(hash)
+        # Retrieve row to return
+        row_song = @db[:songs][:id => song_id]
+      end
+
+      return row_song
+    end
+
+    def songs
+      songs = []
+      @db[:songs].each do |hash|
+        songs << hash_to_song(hash)
+      end
+      return songs
+    end
+
+    def contains? path
+      @db[:songs][:path => path]
+    end
+
+    def clean
+      @db[:songs].each do |hash|
+        path = hash[:path]
+        unless File.exists? path
+          puts "Removing: #{path}"
+          @db[:songs].filter(:path => path).delete
+        end
+      end
+    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
+      end
+      return song
+    end
+  end
+end

data/lib/sh_global.rb

@@ -0,0 +1,54 @@
+require 'fileutils'
+require 'yaml'
+
+module Sh
+  KEYS = {
+    :lastfm => '1a265c70e0ecbe87d51efc5da4bf8a10'.freeze,
+    :music_dns => '5acf4dd55bc341877bacd07878239a82'.freeze
+  }
+
+  class Global
+    def initialize
+      #$KCODE = 'u'
+      # Won't work on Windows
+      $home = ENV['HOME']
+      $config_dir = "#{$home}/.shroom"
+      FileUtils.mkdir $config_dir unless File.exists? $config_dir
+      $cover_dir = "#{$config_dir}/covers"
+      FileUtils.mkdir $cover_dir unless File.exists? $cover_dir
+      @@prefs_file = "#{$config_dir}/preferences.yml"
+
+      $prefs = {
+        :library_dir => "#{$home}/Music",
+        :cover_art => true,
+        :lyrics => true,
+        :lastfm => false,
+        :lastfm_user => nil,
+        :lastfm_password => nil,
+      }
+
+      Global.load_prefs
+    end
+
+    def Global.load_prefs
+      if File.exists?(@@prefs_file)
+        prefs = YAML::load(File.read(@@prefs_file))
+        prefs.each do |k, v|
+          $prefs[k] = v
+        end
+      end
+    end
+
+    def Global.save_prefs
+      File.open(@@prefs_file, 'w') do |f|
+        f.write $prefs.to_yaml
+      end
+    end
+    
+    def Global.locate(file)
+      find_in_load_path("shroom-res/#{file}") || "shroom-res/#{file}"
+    end
+  end
+end
+
+Sh::Global.new

data/lib/sh_lyrics.rb

@@ -0,0 +1,24 @@
+require 'open-uri'
+require 'rexml/document'
+require 'cgi'
+
+module Sh
+  class Lyrics
+    def Lyrics.get_lyrics song
+      artist, title = song.artist, song.title
+      return "" unless artist and title
+      LyricsWiki.get_lyrics(artist, title)
+    end
+
+    class LyricsWiki
+      def LyricsWiki.get_lyrics(artist, title)
+        url = "http://lyricwiki.org/api.php?func=getSong&fmt=xml" +
+          "&artist=#{CGI.escape(artist)}" +
+          "&song=#{CGI.escape(title)}"
+        doc = REXML::Document.new(open(url).read)
+        REXML::XPath.first(doc, '//lyrics').text
+      end
+    end
+  end
+end
+

data/lib/sh_main.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby
+
+# Note to self (Mercurial push URL):
+# http://dismal_denizen@bitbucket.org/dismal_denizen/shroom/
+
+require 'socket'
+
+require 'sh_util'
+require 'sh_global'
+require 'sh_song'
+require 'sh_database'
+require 'sh_player'
+require 'sh_view'
+
+module Sh
+  class Main
+    def initialize
+      $db = Sh::Database.new
+      Sh::View.new.show
+      puts 'Saving preferences...'
+      Sh::Global.save_prefs
+      puts 'Bye!'
+    end
+  end
+end
+
+Sh::Main.new if $0 == __FILE__

data/lib/sh_player.rb

@@ -0,0 +1,164 @@
+require 'gst'
+require 'rubygems'
+require 'scrobbler'
+
+module Sh
+  class Player
+    @@scrobble_auth = nil
+    
+    Gst.init
+
+    attr_reader :song
+
+    def initialize song
+      @song = song
+      @stopped = false
+      @play_time = 0
+
+      init
+    end
+
+    private
+    def init
+      # setup the playbin
+	    @playbin = Gst::ElementFactory.make('playbin')
+	    @playbin.uri = "file://#{@song.path}"
+	    @playbin.ready
+
+      # Get duration
+      # FIXME: This duration-getting code results in nasty error messages
+      @playbin.audio_sink = Gst::ElementFactory.make('fakesink')
+      @playbin.play
+      pos = -1
+      while true
+        while (Gtk.events_pending?)
+          Gtk.main_iteration
+        end
+        query = Gst::QueryPosition.new(Gst::Format::TIME)
+        @playbin.query(query)
+        new_pos = query.parse.last / 1000000000.to_f
+        break if pos > 0 and new_pos == pos
+        pos = new_pos
+      end
+      query = Gst::QueryDuration.new(Gst::Format::TIME)
+      @playbin.query(query)
+      @duration = query.parse.last / 1000000000.to_f
+      @playbin.stop
+	
+	    # setup the sink
+	    @playbin.audio_sink = Gst::ElementFactory.make('autoaudiosink')
+
+      @playbin.bus.add_watch do |a, message|
+        case message.type
+        when Gst::Message::Type::ERROR
+          puts "An error occured: #{message.parse_error[0]}"
+        when Gst::Message::Type::EOS
+          pause
+          seek 0
+          @finished_cb.call self if @finished_cb
+        end
+        true
+      end
+
+      #@duration = @song.duration if @duration <= 0
+
+      # Make sure pipeline is stopped when program is exited
+      Signal.trap('EXIT') do
+        stop
+      end
+
+      GLib::Timeout.add(1000) do
+        @play_time += 1 if playing?
+        not @stopped
+      end
+    end
+
+    public
+    def play
+      @stopped = false
+      @playbin.play
+    end
+
+    def pause
+      @playbin.pause
+    end
+
+    def stop
+      @stopped = true
+      @playbin.stop
+      scrobble! if $prefs[:lastfm]
+    end
+
+    def scrobble!
+      play_time = @play_time
+      if play_time > 240 or (play_time > duration / 2 and duration > 30)
+        auth = @@scrobble_auth
+        if not auth
+          user, pass = $prefs[:lastfm_user], $prefs[:lastfm_password]
+          auth = @@scrobble_auth = Scrobbler::SimpleAuth.new(:user => user, :password => pass)
+          auth.handshake!
+          puts "Auth Status: #{auth.status}"
+        end
+
+        Thread.new do
+          scrobble = Scrobbler::Scrobble.new(
+            :session_id => auth.session_id,
+            :submission_url => auth.submission_url,
+            :artist => song.artist,
+            :track => song.title,
+            :album => song.album,
+            :time => Time.new,
+            :length => play_time,
+            :track_number => song.track_num)
+
+          begin
+            scrobble.submit!
+            puts "Scrobbler Submission Status: #{scrobble.status}"
+            #user = Scrobbler::User.new($prefs[:lastfm_user])
+            #user.recent_tracks.each { |t| puts t.name }
+          rescue
+            puts "Scrobble oopsie"
+          end
+        end
+      end
+    end
+
+    def duration
+      @duration
+    end
+
+    def playing?
+      @playbin and @playbin.get_state.include? Gst::STATE_PLAYING
+    end
+
+    def paused?
+      @playbin and @playbin.get_state.include? Gst::STATE_PAUSED
+    end
+
+    # Get the position (in seconds) that playback is up to
+    def position
+      if not playing? and not paused?
+        return 0
+      else
+        query = Gst::QueryPosition.new(Gst::Format::TIME)
+        @playbin.query(query)
+        pos = query.parse.last
+        if pos < 0
+          return duration
+        else
+          return pos / 1000000000.to_f
+        end
+      end
+    end
+
+    # Set the position (in seconds) to start playback from
+    def seek pos
+      @playbin.seek 1.0, Gst::Format::TIME, Gst::SeekFlags::FLUSH, Gst::SeekType::SET,
+        pos * 1000000000, Gst::SeekType::NONE, -1
+    end
+
+    def on_finished &block
+      @finished_cb = block
+    end
+  end
+end