jonaustin-rockstar 0.7.1

data/lib/rockstar/auth.rb

@@ -0,0 +1,38 @@
+module Rockstar
+
+  # = 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}&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.
+  class Auth < Base
+
+    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

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/event.rb

@@ -0,0 +1,73 @@
+module Rockstar
+  class Event < Base
+
+    attr_accessor :eid, :title, :artists, :headliners, :start_date, :end_date,
+                  :description, :attendance, :reviews, :tag, :url, :website, :tickets,
+                  :cancelled, :tags, :images, :venue
+
+    class << self
+      def new_from_xml(xml, doc)
+        e = Event.new(
+          (xml).at(:id).inner_html,
+          (xml).at(:title).inner_html
+        )
+
+        e.artists = []
+        xml.search("/artists/artist").each {|a|
+          e.artists << a.inner_html
+        }
+
+        e.headliners = []
+        xml.search("/artists/headliner").each{|h|
+          e.headliners <<  h.inner_html
+        }
+
+        e.start_date  = Base.parse_time(xml.search("/startDate").inner_html.strip)
+        e.end_date    = Base.parse_time(xml.search("/endDate").inner_html.strip)
+        e.description = xml.search("/description").inner_html.strip
+        e.attendance  = xml.search("/attendance").inner_html.strip.to_i
+        e.reviews     = xml.search("/reviews").inner_html.strip.to_i
+        e.tag         = xml.search("/tag").inner_html.strip
+        e.url         = xml.search("/url").inner_html.strip
+        e.website     = xml.search("/website").inner_html.strip
+        e.cancelled   = xml.search("/cancelled").inner_html.strip == 1
+
+        e.tickets = []
+        xml.search("/tickets/ticket").each{|t|
+          e.tickets << t.inner_html
+        }
+
+        e.tags = []
+        xml.search("/tags/tag").each{|t|
+          e.tags << t.inner_html
+        }
+
+        e.images = {}
+        xml.search('/image').each {|image|
+          e.images[image['size']] = image.inner_html if e.images[image['size']].nil?
+        }
+
+        e.venue = Venue.new_from_xml(xml.search('/venue'), doc) if xml.search('/venue')
+
+        e
+      end
+    end
+
+    def initialize(id, title)
+      raise ArgumentError, "ID is required" if id.blank?
+      raise ArgumentError, "Title is required" if title.blank?
+      @eid   = id
+      @title = title
+    end
+
+    def image(which=:medium)
+      which = which.to_s
+      raise ArgumentError unless ['small', 'medium', 'large', 'extralarge', 'mega'].include?(which)
+      if (self.images.nil?)
+        load_info
+      end
+      self.images[which]
+    end
+  end
+end
+

data/lib/rockstar/geo.rb

@@ -0,0 +1,47 @@
+module Rockstar
+  class Geo < Base
+    # Get events in a specific location. Opts can be
+    #
+    # * :location => 'madrid'  # A city name from geo.metros
+    # * :lat => 50.0, :long => 14.0 # A geo point
+    #
+    # Additionally you can set the distance from that point with
+    #   :distance => 50 # 50 km from the given location
+    #
+    def events(opts = {}, force = false)
+      get_instance("geo.getEvents", :events, :event, opts, force)
+    end
+
+    def metros(country, force = false)
+      get_instance("geo.getMetros", :metros, :metro, {:country => country}, force)
+    end
+
+
+    
+    # Get a list of the Top Artists for a specified country
+    # 
+    # Country is specified in last.fm API docs as 'A country name, as defined by the ISO 3166-1 country names standard'
+    # Not sure of the coverage
+    # 
+    # Also specify limit and page to page through full resultset
+    # 
+    # returns array of Artist instances
+    def topartists(country, limit = nil, page = nil, force = false)
+      get_instance("geo.getTopArtists", :topartists, :artist, {:country => country, :limit => limit, :page => page}, force)
+    end
+    
+    # Get a list of the Top Tracks for a specified country
+    # 
+    # Country is specified in last.fm API docs as 'A country name, as defined by the ISO 3166-1 country names standard'
+    # Not sure of the coverage
+    # 
+    # Also specify limit and page to page through full resultset
+    # 
+    # returns array of Track instances   
+    # TODO: is this the correct object to return? We dont have the full data so is this really best
+    def toptracks(country, limit = nil, page = nil, force = false)
+      get_instance("geo.getTopTracks", :toptracks, :track, {:country => country, :limit => limit, :page => page}, force)
+    end    
+
+  end
+end

data/lib/rockstar/library.rb

@@ -0,0 +1,13 @@
+module Rockstar
+  class Library < Base
+
+    def artists(force=false, options = {})
+      get_instance("library.getArtists", :artists, :artist, options, force)
+    end
+    
+    def albums(force=false, options = {})
+      get_instance("library.getAlbums", :albums, :album, options, force)
+    end
+
+  end
+end

data/lib/rockstar/metro.rb

@@ -0,0 +1,26 @@
+module Rockstar
+  class Metro < Base
+
+    attr_accessor :name, :country
+
+    class << self
+      def new_from_xml(xml, doc)
+        Metro.new(
+          (xml).at(:name).inner_html,
+          (xml).at(:country).inner_html
+        )
+      end
+    end
+
+    def initialize(name, country)
+      raise ArgumentError, "Name is required" if name.blank?
+      raise ArgumentError, "Country is required" if country.blank?
+      @name = name
+      @country = country
+    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

data/lib/rockstar/session.rb

@@ -0,0 +1,19 @@
+module Rockstar
+  class Session < Base
+    attr_accessor :username, :key, :subscriber
+
+    class << self
+      def new_from_xml(xml, doc=nil)
+        t       = Session.new()
+        t.username  = (xml).at(:name).inner_html
+        t.key   = (xml).at(:key).inner_html
+        t.subscriber   = (xml).at(:subscriber).inner_html
+        t
+      end
+    end
+  end
+end
+
+
+
+

data/lib/rockstar/tag.rb

@@ -0,0 +1,100 @@
+# Below is code samples for how to find the top albums and tracks for a tag.
+#
+#   tag = Rockstar::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}" }
+#
+# Which would output something similar to:
+#
+#   Top Albums
+#   (29) American IV: The Man Comes Around by Johnny Cash
+#   (14) Folks Pop In at the Waterhouse by Various Artists
+#   (13) Hapless by Flowers From The Man Who Shot Your Cousin
+#   (9) Taking The Long Way by Dixie Chicks
+#   (8) Unchained by Johnny Cash
+#   (8) American III: Solitary Man by Johnny Cash
+#   (8) Wide Open Spaces by Dixie Chicks
+#   (7) It's Now or Later by Tangled Star
+#   (7) Greatest Hits by Hank Williams
+#   (7) American Recordings by Johnny Cash
+#   (6) Forgotten Landscape by theNoLifeKing
+#   (6) At Folsom Prison by Johnny Cash
+#   (6) Fox Confessor Brings the Flood by Neko Case
+#   (6) Murder by Johnny Cash
+#   (5) Gloom by theNoLifeKing
+#   (5) Set This Circus Down by Tim McGraw
+#   (5) Blacklisted by Neko Case
+#   (5) Breathe by Faith Hill
+#   (5) Unearthed (disc 4: My Mother's Hymn Book) by Johnny Cash
+#   (4) Home by Dixie Chicks
+#
+#   Top Tracks
+#   (221) Hurt by Johnny Cash
+#   (152) I Walk the Line by Johnny Cash
+#   (147) Ring of Fire by Johnny Cash
+#   (125) Folsom Prison Blues by Johnny Cash
+#   (77) The Man Comes Around by Johnny Cash
+#   (67) Personal Jesus by Johnny Cash
+#   (65) Not Ready To Make Nice by Dixie Chicks
+#   (63) Before He Cheats by Carrie Underwood
+#   (62) Give My Love to Rose by Johnny Cash
+#   (49) Jackson by Johnny Cash
+#   (49) What Hurts The Most by Rascal Flatts
+#   (48) Big River by Johnny Cash
+#   (46) Man in Black by Johnny Cash
+#   (46) Jolene by Dolly Parton
+#   (46) Friends in Low Places by Garth Brooks
+#   (46) One by Johnny Cash
+#   (44) Cocaine Blues by Johnny Cash
+#   (41) Get Rhythm by Johnny Cash
+#   (41) I Still Miss Someone by Johnny Cash
+#   (40) The Devil Went Down to Georgia by Charlie Daniels Band
+module Rockstar
+  class Tag < Base
+    attr_accessor :name, :count, :url
+
+    class << self
+      def new_from_xml(xml, doc=nil)
+        name    = (xml).at(:name).inner_html
+        t       = Tag.new(name)
+        t.count = (xml).at(:count).inner_html
+        t.url   = Base.fix_url((xml).at(:url).inner_html)
+        t
+      end
+
+      def top_tags
+        doc = fetch_and_parse("tag.getTopTags")
+        @top_tags = (doc/"toptags/tag").collect do |tag|
+          t       = Tag.new((tag/'name').inner_html)
+          t.count = (tag/'count').inner_html
+          t.url   = Base.fix_url((tag/'url').inner_html)
+          t
+        end
+      end
+    end
+
+    def initialize(name)
+      raise ArgumentError, "Name is required" if name.blank?
+      @name = name
+    end
+
+
+    def top_artists(force=false)
+      get_instance("tag.getTopArtists", :top_artists, :artist, {:tag => @name}, force)
+    end
+
+    def top_albums(force=false)
+      get_instance("tag.getTopAlbums", :top_albums, :album, {:tag => @name}, force)
+    end
+
+    def top_tracks(force=false)
+      get_instance("tag.getTopTracks", :top_tracks, :track, {:tag => @name}, force)
+    end
+  end
+end