titanous-scrobbler 0.2.2

data/History.txt

@@ -0,0 +1,3 @@
+* v 0.2.2: a bunch of changes from titanous, mostly refactoring
+* v 0.2.0: added support for scrobbling tracks and now playing submission (Titanous)
+* v 0.1.0: initial release

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2007 John Nunemaker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Manifest

@@ -0,0 +1,67 @@
+examples/album.rb
+examples/artist.rb
+examples/scrobble.rb
+examples/tag.rb
+examples/track.rb
+examples/user.rb
+History.txt
+lib/scrobbler/album.rb
+lib/scrobbler/artist.rb
+lib/scrobbler/base.rb
+lib/scrobbler/chart.rb
+lib/scrobbler/playing.rb
+lib/scrobbler/rest.rb
+lib/scrobbler/scrobble.rb
+lib/scrobbler/simpleauth.rb
+lib/scrobbler/tag.rb
+lib/scrobbler/track.rb
+lib/scrobbler/user.rb
+lib/scrobbler/version.rb
+lib/scrobbler.rb
+Manifest
+MIT-LICENSE
+Rakefile
+README.rdoc
+scrobbler.gemspec
+setup.rb
+test/fixtures/xml/album/info.xml
+test/fixtures/xml/artist/fans.xml
+test/fixtures/xml/artist/similar.xml
+test/fixtures/xml/artist/topalbums.xml
+test/fixtures/xml/artist/toptags.xml
+test/fixtures/xml/artist/toptracks.xml
+test/fixtures/xml/tag/topalbums.xml
+test/fixtures/xml/tag/topartists.xml
+test/fixtures/xml/tag/toptags.xml
+test/fixtures/xml/tag/toptracks.xml
+test/fixtures/xml/track/fans.xml
+test/fixtures/xml/track/toptags.xml
+test/fixtures/xml/user/friends.xml
+test/fixtures/xml/user/neighbours.xml
+test/fixtures/xml/user/profile.xml
+test/fixtures/xml/user/recentbannedtracks.xml
+test/fixtures/xml/user/recentlovedtracks.xml
+test/fixtures/xml/user/recenttracks.xml
+test/fixtures/xml/user/systemrecs.xml
+test/fixtures/xml/user/topalbums.xml
+test/fixtures/xml/user/topartists.xml
+test/fixtures/xml/user/toptags.xml
+test/fixtures/xml/user/toptracks.xml
+test/fixtures/xml/user/weeklyalbumchart.xml
+test/fixtures/xml/user/weeklyalbumchart_from_1138536002_to_1139140802.xml
+test/fixtures/xml/user/weeklyartistchart.xml
+test/fixtures/xml/user/weeklyartistchart_from_1138536002_to_1139140802.xml
+test/fixtures/xml/user/weeklychartlist.xml
+test/fixtures/xml/user/weeklytrackchart.xml
+test/fixtures/xml/user/weeklytrackchart_from_1138536002_to_1139140802.xml
+test/mocks/rest.rb
+test/test_helper.rb
+test/unit/album_test.rb
+test/unit/artist_test.rb
+test/unit/chart_test.rb
+test/unit/playing_test.rb
+test/unit/scrobble_test.rb
+test/unit/simpleauth_test.rb
+test/unit/tag_test.rb
+test/unit/track_test.rb
+test/unit/user_test.rb

data/README.rdoc

@@ -0,0 +1,107 @@
+=Scrobbler
+
+Scrobbler is a wrapper for the audioscrobbler web services (http://www.audioscrobbler.net/data/webservices/). 
+
+Below is just a sampling of how easy this lib is to use.
+
+== Users
+
+	user = Scrobbler::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}" }
+	
+== Albums
+	
+	album = Scrobbler::Album.new('Carrie Underwood', 'Some Hearts', :include_info => true)
+
+	puts "Album: #{album.name}"
+	puts "Artist: #{album.artist}"
+	puts "Reach: #{album.reach}"
+	puts "URL: #{album.url}"
+	puts "Release Date: #{album.release_date.strftime('%m/%d/%Y')}"
+
+	puts
+	puts
+
+	puts "Tracks"
+	longest_track_name = album.tracks.collect(&:name).sort { |x, y| y.length <=> x.length }.first.length
+	puts "=" * longest_track_name
+	album.tracks.each { |t| puts t.name }
+	
+==Artists
+	
+	artist = Scrobbler::Artist.new('Carrie Underwood')
+
+	puts 'Top Tracks'
+	puts "=" * 10
+	artist.top_tracks.each { |t| puts "(#{t.reach}) #{t.name}" }
+
+	puts
+
+	puts 'Similar Artists'
+	puts "=" * 15
+	artist.similar.each { |a| puts "(#{a.match}%) #{a.name}" }
+	
+==Tags	
+	
+	tag = Scrobbler::Tag.new('country')
+
+	puts 'Top Albums'
+	tag.top_albums.each { |a| puts "(#{a.count}) #{a.name} by #{a.artist}" }
+
+	puts
+
+	puts 'Top Tracks'
+	tag.top_tracks.each { |t| puts "(#{t.count}) #{t.name} by #{t.artist}" }
+	
+==Tracks
+	
+	track = Scrobbler::Track.new('Carrie Underwood', 'Before He Cheats')
+	puts 'Fans'
+	puts "=" * 4
+	track.fans.each { |u| puts "(#{u.weight}) #{u.username}" }
+	
+== Simple Authentication (for Scrobbling)
+
+    auth = Scrobbler::SimpleAuth.new(:user => 'chunky', :password => 'bacon')
+    auth.handshake!
+
+    puts "Auth Status: #{auth.status}"
+    puts "Session ID: #{auth.session_id}"
+    puts "Now Playing URL: #{auth.now_playing_url}"
+    puts "Submission URL: #{auth.submission_url}"
+
+== Scrobbling
+
+    scrobble = Scrobbler::Scrobble.new(:session_id => auth.session_id,
+                                       :submission_url => auth.submission_url,
+                                       :artist => 'Coldplay',
+                                       :track => 'Viva La Vida',
+                                       :album => "Viva La Vida",
+                                       :time => Time.new,
+                                       :length => 244,
+                                       :track_number => 7)
+    scrobble.submit!
+    puts "Scrobbler Submission Status: #{scrobble.status}"
+
+== Now Playing Submission
+
+    playing = Scrobbler::Playing.new(:session_id => auth.session_id,
+                                     :now_playing_url => auth.now_playing_url,
+                                     :artist => 'Anberlin',
+                                     :track => 'Readyfuels',
+                                     :album => 'Blueprints For the Black Market',
+                                     :length => 218,
+                                     :track_number => 1)
+
+    playing.submit!         
+    puts "Playing Submission Status: #{playing.status}"

data/Rakefile

@@ -0,0 +1,36 @@
+# Rakefile
+require 'rubygems'
+require 'rake'
+require 'echoe'
+require 'lib/scrobbler/version'
+
+WEBSITE_PATH = 'jnunemaker@rubyforge.org:/var/www/gforge-projects/scrobbler'
+
+Echoe.new('scrobbler', Scrobbler::Version) do |p|
+  p.description     = "wrapper for audioscrobbler (last.fm) web services"
+  p.url             = "http://scrobbler.rubyforge.org"
+  p.author          = ['John Nunemaker', 'Jonathan Rudenberg']
+  p.email           = "nunemaker@gmail.com"
+  p.extra_deps      = [['hpricot', '>=0.4.86'], ['activesupport', '>=1.4.2']]
+  p.need_tar_gz     = false
+  p.docs_host       = WEBSITE_PATH
+  p.ignore_pattern  = /website/
+end
+
+desc 'Upload website files to rubyforge'
+task :website do
+  sh %{rsync -av website/ #{WEBSITE_PATH}}
+  Rake::Task['website_docs'].invoke
+end
+
+task :website_docs do
+  Rake::Task['redocs'].invoke
+  sh %{rsync -av doc/ #{WEBSITE_PATH}/docs}
+end
+
+desc 'Preps the gem for a new release'
+task :prepare do
+  %w[manifest build_gemspec].each do |task|
+    Rake::Task[task].invoke
+  end
+end

data/examples/album.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'scrobbler'))
+
+album = Scrobbler::Album.new('Carrie Underwood', 'Some Hearts', :include_info => true)
+
+puts "Album: #{album.name}"
+puts "Artist: #{album.artist}"
+puts "Reach: #{album.reach}"
+puts "URL: #{album.url}"
+puts "Release Date: #{album.release_date.strftime('%m/%d/%Y')}"
+
+puts
+puts
+
+puts "Tracks"
+longest_track_name = album.tracks.collect(&:name).sort { |x, y| y.length <=> x.length }.first.length
+puts "=" * longest_track_name
+album.tracks.each { |t| puts t.name }

data/examples/artist.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'scrobbler'))
+
+artist = Scrobbler::Artist.new('Carrie Underwood')
+
+puts 'Top Tracks'
+puts "=" * 10
+artist.top_tracks.each { |t| puts "(#{t.reach}) #{t.name}" }
+
+puts
+
+puts 'Similar Artists'
+puts "=" * 15
+artist.similar.each { |a| puts "(#{a.match}%) #{a.name}" }

data/examples/scrobble.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'scrobbler'))
+
+auth = Scrobbler::SimpleAuth.new(:user => 'chunky', :password => 'bacon')
+auth.handshake!
+
+puts "Auth Status: #{auth.status}"
+puts "Session ID: #{auth.session_id}"
+puts "Now Playing URL: #{auth.now_playing_url}"
+puts "Submission URL: #{auth.submission_url}"
+
+scrobble = Scrobbler::Scrobble.new(:session_id => auth.session_id,
+                                   :submission_url => auth.submission_url,
+                                   :artist => 'Coldplay',
+                                   :track => 'Viva La Vida',
+                                   :album => 'Viva La Vida',
+                                   :time => Time.new,
+                                   :length => 244,
+                                   :track_number => 7)
+scrobble.submit!
+puts "Scrobbler Submission Status: #{scrobble.status}"
+
+playing = Scrobbler::Playing.new(:session_id => auth.session_id,
+                                 :now_playing_url => auth.now_playing_url,
+                                 :artist => 'Anberlin',
+                                 :track => 'A Day Late',
+                                 :album => 'Never Take Friendship Personal',
+                                 :length => 214,
+                                 :track_number => 5)
+                                 
+playing.submit!         
+puts "Playing Submission Status: #{playing.status}"      

data/examples/tag.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'scrobbler'))
+
+tag = Scrobbler::Tag.new('country')
+
+puts 'Top Albums'
+tag.top_albums.each { |a| puts "(#{a.count}) #{a.name} by #{a.artist}" }
+
+puts
+
+puts 'Top Tracks'
+tag.top_tracks.each { |t| puts "(#{t.count}) #{t.name} by #{t.artist}" }

data/examples/track.rb

@@ -0,0 +1,6 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'scrobbler'))
+
+track = Scrobbler::Track.new('Carrie Underwood', 'Before He Cheats')
+puts 'Fans'
+puts "=" * 4
+track.fans.each { |u| puts "(#{u.weight}) #{u.username}" }

data/examples/user.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'scrobbler'))
+
+user = Scrobbler::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/scrobbler/album.rb

@@ -0,0 +1,143 @@
+# Getting information about an album such as release date and the tracks on it is very easy.
+# 
+#   album = Scrobbler::Album.new('Carrie Underwood', 'Some Hearts', :include_info => true)
+# 
+#   puts "Album: #{album.name}"
+#   puts "Artist: #{album.artist}"
+#   puts "Reach: #{album.reach}"
+#   puts "URL: #{album.url}"
+#   puts "Release Date: #{album.release_date.strftime('%m/%d/%Y')}"
+# 
+#   puts
+#   puts
+# 
+#   puts "Tracks"
+#   longest_track_name = album.tracks.collect(&:name).sort { |x, y| y.length <=> x.length }.first.length
+#   puts "=" * longest_track_name
+#   album.tracks.each { |t| puts t.name }
+#
+# Would output:
+#
+#   Album: Some Hearts
+#   Artist: Carrie Underwood
+#   Reach: 18729
+#   URL: http://www.last.fm/music/Carrie+Underwood/Some+Hearts
+#   Release Date: 11/15/2005
+# 
+# 
+#   Tracks
+#   ===============================
+#   Wasted
+#   Don't Forget to Remember Me
+#   Some Hearts
+#   Jesus, Take the Wheel
+#   The Night Before (Life Goes On)
+#   Lessons Learned
+#   Before He Cheats
+#   Starts With Goodbye
+#   I Just Can't Live a Lie
+#   We're Young and Beautiful
+#   That's Where It Is
+#   Whenever You Remember
+#   I Ain't in Checotah Anymore
+#   Inside Your Heaven
+module Scrobbler
+  class Album < Base
+    attr_accessor :artist, :artist_mbid, :name, :mbid, :playcount, :rank, :url, :reach, :release_date
+    attr_accessor :image_large, :image_medium, :image_small
+    attr_writer :tracks
+    
+    # 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)['name']                    if (xml).at(:artist) && (xml).at(:artist)['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.chartposition = (xml).at(:chartposition).inner_html          if (xml).at(:chartposition)
+        a.rank           = (xml).at(:rank).inner_html                   if (xml).at(:rank)
+        a.url            = (xml/:url).last.inner_html                   if (xml/:url).size > 1
+        a.url            = (xml).at(:url).inner_html                    if a.url.nil? && (xml).at(:url)
+        a.reach          = (xml).at(:reach).inner_html                  if (xml).at(:reach)
+        a.image_large    = (xml).at(:image).at(:large).inner_html       if (xml).at(:image) && (xml).at(:image).at(:large)
+        a.image_medium   = (xml).at(:image).at(:medium).inner_html      if (xml).at(:image) && (xml).at(:image).at(:medium)
+        a.image_small    = (xml).at(:image).at(:small).inner_html       if (xml).at(:image) && (xml).at(:image).at(:small)
+        
+        # coverart element used on top albums for tag
+        a.image_large    = (xml).at(:coverart).at(:large).inner_html    if a.image_large.nil? && (xml).at(:coverart) && (xml).at(:coverart).at(:large)
+        a.image_medium   = (xml).at(:coverart).at(:medium).inner_html   if a.image_medium.nil? && (xml).at(:coverart) && (xml).at(:coverart).at(:medium)
+        a.image_small    = (xml).at(:coverart).at(:small).inner_html    if a.image_small.nil? && (xml).at(:coverart) && (xml).at(:coverart).at(: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 api_path
+      "/#{API_VERSION}/album/#{CGI::escape(artist)}/#{CGI::escape(name)}"
+    end
+    
+    def load_info
+      doc           = self.class.fetch_and_parse("#{api_path}/info.xml")
+      @reach        = (doc).at(:reach).inner_html
+      @url          = (doc).at(:url).inner_html
+      @release_date = Time.parse((doc).at(:releasedate).inner_html.strip)
+      @image_large  = (doc).at(:coverart).at(:large).inner_html
+      @image_medium = (doc).at(:coverart).at(:medium).inner_html
+      @image_small  = (doc).at(:coverart).at(:small).inner_html
+      @mbid         = (doc).at(:mbid).inner_html
+      @tracks       = (doc/:track).inject([]) do |tracks, track|
+        t             = Track.new(artist, track['title'])
+        t.artist_mbid = artist_mbid
+        t.album       = name
+        t.album_mbid  = mbid
+        t.url         = (track).at(:url).inner_html
+        t.reach       = (track).at(:reach).inner_html
+        tracks << t
+        tracks
+      end
+    end
+    
+    def tracks
+      load_info if @tracks.nil?
+      @tracks
+    end
+    
+    def image(which=:small)
+      which = which.to_s
+      raise ArgumentError unless ['small', 'medium', 'large'].include?(which)      
+      img_url = instance_variable_get("@image_#{which}")
+      if img_url.nil?
+        load_info
+        img_url = instance_variable_get("@image_#{which}")
+      end
+      img_url
+    end
+  end
+end

data/lib/scrobbler/artist.rb

@@ -0,0 +1,127 @@
+# Below are examples of how to find an artists top tracks and similar artists.
+# 
+#   artist = Scrobbler::Artist.new('Carrie Underwood')
+# 
+#   puts 'Top Tracks'
+#   puts "=" * 10
+#   artist.top_tracks.each { |t| puts "(#{t.reach}) #{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 Scrobbler
+  class Artist < Base
+    attr_accessor :name, :mbid, :playcount, :rank, :url, :thumbnail, :image, :reach, :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.rank           = (xml).at(:rank).inner_html           if (xml).at(:rank)
+        a.url            = (xml).at(:url).inner_html            if (xml).at(:url)
+        a.thumbnail      = (xml).at(:thumbnail).inner_html      if (xml).at(:thumbnail)
+        a.thumbnail      = (xml).at(:image_small).inner_html    if a.thumbnail.nil? && (xml).at(:image_small)
+        a.image          = (xml).at(:image).inner_html          if (xml).at(:image)
+        a.reach          = (xml).at(:reach).inner_html          if (xml).at(:reach)
+        a.match          = (xml).at(:match).inner_html          if (xml).at(:match)
+        a.chartposition = (xml).at(:chartposition).inner_html  if (xml).at(:chartposition)
+
+        # 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 api_path
+      "/#{API_VERSION}/artist/#{CGI::escape(name)}"
+    end
+    
+    def current_events(format=:ics)
+      format = :ics if format.to_s == 'ical'
+      raise ArgumentError unless ['ics', 'rss'].include?(format.to_s)
+      "#{API_URL.chop}#{api_path}/events.#{format}"
+    end
+    
+    def similar(force=false)
+      get_instance(:similar, :similar, :artist, force)
+    end
+    
+    def top_fans(force=false)
+      get_instance(:fans, :top_fans, :user, force)
+    end
+    
+    def top_tracks(force=false)
+      get_instance(:toptracks, :top_tracks, :track, force)
+    end
+    
+    def top_albums(force=false)
+      get_instance(:topalbums, :top_albums, :album, force)
+    end
+    
+    def top_tags(force=false)
+      get_instance(:toptags, :top_tags, :tag, force)
+    end
+  end
+end

data/lib/scrobbler/base.rb

@@ -0,0 +1,29 @@
+module Scrobbler
+  
+  API_URL     = 'http://ws.audioscrobbler.com/'
+  API_VERSION = '1.0'
+  
+  class Base
+    class << self
+      def connection
+        @connection ||= REST::Connection.new(API_URL)
+      end
+      
+      def fetch_and_parse(resource)
+        Hpricot::XML(connection.get(resource))
+      end
+    end
+    
+    private
+      # in order for subclass to use, it must have api_path method
+      def get_instance(api_method, instance_name, element, force=false)
+        scrobbler_class = "scrobbler/#{element.to_s}".camelize.constantize
+        if instance_variable_get("@#{instance_name}").nil? || force
+          doc      = self.class.fetch_and_parse("#{api_path}/#{api_method}.xml")
+          elements = (doc/element).inject([]) { |elements, el| elements << scrobbler_class.new_from_xml(el, doc); elements }
+          instance_variable_set("@#{instance_name}", elements)
+        end
+        instance_variable_get("@#{instance_name}")
+      end
+  end
+end

data/lib/scrobbler/chart.rb

@@ -0,0 +1,31 @@
+module Scrobbler
+  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