rockstar-custom 0.6.1

data/lib/rockstar/tokenauth.rb

@@ -0,0 +1,84 @@
+require 'digest/md5'
+
+# exception definitions
+class BadAuthError < StandardError; end
+class BannedError < StandardError; end
+class BadTimeError < StandardError; end
+module Rockstar
+  
+  # = Token Authentification
+  #
+  # There are 2 ways to get an auth token : 
+  # 
+  # = Desktop-App
+  # 1. Get a new token to request authorisation:
+  #     token = Rockstar::Auth.new.token
+  # 2. Open a webbrowser with http://www.last.fm/api/auth/?api_key=xxxxxxxxxxx&token=xxxxxxxx
+  # 3. Wait for the User to confirm that he accepted your request. 
+  # 4. Continue with "Get the session token"
+  #
+  # = Web-App
+  # 1. Redirect the user to http://www.last.fm/api/auth/?api_key={YOUR_API_KEY}&amp;cb={YOUR_RETURN_URL}
+  # 2. If the user accepts, lastfm will redirect to YOUR_RETURN_URL?token=TOKEN
+  #     token = params[:token]
+  # 3. Continue with "Get the session token"
+  #
+  # = Get the session token
+  # 1. Use the previous token and call 
+  #     session = Rockstar::Auth.new.session(token) 
+  # 2. Store the session.key and session.username returned. The session.key will not
+  #    expire. It is save to store it into your database.
+  # 3. Use this session.key as token to authentificate with this class :
+  #     auth = Rockstar::TokenAuth.new({:username => 'chunky', :token => 'bacon'})
+  #     auth.handshake!
+  # 
+  class TokenAuth
+    # you should read last.fm/api/submissions#handshake
+
+    attr_accessor :user, :token, :client_id, :client_ver
+    attr_reader :status, :session_id, :now_playing_url, :submission_url
+
+    def initialize(args = {})
+      @user = args[:username] # last.fm user
+      @token = args[:token] # last.fm token
+      @client_id = 'rck' # Client ID assigned by last.fm; Don't change this!
+      @client_ver = Rockstar::Version
+
+      raise ArgumentError, 'Missing required argument' if @user.blank? || @token.blank?
+      
+      @connection = REST::Connection.new(Rockstar::AUTH_URL)
+    end
+
+    def handshake!
+      timestamp = Time.now.to_i.to_s
+      auth = Digest::MD5.hexdigest("#{Rockstar.lastfm_api_secret}#{timestamp}")
+
+      query = { :hs => 'true',
+                :p => AUTH_VER,
+                :c => @client_id,
+                :v => @client_ver,
+                :u => @user,
+                :t => timestamp,
+                :a => auth,
+                :api_key=>Rockstar.lastfm_api_key,
+                :sk => @token }
+      result = @connection.get('/', true, query)
+
+      @status = result.split(/\n/)[0]
+      case @status
+      when /OK/
+        @session_id, @now_playing_url, @submission_url = result.split(/\n/)[1,3]
+      when /BANNED/
+        raise BannedError # something is wrong with the gem, check for an update
+      when /BADAUTH/
+        raise BadAuthError # invalid user/password
+      when /FAILED/
+        raise RequestFailedError, @status
+      when /BADTIME/
+        raise BadTimeError # system time is way off
+      else
+        raise RequestFailedError
+      end  
+    end
+  end
+end

data/lib/rockstar/track.rb

@@ -0,0 +1,260 @@
+# 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
+    attr_accessor :summary, :content, :streamable, :album, :album_mbid, :date, :date_uts, :duration
+    
+    # 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.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
+    
+    # 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,200 @@
+# 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 current_events(format=:ics)
+      warn "[DEPRECATION] `current_events` is deprecated. The current api doesn't offer ics/ical formatted data."
+    end
+    
+    def friends_events(format=:ics)
+      warn "[DEPRECATION] `friends_events` is deprecated. The current api doesn't offer ics/ical formatted data."
+    end
+    
+    def recommended_events(format=:ics)
+      warn "[DEPRECATION] `recommended_events` is deprecated. The current api doesn't offer ics/ical formatted data."
+    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)
+      get_instance("user.getTopArtists", :top_artists, :artist, {:user => @username, :period => @period}, 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_banned_tracks(force=false)
+      warn "[DEPRECATION] `recent_banned_tracks` is deprecated. The current api doesn't offer this function"
+      []
+    end
+    
+    def recent_loved_tracks(force=false)
+      get_instance("user.getLovedTracks", :recent_loved_tracks, :track, {:user => @username}, force)
+    end
+    
+    def recommendations(force=false)
+      warn "[DEPRECATION] `recommendations` is deprecated. Please use recommended_artists"
+      []
+    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
+
+    # 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