jonaustin-rockstar 0.7.1

data/lib/rockstar/track.rb

@@ -0,0 +1,265 @@
+# Below is an example of how to get the top fans for a track.
+#
+#   track = Rockstar::Track.new('Carrie Underwood', 'Before He Cheats')
+#   puts 'Fans'
+#   puts "=" * 4
+#   track.fans.each { |u| puts u.username }
+#
+# Which would output something like:
+#
+#   track = Rockstar::Track.new('Carrie Underwood', 'Before He Cheats')
+#   puts 'Fans'
+#   puts "=" * 4
+#   track.fans.each { |u| puts "(#{u.weight}) #{u.username}" }
+#
+#   Fans
+#   ====
+#   (69163) PimpinRose
+#   (7225) selene204
+#   (7000) CelestiaLegends
+#   (6817) muehllr
+#   (5387) Mudley
+#   (5368) ilovejohnny1984
+#   (5232) MeganIAD
+#   (5132) Veric
+#   (5097) aeVnar
+#   (3390) kristaaan
+#   (3239) kelseaowns
+#   (2780) syndication
+#   (2735) mkumm
+#   (2706) Kimmybeebee
+#   (2648) skorpcroze
+#   (2549) mistergreg
+#   (2449) mlmjcace
+#   (2302) tiNEey
+#   (2169) ajsbabiegirl
+
+class BadSessionError < StandardError; end
+class UnavailableError < StandardError; end
+class RequestFailedError < StandardError; end
+
+
+module Rockstar
+  class Track < Base
+    attr_accessor :artist, :artist_mbid, :name, :mbid, :playcount, :rank, :url, :now_playing
+    attr_accessor :summary, :content, :streamable, :album, :album_mbid, :date, :date_uts, :duration
+    alias_method :now_playing?, :now_playing
+
+    # only seems to be used on top tracks for tag
+    attr_accessor :count, :thumbnail, :image, :images
+
+    # for weekly top tracks
+    attr_accessor :chartposition
+
+    class << self
+      def new_from_xml(xml, doc=nil)
+        artist          = (xml).at(:artist)['name']               if (xml).at(:artist) && !(xml).at(:artist)['name'].nil?
+        artist          = (xml).at(:artist).at(:name).inner_html  if artist.nil? && (xml).at(:artist) && (xml).at(:artist).at(:name)
+        artist          = (xml).at(:artist).inner_html            if artist.nil? && (xml).at(:artist)
+        artist          = doc.root['artist']                      if artist.nil? && doc.root['artist']
+        name            = (xml).at(:name).inner_html              if (xml).at(:name)
+        name            = xml['name']                             if name.nil? && xml['name']
+
+        track = Track.new(artist, name)
+        track.load_info(xml)
+        track
+      end
+
+      def love(artist, track, session_key)
+        doc = Hpricot::XML(Track.connection.post("track.love", true, {:track => track, :artist => artist, :sk => session_key}))
+        doc.at("lfm")["status"]
+      end
+
+      # Scrobble a song
+      #
+      # Possible parameters:
+      #    session_key (required) : the session key you got during authentification
+      #    track       (required) : name of the track
+      #    artist      (required) : name of the artist of the track
+      #    time        (required) : a time object set to the time the track started playing
+      #    album                  : Name of the album
+      #    albumArtist            : Name of the album artist if artist differs
+      #    trackNumber            : Number of the track
+      #    mbid                   : MusicBrainz ID of the track
+      #    duration               : track length
+      def scrobble(params = {})
+        if params[:session_key].blank? || params[:track].blank? || params[:time].nil? || params[:artist].blank?
+          raise ArgumentError, "Missing required argument"
+        end
+
+        query = {
+          :sk           => params[:session_key],
+          "track[0]"    => params[:track],
+          "timestamp[0]"=> params[:time].utc.to_i,
+          "artist[0]"   => params[:artist]
+        }
+
+        query["album[0]"]       = params[:album] if !params[:album].blank?
+        query["albumArtist[0]"] = params[:albumArtist] if !params[:albumArtist].blank?
+        query["trackNumber[0]"] = params[:trackNumber] if !params[:trackNumber].blank?
+        query["mbid[0]"]        = params[:mbid] if !params[:mbid].blank?
+        query["duration[0]"]    = params[:duration] if !params[:duration].blank?
+
+        doc = Hpricot::XML(Track.connection.post("track.scrobble", true, query))
+
+        if doc.at("lfm")["status"] == "failed"
+          case doc.at("lfm").at("error")["code"].to_i
+            when 9
+              raise BadSessionError, doc.at("lfm").at("error").inner_html
+            when 11, 16
+              raise UnavailableError, doc.at("lfm").at("error").inner_html
+           else
+              raise RequestFailedError, doc.at("lfm").at("error").inner_html
+           end
+        end
+
+        doc.at("lfm")["status"]
+       end
+
+      # Update the current playing song
+      #
+      # Possible parameters:
+      #    session_key (required) : the session key you got during authentification
+      #    track       (required) : name of the track
+      #    artist      (required) : name of the artist of the track
+      #    album                  : Name of the album
+      #    albumArtist            : Name of the album artist if artist differs
+      #    trackNumber            : Number of the track
+      #    mbid                   : MusicBrainz ID of the track
+      #    duration               : track length
+      def updateNowPlaying(params = {})
+        if params[:session_key].blank? || params[:track].blank? || params[:artist].blank?
+          raise ArgumentError, "Missing required argument"
+        end
+
+        query = {
+          :sk        => params[:session_key],
+          "track"    => params[:track],
+          "artist"   => params[:artist]
+        }
+
+        query["album"]       = params[:album] if !params[:album].blank?
+        query["albumArtist"] = params[:albumArtist] if !params[:albumArtist].blank?
+        query["trackNumber"] = params[:trackNumber] if !params[:trackNumber].blank?
+        query["mbid"]        = params[:mbid] if !params[:mbid].blank?
+        query["duration"]    = params[:duration] if !params[:duration].blank?
+
+        doc = Hpricot::XML(Track.connection.post("track.updateNowPlaying", true, query))
+
+        if doc.at("lfm")["status"] == "failed"
+          case doc.at("lfm").at("error")["code"].to_i
+            when 9
+              raise BadSessionError, doc.at("lfm").at("error").inner_html
+            when 11, 16
+              raise UnavailableError, doc.at("lfm").at("error").inner_html
+           else
+              raise RequestFailedError, doc.at("lfm").at("error").inner_html
+           end
+        end
+
+        doc.at("lfm")["status"]
+      end
+
+    end
+
+    def initialize(artist, name, o={})
+      raise ArgumentError, "Artist is required" if artist.blank?
+      raise ArgumentError, "Name is required" if name.blank?
+      @artist = artist
+      @name = name
+
+      options = {:include_info => false}.merge(o)
+      load_info if options[:include_info]
+    end
+
+    def load_info(xml=nil)
+      unless xml
+        doc = self.class.fetch_and_parse("track.getInfo", {:artist => @artist, :track => @name})
+        xml = (doc / :track).first
+      end
+
+      return self if xml.nil?
+
+      self.now_playing	 = xml['nowplaying'] == 'true' ? true : false
+      self.artist_mbid   = (xml).at(:artist)['mbid']               if (xml).at(:artist) && (xml).at(:artist)['mbid']
+      self.artist_mbid   = (xml).at(:artist).at(:mbid).inner_html  if artist_mbid.nil? && (xml).at(:artist) && (xml).at(:artist).at(:mbid)
+      self.mbid          = (xml).at(:mbid).inner_html              if (xml).at(:mbid)
+      self.playcount     = (xml).at(:playcount).inner_html         if (xml).at(:playcount)
+      self.chartposition = self.rank = xml['rank']                 if xml['rank']
+      self.url           = Base.fix_url((xml).at(:url).inner_html) if (xml).at(:url)
+      self.streamable    = (xml).at(:track)['streamable']          if (xml).at(:track) && (xml).at(:track)['streamable']
+      self.streamable    = (xml).at(:streamable).inner_html == '1' ? 'yes' : 'no' if streamable.nil? && (xml).at(:streamable)
+      self.duration      = (xml).at(:duration).inner_html.to_i     if (xml).at(:duration)
+
+      self.count         = xml['count']                            if xml['count']
+      self.album         = (xml).at(:album).inner_html             if (xml).at(:album)
+      self.album_mbid    = (xml).at(:album)['mbid']                if (xml).at(:album) && (xml).at(:album)['mbid']
+      self.date          = Base.parse_time((xml).at(:date).inner_html)  if (xml).at(:date)
+      self.date_uts      = (xml).at(:date)['uts']                  if (xml).at(:date) && (xml).at(:date)['uts']
+
+      if wiki_xml = xml.at(:wiki)
+        self.summary     = wiki_xml.at(:summary).to_plain_text     if wiki_xml.at(:summary)
+        self.content     = wiki_xml.at(:content).to_plain_text     if wiki_xml.at(:content)
+      end
+
+      self.images = {}
+      (xml/'image').each {|image|
+        self.images[image['size']] = image.inner_html if self.images[image['size']].nil?
+      }
+
+      self.thumbnail = images['small']
+      self.image     = images['medium']
+
+      self
+    end
+
+    def albums(force=false)
+      get_instance("track.getInfo", :albums, :album, {:track => @name, :artist => @artist}, force)
+    end
+
+    def fans(force=false)
+      get_instance("track.getTopFans", :fans, :user, {:track => @name, :artist => @artist}, force)
+    end
+
+    def tags(force=false)
+      get_instance("track.getTopTags", :tags, :tag, {:track => @name, :artist => @artist}, force)
+    end
+
+    def similar(limit = 10, force = false)
+      get_instance('track.getSimilar', :similar, :track, {:track => @name, :artist => @artist, :limit => limit}, force)
+    end
+
+    # The session_key is returned by auth.session.key
+    def love(session_key)
+      Track.love(@artist, @name, session_key)
+    end
+
+    # scrobble this track
+    #   time :       a time object set to the time the track started playing
+    #   session_key: the session key you got during authentification
+    def scrobble(time, session_key)
+      Track.scrobble({
+        :session_key => session_key,
+        :time        => time,
+        :track       => @name,
+        :artist      => @artist,
+        :album       => @album,
+        :mbid        => @mbid
+      })
+    end
+
+    # inform last.fm that this track is currently playing
+    #   time :       a time object set to the time the track started playing
+    #   session_key: the session key you got during authentification
+    def updateNowPlaying(time, session_key)
+      Track.updateNowPlaying({
+        :session_key => session_key,
+        :time        => time,
+        :track       => @name,
+        :artist      => @artist,
+        :album       => @album,
+        :mbid        => @mbid
+      })
+    end
+  end
+end

data/lib/rockstar/user.rb

@@ -0,0 +1,205 @@
+# Probably the most common use of this lib would be to get your most recent tracks or your top tracks. Below are some code samples.
+#   user = Rockstar::User.new('jnunemaker')
+#
+#   puts "#{user.username}'s Recent Tracks"
+#   puts "=" * (user.username.length + 16)
+#   user.recent_tracks.each { |t| puts t.name }
+#
+#   puts
+#   puts
+#
+#   puts "#{user.username}'s Top Tracks"
+#   puts "=" * (user.username.length + 13)
+#   user.top_tracks.each { |t| puts "(#{t.playcount}) #{t.name}" }
+#
+# Which would output something like:
+#
+#   jnunemaker's Recent Tracks
+#   ==========================
+#   Everything You Want
+#   You're a God
+#   Bitter Sweet Symphony [Original Version]
+#   Lord I Guess I'll Never Know
+#   Country Song
+#   Bitter Sweet Symphony (Radio Edit)
+#
+#
+#   jnunemaker's Top Tracks
+#   =======================
+#   (62) Probably Wouldn't Be This Way
+#   (55) Not Ready To Make Nice
+#   (45) Easy Silence
+#   (43) Song 2
+#   (40) Everybody Knows
+#   (39) Before He Cheats
+#   (39) Something's Gotta Give
+#   (38) Hips Don't Lie (featuring Wyclef Jean)
+#   (37) Unwritten
+#   (37) Move Along
+#   (37) Dance, Dance
+#   (36) We Belong Together
+#   (36) Jesus, Take the Wheel
+#   (36) Black Horse and the Cherry Tree (radio version)
+#   (35) Photograph
+#   (35) You're Beautiful
+#   (35) Walk Away
+#   (34) Stickwitu
+module Rockstar
+  class User < Base
+    # attributes needed to initialize
+    attr_reader :username, :period
+
+    # profile attributes
+    attr_accessor :id, :cluster, :url, :realname, :mbox_sha1sum, :registered
+    attr_accessor :registered_unixtime, :age, :gender, :country, :playcount, :avatar, :realname, :images
+
+    # neighbor attributes
+    attr_accessor :match
+
+    # track fans attributes
+    attr_accessor :weight
+
+    class << self
+      def new_from_xml(xml, doc=nil)
+        u        = User.new((xml).at(:name).inner_html)
+        u.url    = Base.fix_url((xml).at(:url).inner_html)    if (xml).at(:url)
+
+        u.images = {}
+        (xml/'image').each {|image|
+          u.images[image['size']] = image.inner_html if u.images[image['size']].nil?
+        }
+
+        u.avatar = u.images['small']
+
+        u.weight = (xml).at(:weight).inner_html if (xml).at(:weight)
+        u.match  = (xml).at(:match).inner_html  if (xml).at(:match)
+        u.realname= (xml).at(:realname).inner_html    if (xml).at(:realname)
+        u
+      end
+
+      def find(*args)
+        options = {:include_profile => false}
+        options.merge!(args.pop) if args.last.is_a?(Hash)
+        users = args.flatten.inject([]) { |users, u| users << User.new(u, options); users }
+        users.length == 1 ? users.pop : users
+      end
+    end
+
+    def initialize(username, o={})
+      options = {:include_profile => false, :period => 'overall'}.merge(o)
+      raise ArgumentError if username.blank?
+      @username = username
+      @period = options[:period]
+      load_profile() if options[:include_profile]
+    end
+
+    def load_profile
+      doc                  = self.class.fetch_and_parse("user.getInfo", {:user => @username})
+      @id                  = (doc).at(:id).inner_html
+      @url                 = Base.fix_url((doc).at(:url).inner_html)
+      @realname            = (doc).at(:realname).inner_html
+      @registered          = (doc).at(:registered).inner_html
+      @registered_unixtime = (doc).at(:registered)['unixtime']
+      @age                 = (doc).at(:age).inner_html
+      @gender              = (doc).at(:gender).inner_html
+      @country             = (doc).at(:country).inner_html
+      @playcount           = (doc).at(:playcount).inner_html
+
+      @images = {}
+      (doc/'image').each {|image|
+        @images[image['size']] = image.inner_html
+      }
+
+      @avatar              = @images["small"]
+    end
+
+    def top_artists(force=false, options = {})
+      default_options = {
+        :period => self.period
+      }
+      options = default_options.merge(options)
+      options[:user] = @username
+
+      get_instance("user.getTopArtists", :top_artists, :artist, options, force)
+    end
+
+    def top_albums(force=false)
+      get_instance("user.getTopAlbums", :top_albums, :album, {:user => @username}, force)
+    end
+
+    def top_tracks(force=false)
+      get_instance("user.getTopTracks", :top_tracks, :track, {:user => @username}, force)
+    end
+
+    def top_tags(force=false)
+      get_instance("user.getTopTags", :top_tags, :tag, {:user => @username}, force)
+    end
+
+    def friends(force=false)
+      get_instance("user.getFriends", :friends, :user, {:user => @username}, force)
+    end
+
+    def neighbours(force=false)
+      get_instance("user.getNeighbours", :neighbours, :user, {:user => @username}, force)
+    end
+
+    def recent_tracks(force=false)
+      get_instance("user.getRecentTracks", :recent_tracks, :track, {:user => @username}, force)
+    end
+
+    def recent_loved_tracks(force=false)
+      get_instance("user.getLovedTracks", :recent_loved_tracks, :track, {:user => @username}, force)
+    end
+
+    # The session_key is returned by auth.session.key
+    def recommended_artists(session_key, force=false)
+      get_instance("user.getRecommendedArtists", :recommendations, :artist, {:user => @username, :sk => session_key}, force)
+    end
+
+    def charts(force=false)
+      get_instance("user.getWeeklyChartList", :charts, :chart, {:user => @username}, force)
+    end
+
+    def weekly_artist_chart(from=nil, to=nil)
+      doc = self.class.fetch_and_parse("user.getWeeklyArtistChart", {:user => @username, :from => from, :to => to})
+      (doc/:artist).inject([]) { |elements, el| elements << Artist.new_from_xml(el); elements }
+    end
+
+    def weekly_album_chart(from=nil, to=nil)
+      doc = self.class.fetch_and_parse("user.getWeeklyAlbumChart", {:user => @username, :from => from, :to => to})
+      (doc/:album).inject([]) { |elements, el| elements << Album.new_from_xml(el); elements }
+    end
+
+    def weekly_track_chart(from=nil, to=nil)
+      doc = self.class.fetch_and_parse("user.getWeeklyTrackChart", {:user => @username, :from => from, :to => to})
+      (doc/:track).inject([]) { |elements, el| elements << Track.new_from_xml(el); elements }
+    end
+
+    # Wrappers for Rockstar::Library
+    def artists(force=false, options = {})
+      default_options = {
+        :user => @username
+      }
+      options = default_options.merge(options)
+
+      library = Rockstar::Library.new
+      library.artists(false, options)
+    end
+
+    def albums(force=false, options = {})
+      default_options = {
+        :user => @username
+      }
+      options = default_options.merge(options)
+
+      library = Rockstar::Library.new
+      library.albums(false, options)
+    end
+
+    # Get the recommendated events for the user, auth.session.key needed.
+    def events(session_key, force = false)
+      get_instance("user.getEvents", :events, :event, {:user => @username, :sk => session_key}, force)
+    end
+
+  end
+end