scrobbler-ng 2.0.0

data/lib/scrobbler/base.rb

@@ -0,0 +1,124 @@
+require 'digest/md5'
+
+$KCODE = 'u'
+
+include LibXML
+
+module Scrobbler
+  
+  API_URL     = 'http://ws.audioscrobbler.com/'
+  
+class Base
+    def Base.api_key=(api_key) 
+        @@api_key = api_key
+    end
+
+    def Base.secret=(secret)
+        @@secret = secret
+    end
+
+    def Base.connection
+        @connection ||= REST::Connection.new(API_URL)
+    end
+    
+    def Base.sanitize(param)
+      URI.escape(param.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    end
+
+    def Base.camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      else
+        lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+      end
+    end
+
+    def Base.constanize(camel_cased_word)
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    end
+    
+    def Base.get(api_method, parent, element, parameters = {})
+        scrobbler_class = constanize(camelize("scrobbler/#{element.to_s}"))
+        doc = request(api_method, parameters)
+        elements = []
+        doc.root.children.each do |child|
+            next unless child.name == parent.to_s
+            child.children.each do |child2|
+                next unless child2.name == element.to_s
+                elements << scrobbler_class.new_from_libxml(child2)
+            end
+        end
+        elements
+    end
+
+    def Base.post_request(api_method, parameters = {}, request_method = 'get')
+      Base.request(api_method, parameters, 'post')
+    end
+
+    def Base.request(api_method, parameters = {}, request_method = 'get')
+      parameters = {:signed => false}.merge(parameters)
+      parameters['api_key'] = @@api_key
+      parameters['method'] = api_method.to_s
+      paramlist = []
+      # Check if we want a signed call and pop :signed
+      if parameters.delete :signed
+        #1: Sort alphabetically
+        params = parameters.sort{|a,b| a[0].to_s<=>b[0].to_s}
+        #2: concat them into one string
+        str = params.join('')
+        #3: Append secret
+        str = str + @@secret
+        #4: Make a md5 hash
+        md5 = Digest::MD5.hexdigest(str)
+        params << [:api_sig, md5]
+        params.each do |a|
+          paramlist << "#{sanitize(a[0])}=#{sanitize(a[1])}"
+        end
+      else
+        parameters.each do |key, value|
+          paramlist << "#{sanitize(key)}=#{sanitize(value)}"
+        end
+      end
+      url = '/2.0/?' + paramlist.join('&')
+      XML::Document.string(self.connection.send(request_method,url))
+    end
+    
+    
+    private
+      
+    def Base.mixins(*args)
+      args.each do |arg|
+        if arg == :image
+          extend Scrobbler::ImageClassFuncs
+          include Scrobbler::ImageObjectFuncs
+        elsif arg == :streamable
+          attr_reader :streamable
+          extend StreamableClassFuncs
+          include StreamableObjectFuncs
+        else
+          raise ArgumentError, "#{arg} is not a known mixin"
+        end
+      end
+    end
+    
+      def populate_data(data = {})
+        data.each do |key, value|
+          instance_variable_set("@#{key.to_s}", value)
+        end
+      end
+
+      def get_response(api_method, instance_name, parent, element, params, force=false)
+        if instance_variable_get("@#{instance_name}").nil? || force
+            instance_variable_set("@#{instance_name}", Base.get(api_method, parent, element, params))
+        end
+        instance_variable_get("@#{instance_name}")
+      end
+end # class Base
+end # module Scrobbler

data/lib/scrobbler/event.rb

@@ -0,0 +1,105 @@
+module Scrobbler
+  class Event < Base
+    # Load Helper modules
+    include ImageObjectFuncs
+    extend  ImageClassFuncs
+    
+    attr_accessor :id, :title, :start_date, :start_time, :description
+    attr_accessor :reviews, :tag, :url, :artists, :headliner, :image_small
+    attr_accessor :image_medium, :image_large, :attendance, :venue
+    
+    class << self
+
+      def update_or_create_from_xml(xml, event=nil)
+        data = {}
+        artists = []
+        headliner = nil
+        venue = nil
+
+        xml.children.each do |child|
+          data[:id] = child.content.to_i if child.name == 'id'
+          data[:title] = child.content if child.name == 'title'
+
+          if child.name == 'artists'
+            child.children.each do |artist_element|
+              artists << Artist.new(artist_element.content) if artist_element.name == 'artist'
+              headliner = Artist.new(artist_element.content) if artist_element.name == 'headliner'
+            end
+            artists << headliner unless headliner.nil? || headliner_alrady_listed_in_artist_list?(artists,headliner)
+          end
+
+          maybe_image_node(data, child)
+          data[:url] = child.content if child.name == 'url'
+          data[:description] = child.content if child.name == 'description'
+          data[:attendance] = child.content.to_i if child.name == 'attendance'
+          data[:reviews]    = child.content.to_i if child.name == 'reviews'
+          data[:tag]        = child.content if child.name == 'tag'
+          data[:start_date] = Time.parse(child.content) if child.name == 'startDate'
+          data[:start_time] = child.content if child.name == 'startTime'
+          venue = Venue.new_from_xml(child) if child.name == 'venue'
+        end
+
+        if event.nil?
+          event = Event.new(data[:id],data)
+        else
+          event.send :populate_data, data
+        end
+
+        event.artists = artists.uniq
+        event.headliner = headliner
+        event.venue = venue
+        event
+      end
+
+      def headliner_alrady_listed_in_artist_list?(artists,headliner)
+        artists.each do |artist|
+          return true if artist.name == headliner.name
+        end
+        false
+      end
+
+      def new_from_libxml(xml)
+        update_or_create_from_xml(xml)
+      end
+    end
+
+    def initialize(id,input={})
+      raise ArgumentError if id.nil?
+      @id = id
+      populate_data(input)
+      load_info() if input[:include_info]
+    end
+
+    def shouts(force = false)
+      get_response('event.getshouts', :shouts, 'shouts', 'shout', {'event'=>@id}, force)
+    end
+
+    def attendees(force = false)
+      get_response('event.getattendees', :attendees, 'attendees', 'user', {'event'=>@id}, force)
+    end
+
+    def shout
+      # This function require authentication, but SimpleAuth is not yet 2.0
+      raise NotImplementedError
+    end
+
+    def attend(session, attendance_status)
+      doc = Base.post_request('event.attend',{:event => @id, :signed => true, :status => attendance_status, :sk => session.key})
+    end
+
+    def share
+      # This function require authentication, but SimpleAuth is not yet 2.0
+      raise NotImplementedError
+    end
+
+    # Load additional informatalbumion about this event
+    #
+    # Calls "event.getinfo" REST method
+    def load_info
+      doc = Base.request('event.getinfo', {'event' => @id})
+      doc.root.children.each do |child|        
+        Event.update_or_create_from_xml(child, self) if child.name == 'event'
+      end      
+    end
+  end
+end

data/lib/scrobbler/geo.rb

@@ -0,0 +1,27 @@
+module Scrobbler
+  class Geo < Base
+
+    # Gets a list of events based on the location that
+    # the Geo object is set to
+    def events(options={})
+      options = set_default_options(options)
+      get_response('geo.getevents', :events, 'events', 'event', options, options[:force])
+    end
+
+    def top_artists(options={})
+      options = set_default_options(options)
+      get_response('geo.gettopartists', :artists, 'topartists', 'artist', options, options[:force])
+    end
+
+    def top_tracks(options={})
+      options = set_default_options(options)
+      get_response('geo.gettoptracks', :tracks, 'toptracks', 'track', options, options[:force])
+    end
+
+    private
+
+    def set_default_options(options={})
+      {:force => false, :page => 1}.merge options
+    end
+  end
+end

data/lib/scrobbler/helper/image.rb

@@ -0,0 +1,52 @@
+module Scrobbler
+  # Defines some functions that are used nearly all Scrobbler classes which
+  # have to deal with image references.
+  #
+  # This module defines the class functions, use "extend ImageClassFuncs" in
+  # class.
+  module ImageClassFuncs
+    # Check if the given libxml node is an image referencing node and in case
+    # of, read it into that given hash of data 
+    def maybe_image_node(data, node)
+      if node.name == 'image'
+        data[:image_small] = node.content if node['size'] == 'small'
+        data[:image_medium] = node.content if node['size'] == 'medium'
+        data[:image_large] = node.content if node['size'] == 'large'
+        data[:image_extralarge] = node.content if node['size'] == 'extralarge'
+      end
+    end
+  end
+  
+  # Defines some functions that are used nearly all Scrobbler classes which
+  # have to deal with image references.
+  #
+  # This module defines the object functions, use "include ImageObjectFuncs" in
+  # class.
+  module ImageObjectFuncs
+    # Check if the given libxml node is an image referencing node and in case
+    # of, read it into the object
+    def check_image_node(node)
+      if node.name == 'image'
+        @image_small = node.content if node['size'] == 'small'
+        @image_medium = node.content if node['size'] == 'medium'
+        @image_large = node.content if node['size'] == 'large'
+        @image_extralarge = node.content if node['size'] == 'extralarge'
+      end
+    end
+    
+    # Return the URL to the specified image size.
+    #
+    # If the URL to the given image size is not known and a 
+    # 'load_info'-function is defined, it will be called.
+    def image(which=:small)
+      which = which.to_s
+      raise ArgumentError unless ['small', 'medium', 'large', 'extralarge'].include?(which)      
+      img_url = instance_variable_get("@image_#{which}")
+      if img_url.nil? && responds_to?(:load_info) 
+        load_info 
+        img_url = instance_variable_get("@image_#{which}")
+      end
+      img_url
+    end
+  end
+end

data/lib/scrobbler/helper/streamable.rb

@@ -0,0 +1,40 @@
+module Scrobbler
+  # Defines some functions that are used nearly all Scrobbler classes which
+  # have to deal with the streamable flag.
+  #
+  # This module defines the class functions, use "extend StreamableClassFuncs" in
+  # class.
+  module StreamableClassFuncs
+    # Check if the given libxml node is defining if the given content is 
+    # streamable. If so, set the flag in the given hash
+    def Base.maybe_streamable_node(data, node)
+      if node.name == 'streamable'
+        data[:streamable] = ['1', 'true'].include?(node.content)
+      end
+    end
+    
+    # Check if the given libxml node has a streamable attribute defining if the
+    # given content is streamable. If so, set the flag in the given hash
+    def Base.maybe_streamable_attribute(data, node)
+      if node['streamable']
+        data[:streamable] = ['1', 'true'].include?(node['streamable'])
+      end
+    end
+    
+  end
+  
+  # Defines some functions that are used nearly all Scrobbler classes which
+  # have to deal with the streamable flag.
+  #
+  # This module defines the object functions, use "include StreamableObjectFuncs" in
+  # class.
+  module StreamableObjectFuncs
+    # Check if the given libxml node is defining if the given content is 
+    # streamable. If so, set the flag in the object
+    def check_streamable_node(node)
+      if node.name == 'streamable'
+        @streamable = ['1', 'true'].include?(node.content)
+      end
+    end
+  end
+end

data/lib/scrobbler/library.rb

@@ -0,0 +1,123 @@
+module Scrobbler
+  # Class for invocation of library.* API functions.
+  class Library < Base
+    attr_reader :user
+  
+    # Create a new Scrobber::Library instance.
+    #
+    # @param [String, Symbol, Scrobbler::User] user The user who's library data
+    #   is requested.
+    # @raise ArgumentError If a not supported type is given as user.
+    def initialize(user)
+      case user.class
+        when user.class == Scrobbler::User
+          @user = user
+        when [String, Symbol].contains?(user.class)
+          @user = Scrobbler::User.new(user.to_s)
+        else
+          raise ArgumentError("Invalid argument for user.")
+      end
+    end
+    
+    def add_album
+        # This function require authentication, but SimpleAuth is not yet 2.0
+        raise NotImplementedError
+    end
+    
+    def add_artist
+        # This function require authentication, but SimpleAuth is not yet 2.0
+        raise NotImplementedError
+    end
+    
+    def add_track
+      # This function require authentication, but SimpleAuth is not yet 2.0
+      raise NotImplementedError
+    end
+    
+    # A list of all the albums in a user's library, with play counts and tag 
+    # counts. 
+    def albums(options={})
+        options = {:force => false, :all => true}.merge options
+        options[:user] = @user.name
+        albums = []
+        if options[:all]
+            doc = Base.request('library.getalbums', options)
+            root = nil
+            doc.root.children.each do |child|
+                next unless child.name == 'albums'
+                root = child
+            end
+            total_pages = root['totalPages'].to_i
+            root.children.each do |child|
+                next unless child.name == 'album'
+                albums << Scrobbler::Album.new_from_libxml(child)
+            end
+            for i in 2..total_pages do
+                options[:page] = i
+                albums.concat get_response('library.getalbums', :none, 'albums', 'album', options, true)
+            end
+        else
+            albums = get_response('library.getalbums', :get_albums, 'albums', 'album', options, true)
+        end
+        albums
+    end
+
+    # A list of all the artists in a user's library, with play counts and tag
+    # counts. 
+    def artists(options={})
+        options = {:force => false, :all => true}.merge options
+        options[:user] = @user.name
+        artists = []
+        if options[:all]
+            doc = Base.request('library.getartists', options)
+            root = nil
+            doc.root.children.each do |child|
+                next unless child.name == 'artists'
+                root = child
+            end
+            total_pages = root['totalPages'].to_i
+            root.children.each do |child|
+                next unless child.name == 'artist'
+                artists << Scrobbler::Artist.new_from_libxml(child)
+            end
+            for i in 2..total_pages do
+                options[:page] = i
+                artists.concat get_response('library.getartists', :none, 'artists', 'artist', options, true)
+            end
+        else
+            artists = get_response('library.getartists', :get_albums, 'artists', 'artist', options, true)
+        end
+        artists
+    end
+    
+    # A list of all the tracks in a user's library, with play counts and tag
+    # counts. 
+    def tracks(options={})
+        options = {:force => false, :all => true}.merge options
+        options[:user] = @user.name
+        tracks = []
+        if options[:all]
+            doc = Base.request('library.gettracks', options)
+            root = nil
+            doc.root.children.each do |child|
+                next unless child.name == 'tracks'
+                root = child
+            end
+            total_pages = root['totalPages'].to_i
+            root.children.each do |child|
+                next unless child.name == 'track'
+                tracks << Scrobbler::Track.new_from_libxml(child)
+            end
+            for i in 2..total_pages do
+                options[:page] = i
+                tracks.concat get_response('library.gettracks', :none, 'tracks', 'track', options, true)
+            end
+        else
+            tracks = get_response('library.gettracks', :get_albums, 'tracks', 'track', options, true)
+        end
+        tracks
+    end
+    
+  end
+end
+

data/lib/scrobbler/playing.rb

@@ -0,0 +1,49 @@
+module Scrobbler
+  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 Scrobbler::SimpleAuth
+      @now_playing_url = args[:now_playing_url] # from Scrobbler::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?(&:empty?)
+        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('', query)
+
+      case @status
+      when /OK/
+
+      when /BADSESSION/
+        raise BadSessionError # rerun Scrobbler::SimpleAuth#handshake!
+      else
+        raise RequestFailedError
+      end
+    end
+  end
+end

data/lib/scrobbler/playlist.rb

@@ -0,0 +1,45 @@
+module Scrobbler
+  # @todo everything
+  class Playlist < Base
+    # Load Helper modules
+    include ImageObjectFuncs
+    extend  ImageClassFuncs
+    
+    attr_reader :url, :id, :title, :date, :creator
+    attr_reader :description, :size, :duration, :streamable
+    class << self
+      def new_from_libxml(xml)
+        data = {}
+
+        xml.children.each do |child|
+          data[:id] = child.content.to_i if child.name == 'id'
+          data[:title] = child.content if child.name == 'title'
+
+          maybe_image_node(data, child)
+          data[:date] = Time.parse(child.content) if child.name == 'date'
+
+          data[:size] = child.content.to_i if child.name == 'size'
+          data[:description] = child.content if child.name == 'description'
+          data[:duration] = child.content.to_i if child.name == 'duration'
+
+          if child.name == 'streamable'
+            if ['1', 'true'].include?(child.content)
+              data[:streamable] = true
+            else
+              data[:streamable] = false
+            end
+          end
+          data[:creator]        = child.content if child.name == 'creator'
+          data[:url]        = child.content if child.name == 'url'
+        end
+        Playlist.new(data[:url],data)
+      end
+    end
+  
+    def initialize(url,data={})
+      @url = url
+      populate_data(data)
+    end
+  end
+end
+

data/lib/scrobbler/radio.rb

@@ -0,0 +1,12 @@
+module Scrobbler
+  # @todo everything
+  class Radio < Base
+    attr_reader :station
+  
+    def initialize(station)
+      @station = station
+    end
+    
+  end
+end
+

data/lib/scrobbler/rest.rb

@@ -0,0 +1,47 @@
+require 'net/https'
+
+module Scrobbler
+  module REST
+  	class Connection
+  		def initialize(base_url, args = {})
+  			@base_url = base_url
+  			@username = args[:username]
+  			@password = args[:password]
+  		end
+
+  		def get(resource, args = nil)
+  			request(resource, "get", args)
+  		end
+
+  		def post(resource, args = nil)
+  			request(resource, "post", args)
+  		end
+
+  		def request(resource, method = "get", args = nil)
+  			url = URI.join(@base_url, resource)
+
+  			if args
+  				# TODO: What about keys without value?
+  				url.query = args.map { |k,v| "%s=%s" % [URI.encode(k.to_s), URI.encode(v.to_s)] }.join("&")
+  			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
+  	end
+  end
+end