rockstar 0.3.0

data/lib/rockstar/album.rb

@@ -0,0 +1,108 @@
+# Getting information about an album such as release date and the summary or description on it is very easy.
+# 
+#   album = Rockstar::Album.new('Carrie Underwood', 'Some Hearts', :include_info => true)
+# 
+#   puts "Album: #{album.name}"
+#   puts "Artist: #{album.artist}"
+#   puts "URL: #{album.url}"
+#   puts "Release Date: #{album.release_date.strftime('%m/%d/%Y')}"
+# 
+# Would output:
+#
+#   Album: Some Hearts
+#   Artist: Carrie Underwood
+#   URL: http://www.last.fm/music/Carrie+Underwood/Some+Hearts
+#   Release Date: 11/15/2005
+# 
+module Rockstar
+  class Album < Base
+    attr_accessor :artist, :artist_mbid, :name, :mbid, :playcount, :rank, :url, :release_date
+    attr_accessor :image_large, :image_medium, :image_small, :summary, :content, :images
+    
+    # needed on top albums for tag
+    attr_accessor :count, :streamable
+    
+    # needed for weekly album charts
+    attr_accessor :chartposition
+    
+    class << self
+      def find(artist, name, o={})
+        new(artist, name, o)
+      end
+      
+      def new_from_xml(xml, doc=nil)
+        name             = (xml).at(:name).inner_html                  if (xml).at(:name)
+        name             = xml['name']                                 if name.nil? && xml['name']
+        artist           = (xml).at(:artist).at(:name).inner_html      if (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']
+        a                = Album.new(artist, name)
+        a.artist_mbid    = (xml).at(:artist)['mbid']                   if (xml).at(:artist) && (xml).at(:artist)['mbid']
+        a.artist_mbid    = (xml).at(:artist).at(:mbid).inner_html      if a.artist_mbid.nil? && (xml).at(:artist) && (xml).at(:artist).at(:mbid)
+        a.mbid           = (xml).at(:mbid).inner_html                  if (xml).at(:mbid)
+        a.playcount      = (xml).at(:playcount).inner_html             if (xml).at(:playcount)
+        a.rank           = xml['rank']                                 if xml['rank']
+        a.rank           = (xml).at(:rank).inner_html                  if (xml).at(:rank) if a.rank.nil?
+        a.url            = Base.fix_url((xml).at(:url).inner_html)     if (xml).at(:url)
+        
+        a.chartposition  = a.rank
+        
+        a.images = {}
+        (xml/'image').each {|image|
+          a.images[image['size']] = image.inner_html
+        }
+        
+        a.image_large    = a.images['large']
+        a.image_medium   = a.images['medium']
+        a.image_small    = a.images['small']
+        
+        # needed on top albums for tag
+        a.count          = xml['count'] if xml['count']
+        a.streamable     = xml['streamable'] if xml['streamable']
+        a
+      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
+      doc           = self.class.fetch_and_parse("album.getInfo", {:artist => @artist, :album =>@name})
+      @url          = Base.fix_url((doc).at(:url).inner_html)
+      @release_date = Time.parse((doc).at(:releasedate).inner_html.strip)
+
+      @images = {}
+      (doc/'image').each {|image|
+        @images[image['size']] = image.inner_html
+      }
+
+      @image_large    = @images['large']
+      @image_medium   = @images['medium']
+      @image_small    = @images['small']
+
+      @mbid         = (doc).at(:mbid).inner_html
+      @summary      = (doc).at(:summary).to_plain_text
+      @content      = (doc).at(:content).to_plain_text
+    end
+    
+    def tracks
+      warn "[DEPRECATION] `tracks` is deprecated. The current api doesn't offer this function"
+      []
+    end
+    
+    def image(which=:small)
+      which = which.to_s
+      raise ArgumentError unless ['small', 'medium', 'large', 'extralarge'].include?(which)  
+      if (self.images.nil?)
+        load_info
+      end    
+      self.images[which]
+    end
+  end
+end

data/lib/rockstar/artist.rb

@@ -0,0 +1,135 @@
+# Below are examples of how to find an artists top tracks and similar artists.
+# 
+#   artist = Rockstar::Artist.new('Carrie Underwood')
+# 
+#   puts 'Top Tracks'
+#   puts "=" * 10
+#   artist.top_tracks.each { |t| puts "#{t.name}" }
+# 
+#   puts
+# 
+#   puts 'Similar Artists'
+#   puts "=" * 15
+#   artist.similar.each { |a| puts "(#{a.match}%) #{a.name}" }
+# 
+# Would output something similar to:
+# 
+#   Top Tracks
+#   ==========
+#   (8797) Before He Cheats
+#   (3574) Don't Forget to Remember Me
+#   (3569) Wasted
+#   (3246) Some Hearts
+#   (3142) Jesus, Take the Wheel
+#   (2600) Starts With Goodbye
+#   (2511) Jesus Take The Wheel
+#   (2423) Inside Your Heaven
+#   (2328) Lessons Learned
+#   (2040) I Just Can't Live a Lie
+#   (1899) Whenever You Remember
+#   (1882) We're Young and Beautiful
+#   (1854) That's Where It Is
+#   (1786) I Ain't in Checotah Anymore
+#   (1596) The Night Before (Life Goes On)
+#   
+#   Similar Artists
+#   ===============
+#   (100%) Rascal Flatts
+#   (84.985%) Keith Urban
+#   (84.007%) Kellie Pickler
+#   (82.694%) Katharine McPhee
+#   (81.213%) Martina McBride
+#   (79.397%) Faith Hill
+#   (77.121%) Tim McGraw
+#   (75.191%) Jessica Simpson
+#   (75.182%) Sara Evans
+#   (75.144%) The Wreckers
+#   (73.034%) Kenny Chesney
+#   (71.765%) Dixie Chicks
+#   (71.084%) Kelly Clarkson
+#   (69.535%) Miranda Lambert
+#   (66.952%) LeAnn Rimes
+#   (66.398%) Mandy Moore
+#   (65.817%) Bo Bice
+#   (65.279%) Diana DeGarmo
+#   (65.115%) Gretchen Wilson
+#   (62.982%) Clay Aiken
+#   (62.436%) Ashlee Simpson
+#   (62.160%) Christina Aguilera
+module Rockstar
+  class Artist < Base
+    attr_accessor :name, :mbid, :playcount, :rank, :url, :thumbnail, :images, :count, :streamable
+    attr_accessor :chartposition
+    
+    # used for similar artists
+    attr_accessor :match
+    
+    class << self
+      def new_from_xml(xml, doc=nil)
+        name             = (xml).at(:name).inner_html           if (xml).at(:name)
+        # occasionally name can be found in root of artist element (<artist name="">) rather than as an element (<name>)
+        name             = xml['name']                          if name.nil? && xml['name']
+        a                = Artist.new(name)
+        a.mbid           = (xml).at(:mbid).inner_html              if (xml).at(:mbid)
+        a.playcount      = (xml).at(:playcount).inner_html         if (xml).at(:playcount)
+        a.chartposition  = a.rank = xml['rank']                     if xml['rank']
+        a.chartposition  = a.rank = (xml).at(:rank).inner_html      if (xml).at(:rank) if a.rank.nil?
+        a.url            = Base.fix_url((xml).at(:url).inner_html) if (xml).at(:url)
+        
+        a.images = {}
+        (xml/'image').each {|image|
+          a.images[image['size']] = image.inner_html
+        }
+        
+        a.thumbnail = a.images['small']
+        
+        a.match          = (xml).at(:match).inner_html          if (xml).at(:match)
+       
+        # in top artists for tag
+        a.count          = xml['count']                         if xml['count']
+        a.streamable     = xml['streamable']                    if xml['streamable']
+        a.streamable     = (xml).at(:streamable).inner_html == '1' ? 'yes' : 'no' if a.streamable.nil? && (xml).at(:streamable)
+        a
+      end
+    end
+    
+    def initialize(name)
+      raise ArgumentError, "Name is required" if name.blank?
+      @name = name
+    end
+    
+    def current_events(format=:ics)
+      warn "[DEPRECATION] `current_events` is deprecated. The current api doesn't offer this function"
+      []
+    end
+    
+    def similar(force=false)
+      get_instance("artist.getSimilar", :similar, :artist, {:artist => @name}, force)
+    end
+    
+    def top_fans(force=false)
+      get_instance("artist.getTopFans", :top_fans, :user, {:artist => @name}, force)
+    end
+    
+    def top_tracks(force=false)
+      get_instance("artist.getTopTracks", :top_tracks, :track, {:artist => @name}, force)
+    end
+    
+    def top_albums(force=false)
+      get_instance("artist.getTopAlbums", :top_albums, :album, {:artist => @name}, force)
+    end
+    
+    def top_tags(force=false)
+      get_instance("artist.getTopTags", :top_tags, :tag, {:artist => @name}, force)
+    end
+    
+    def image(which=:medium)
+      which = which.to_s
+      raise ArgumentError unless ['small', 'medium', 'large', 'extralarge'].include?(which)  
+      if (self.images.nil?)
+        load_info
+      end    
+      self.images[which]
+    end
+  end
+end

data/lib/rockstar/auth.rb

@@ -0,0 +1,21 @@
+module Rockstar
+  
+  class Auth < Base
+    # Returns the token for a session. You have to use
+    # TokenAuth first and then use this class with the token
+    # that is given by last.fm to create a session token
+    # This session token can be stored in your database, it is
+    # not expiring.
+    # See Rockstar::TokenAuth for a detailed example
+    def session(token)
+      doc = self.class.fetch_and_parse("auth.getSession", {:token => token}, true)
+      Rockstar::Session.new_from_xml(doc)
+    end
+    
+    def token
+      doc = self.class.fetch_and_parse("auth.getToken", {}, true)
+      token = (doc).at(:token).inner_html if (doc).at(:token)
+      token
+    end
+  end
+end

data/lib/rockstar/base.rb

@@ -0,0 +1,37 @@
+module Rockstar 
+  
+  API_URL     = 'http://ws.audioscrobbler.com/'
+  API_VERSION = '2.0'
+  
+  class Base
+    class << self
+      def connection
+        @connection ||= REST::Connection.new(API_URL + API_VERSION + "/")
+      end
+      
+      def fetch_and_parse(resource, params = {}, sign_request = false)
+        Hpricot::XML(connection.get(resource, sign_request, params))
+      end
+    end
+    
+    private
+      # in order for subclass to use, it must have api_path method
+      def get_instance(api_method, instance_name, element, params, force=false, sign_request = false)
+        rockstar_class = "rockstar/#{element.to_s}".camelize.constantize
+        
+        if instance_variable_get("@#{instance_name}").nil? || force
+          doc      = self.class.fetch_and_parse(api_method, params, sign_request)
+          elements = (doc/element).inject([]) { |elements, el| elements << rockstar_class.new_from_xml(el, doc); elements }
+          instance_variable_set("@#{instance_name}", elements)
+        end
+        instance_variable_get("@#{instance_name}")
+      end
+      
+      def self.fix_url(url)
+        if (!url.blank? && !url.match("^http://"))
+          url = "http://#{url}"
+        end
+        url
+      end
+  end
+end

data/lib/rockstar/chart.rb

@@ -0,0 +1,31 @@
+module Rockstar
+  class Chart < Base
+    class << self
+      def new_from_xml(xml, doc)
+        Chart.new(xml['from'], xml['to'])
+      end
+    end
+    def initialize(from, to)
+      raise ArgumentError, "From is required" if from.blank?
+      raise ArgumentError, "To is required" if to.blank?
+      @from = from
+      @to = to
+    end
+    
+    def from=(value)
+      @from = value.to_i
+    end
+    
+    def to=(value)
+      @to = value.to_i
+    end
+    
+    def from
+      @from.to_i
+    end
+    
+    def to
+      @to.to_i
+    end
+  end
+end

data/lib/rockstar/playing.rb

@@ -0,0 +1,49 @@
+module Rockstar
+  class Playing
+    # you should read last.fm/api/submissions#np first!
+
+    attr_accessor :session_id, :now_playing_url, :artist, :track,
+                  :album, :length, :track_number, :mb_track_id
+    attr_reader :status
+
+    def initialize(args = {})
+      @session_id = args[:session_id] # from Rockstar::SimpleAuth
+      @now_playing_url = args[:now_playing_url] # from Rockstar::SimpleAuth (can change)
+      @artist = args[:artist] # track artist
+      @track = args[:track] # track name
+      @album = args[:album] || '' # track album (optional)
+      @length = args[:length] || '' # track length in seconds (optional)
+      @track_number = args[:track_number] || '' # track number (optional)
+      @mb_track_id = args[:mb_track_id] || '' # MusicBrainz track ID (optional)
+
+      if [@session_id, @now_playing_url, @artist, @track].any?(&:blank?)
+        raise ArgumentError, 'Missing required argument'
+      elsif !@length.to_s.empty? && @length.to_i <= 30 # see last.fm/api
+        raise ArgumentError, 'Length must be greater than 30 seconds'
+      end 
+
+      @connection = REST::Connection.new(@now_playing_url)
+    end
+
+    def submit!
+      query = { :s => @session_id,
+                :a => @artist,
+                :t => @track,
+                :b => @album,
+                :l => @length,
+                :n => @track_number,
+                :m => @mb_track_id }
+
+      @status = @connection.post('', false, query)
+
+      case @status
+      when /OK/
+
+      when /BADSESSION/
+        raise BadSessionError # rerun Rockstar::SimpleAuth#handshake!
+      else
+        raise RequestFailedError
+      end
+    end
+  end
+end

data/lib/rockstar/rest.rb

@@ -0,0 +1,66 @@
+require 'net/https'
+require 'digest/md5'
+
+module Rockstar
+  module REST
+  	class Connection
+  		def initialize(base_url, args = {})
+  			@base_url = base_url
+  			@username = args[:username]
+  			@password = args[:password]
+  		end
+
+  		def get(resource, sign_request, args = {})
+  			request(resource, "get", args, sign_request)
+  		end
+
+  		def post(resource, sign_request, args = nil)
+  			request(resource, "post", args, sign_request)
+  		end
+
+  		def request(resource, method = "get", args = {}, sign_request=false)
+  		 	url = URI.parse(@base_url)
+        
+        if (!resource.blank?)
+          args[:method] = resource
+          args[:api_key]= Rockstar.lastfm_api_key
+        end
+        
+  			if args
+  			  sorted_keys = args.keys.sort_by{|k|k.to_s}
+          query = sorted_keys.collect { |k| "%s=%s" % [escape(k.to_s), escape(args[k].to_s)] }.join("&")
+
+          if !args[:sk].nil? ||sign_request # Session Key available => sign the request or sign_request = true?
+            signed = sorted_keys.collect {|k| "%s%s" % [k.to_s, args[k].to_s]}.join()
+            
+            auth = Digest::MD5.hexdigest("#{signed}#{Rockstar.lastfm_api_secret}")
+            query += "&api_sig=#{auth}"
+          end
+  				url.query = query
+  			end
+
+       	case method
+  			when "get"
+  				req = Net::HTTP::Get.new(url.request_uri)
+  			when "post"
+  				req = Net::HTTP::Post.new(url.request_uri)
+  			end
+
+  			if @username and @password
+  				req.basic_auth(@username, @password)
+  			end
+
+  			http = Net::HTTP.new(url.host, url.port)
+  			http.use_ssl = (url.port == 443)
+
+  			res = http.start() { |conn| conn.request(req) }
+  			res.body
+  		end
+  		
+  		private
+  		  def escape(str)
+  		    URI.escape(str, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+  		  end
+  	end
+  end
+end