rockstar-custom 0.6.1

data/examples/track.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'rockstar'))
+require 'pp'
+
+# Please enter your API-Keys into lastfm.yml first. 
+# You can find them here : http://www.lastfm.de/api/account
+Rockstar.lastfm = YAML.load_file(File.join(File.dirname(__FILE__), 'lastfm.yml'))
+
+track = Rockstar::Track.new('Carrie Underwood', 'Before He Cheats')
+puts 'Fans'
+puts "=" * 4
+track.fans.each { |u| puts "(#{u.weight}) #{u.username}" }
+
+track = Rockstar::Track.new('U2 & Green Day', 'The Saints Are Coming')
+pp track.tags

data/examples/user.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'rockstar'))
+
+# Please enter your API-Keys into lastfm.yml first. 
+# You can find them here : http://www.lastfm.de/api/account
+Rockstar.lastfm = YAML.load_file(File.join(File.dirname(__FILE__), 'lastfm.yml'))
+
+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}" }

data/lib/rockstar.rb

@@ -0,0 +1,50 @@
+$: << File.expand_path(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'cgi'
+require 'hpricot'
+require 'active_support'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/inflections'
+require 'time'
+require 'yaml'
+
+require 'rockstar/base'
+require 'rockstar/version'
+
+require 'rockstar/album'
+require 'rockstar/artist'
+require 'rockstar/chart'
+require 'rockstar/event'
+require 'rockstar/geo'
+require 'rockstar/metro'
+require 'rockstar/user'
+require 'rockstar/tag'
+require 'rockstar/track'
+require 'rockstar/venue'
+
+require 'rockstar/simpleauth'
+require 'rockstar/auth'
+require 'rockstar/session'
+require 'rockstar/tokenauth'
+require 'rockstar/scrobble'
+require 'rockstar/playing'
+
+require 'rockstar/rest'
+
+module Rockstar
+  extend self
+  
+  def lastfm=(args)
+    @api_key    = args["api_key"]
+    @api_secret = args["api_secret"]
+  end
+  
+  def lastfm_api_key
+    @api_key
+  end
+  
+  def lastfm_api_secret
+    @api_secret
+  end
+end

data/lib/rockstar/album.rb

@@ -0,0 +1,109 @@
+# 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']
+        name             = xml.at(:title).inner_html                   if name.nil? && (xml).at(:title)
+        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 && doc.root['artist']
+
+        album = Album.new(artist, name)
+        album.load_info(xml)
+        album
+      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("album.getInfo", {:artist => @artist, :album =>@name})
+        xml = (doc / :album).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.rank           = xml['rank']                                 if xml['rank']
+      self.rank           = (xml).at(:rank).inner_html                  if (xml).at(:rank) if rank.nil?
+      self.url            = Base.fix_url((xml).at(:url).inner_html)     if (xml).at(:url)
+
+      self.summary        = (xml).at(:summary).to_plain_text            if (xml).at(:summary)
+      self.content        = (xml).at(:content).to_plain_text            if (xml).at(:content)
+
+      self.release_date   = Base.parse_time((xml).at(:releasedate).inner_html.strip) if (xml).at(:releasedate)
+      self.chartposition  = rank
+      
+      self.images = {}
+      (xml/'image').each {|image|
+        self.images[image['size']] = image.inner_html if self.images[image['size']].nil?
+      }
+      
+      self.image_large    = images['large']
+      self.image_medium   = images['medium']
+      self.image_small    = images['small']
+      
+      # needed on top albums for tag
+      self.count          = xml['count'] if xml['count']
+      self.streamable     = xml['streamable'] if xml['streamable']
+
+      self
+    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,182 @@
+# 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, :listenercount, :playcount, :rank, :url, :thumbnail
+    attr_accessor :summary, :content, :images, :count, :streamable
+    attr_accessor :chartposition
+    
+    # used for similar artists
+    attr_accessor :match
+    
+    class << self
+      def new_from_xml(xml, doc=nil)
+        # occasionally name can be found in root of artist element (<artist name="">) rather than as an element (<name>)
+        name             = (xml).at(:name).inner_html           if (xml).at(:name)
+        name             = xml['name']                          if name.nil? && xml['name']
+
+        artist = Artist.new(name)
+        artist.load_info(xml)
+        artist
+      end
+    end
+    
+    def initialize(name, o={})
+      raise ArgumentError, "Name is required" if name.blank?
+      @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("artist.getInfo", {:artist => @name})
+        xml = (doc / :artist).first
+      end
+
+      return self if xml.nil?
+
+      self.mbid           = (xml).at(:mbid).inner_html              if (xml).at(:mbid)
+      self.listenercount  = (xml).at(:listeners).inner_html         if (xml).at(:listeners)
+      self.playcount      = (xml).at(:playcount).inner_html         if (xml).at(:playcount)
+      self.chartposition  = self.rank = xml['rank']                 if xml['rank']
+      self.chartposition  = self.rank = (xml).at(:rank).inner_html  if (xml).at(:rank) if self.rank.nil?
+      self.url            = Base.fix_url((xml).at(:url).inner_html) if (xml).at(:url)
+
+      if bio_xml = xml.at(:bio)
+        self.summary      = bio_xml.at(:summary).to_plain_text      if bio_xml.at(:summary)
+        self.content      = bio_xml.at(:content).to_plain_text      if bio_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      = self.images['small']
+      self.match          = (xml).at(:match).inner_html          if (xml).at(:match)
+       
+      # in top artists for tag
+      self.count          = xml['count']                         if xml['count']
+      self.streamable     = xml['streamable']                    if xml['streamable']
+
+      self.streamable     = (xml).at(:streamable).inner_html == '1' ? 'yes' : 'no' if self.streamable.nil? && (xml).at(:streamable)
+
+      self
+    end
+    
+    def current_events(format=:ics)
+      warn "[DEPRECATION] the `current_events` method is deprecated. Please use artist.events"
+      events
+    end
+
+    def events(force=false)
+      get_instance("artist.getEvents", :events, :event, {:artist => @name}, force)
+    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)
+      load_info if self.images.nil?
+      self.images[which]
+    end
+
+    def user_images(opts={})
+      if mbid.nil?
+        opts[:artist] = name
+      else
+        opts[:mbid] = mbid
+      end
+
+      images = []
+      image_doc = self.class.fetch_and_parse("artist.getImages", opts, false)
+      (image_doc/'image').each do |xml|
+        image_sizes = {}
+        xml.search('/sizes/size').each do |image|
+          image_sizes[image['name']] = image.inner_html
+        end
+
+        images << image_sizes
+      end
+
+      images
+    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,48 @@
+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
+      
+      def get_instance(api_method, instance_name, element, params, sign_request = false)
+        rockstar_class = "rockstar/#{element.to_s}".camelize.constantize
+        doc      = self.fetch_and_parse(api_method, params, sign_request)
+        (doc/element).inject([]) { |elements, el| elements << rockstar_class.new_from_xml(el, doc); elements }
+      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
+
+      def self.parse_time(time_str)
+        return nil if time_str.blank?
+        Time.parse(time_str)
+      end
+  end
+end