rockstar-custom 0.6.1

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,22 @@
+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
+
+  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/playing.rb

@@ -0,0 +1,50 @@
+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!
+       warn "[DEPRECATION] the `playing` class is deprecated. Please use track.updateNowPlaying"
+       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

data/lib/rockstar/scrobble.rb

@@ -0,0 +1,68 @@
+# exception definitions
+class BadSessionError < StandardError; end
+class RequestFailedError < StandardError; end
+
+module Rockstar
+  class Scrobble
+    # you need to read last.fm/api/submissions#subs first!
+
+    attr_accessor :session_id, :submission_url, :artist, :track, :time,
+                  :source, :length, :album, :track_number, :mb_track_id, :rating
+    attr_reader :status
+
+    def initialize(args = {})
+      @session_id = args[:session_id] # from Rockstar::TokenAuth
+      @submission_url = args[:submission_url] # from Rockstar::TokenAuth (can change)
+      @artist = args[:artist] # track artist
+      @track = args[:track] # track name
+      @time = args[:time] # a Time object set to the time the track started playing
+      @source = args[:source] || 'P' # track source, see last.fm/api/submissions#subs
+      @length = args[:length].to_s || '' # track length in seconds
+      @album = args[:album] || '' # track album name (optional)
+      @track_number = args[:track_number] || '' # track number (optional)
+      @mb_track_id = args[:mb_track_id] || '' # MusicBrainz track ID (optional)
+      @rating = args[:rating] || '' # Rating for clip (optional L=Love, B=Ban (if source=L), S=Skip (if source=L))
+      
+      if [@session_id, @submission_url, @artist, @track].any?(&:blank?)
+        raise ArgumentError, 'Missing required argument'
+      elsif @time.class.to_s != 'Time'
+        raise ArgumentError, ":time must be a Time object"
+      elsif !['P','R','E','U'].include?(@source) # see last.fm/api/submissions#subs
+        raise ArgumentError, "Invalid source"
+      elsif @source == 'P' && @length.blank? # length is not optional if source is P
+        raise ArgumentError, 'Length must be set'
+      elsif !@length.blank? && @length.to_i <= 30 # see last.fm/api/submissions#subs
+        raise ArgumentError, 'Length must be greater than 30 seconds'
+      end
+
+      @connection = REST::Connection.new(@submission_url)
+    end
+
+    def submit!
+       warn "[DEPRECATION] the `scrobble` class is deprecated. Please use track.scrobble"
+       query = { :s => @session_id,
+                'a[0]' => @artist,
+                't[0]' => @track,
+                'i[0]' => @time.utc.to_i,
+                'o[0]' => @source,
+                'r[0]' => @rating,
+                'l[0]' => @length,
+                'b[0]' => @album,
+                'n[0]' => @track_number,
+                'm[0]' => @mb_track_id }
+                
+      @status = @connection.post('', false, query)
+
+      case @status
+      when /OK/
+
+      when /BADSESSION/
+        raise BadSessionError # rerun Rockstar::SimpleAuth#handshake!
+      when /FAILED/
+        raise RequestFailedError, @status
+      else
+        raise RequestFailedError
+      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/simpleauth.rb

@@ -0,0 +1,62 @@
+require 'digest/md5'
+
+# exception definitions
+class BadAuthError < StandardError; end
+class BannedError < StandardError; end
+class BadTimeError < StandardError; end
+module Rockstar
+  AUTH_URL = 'http://post.audioscrobbler.com'
+  AUTH_VER = '1.2.1'
+  
+  # This class is deprecated. Please use TokenAuth instead.
+  class SimpleAuth
+    # you should read last.fm/api/submissions#handshake
+
+    attr_accessor :user, :password, :client_id, :client_ver
+    attr_reader :status, :session_id, :now_playing_url, :submission_url
+
+    def initialize(args = {})
+      warn "[DEPRECATION] This class is deprecated. Please use TokenAuth instead!"
+      
+      @user = args[:user] # last.fm username
+      @password = args[:password] # last.fm password
+      @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? || @password.blank?
+
+      @connection = REST::Connection.new(AUTH_URL)
+    end
+
+    def handshake!
+      password_hash = Digest::MD5.hexdigest(@password)
+      timestamp = Time.now.to_i.to_s
+      token = Digest::MD5.hexdigest(password_hash + timestamp)
+
+      query = { :hs => 'true',
+                :p => AUTH_VER,
+                :c => @client_id,
+                :v => @client_ver,
+                :u => @user,
+                :t => timestamp,
+                :a => token }
+      result = @connection.get('/', false, 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/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