hornairs-scrobbler 0.2.3

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,112 @@
+module Scrobbler
+  # @todo everything
+  class Library < Base
+    attr_reader :user
+  
+    def initialize(user)
+      @user = user if user.class == Scrobbler::User
+      @user = Scrobbler::User.new(user.to_s) unless user.class == Scrobbler::User
+    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?(&: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!
+      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,87 @@
+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 url_for_album(album_id)
+        "lastfm://playlist/album/"+album_id.to_s
+      end
+      
+      def url_for_playlist(playlist_id)
+        "lastfm://playlist/album/"+playlist_id.to_s
+      end
+      
+      def new_from_album(album)
+        pp album.class
+        raise ArgumentError, "Must create a playlist from an album object" if album.class != Scrobbler::Album
+        Playlist.new(url_for_album(album.album_id))
+      end
+      
+      def new_from_xml(xml)
+        data = data_from_xml(xml)
+        puts "Creating Playlist: #{data[:title]}"
+        return nil if data[:title].nil?
+        Playlist.new(data[:url],data)
+      end
+      
+      def data_from_xml(xml, o = {})      
+        o = {:include_track_info => true}.merge(o)
+        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
+          
+          if child.name == 'trackList'
+            data[:tracks] = []
+            child.children.each do |grandchild|
+              data[:tracks] << Track.new_from_xml(grandchild, o) if grandchild.name == 'track'
+            end
+          end
+          data[:creator] = child.content if child.name == 'creator'
+          data[:url]     = child.content if child.name == 'url'
+        end
+        data
+      end
+    end
+  
+    def initialize(url,data={})
+      @url = url
+      fetch() unless data[:include_info] && data[:include_info] == false
+    end
+    
+    def fetch() 
+      #Since playlists aren't static in the same sense the other objects are, dont cache results, always fetch the lastest version.
+      xml = Base.request('playlist.fetch', {:playlistURL => @url});
+      unless xml.root['status'] == 'failed'
+        xml.root.children.each do |child|
+          next unless child.name == 'playlist'
+          data = self.class.data_from_xml(child, {:include_track_info => false, :include_album_info => false})
+          populate_data(data)
+          break
+        end # xml.children.each do |child|
+      end
+    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

data/lib/scrobbler/scrobble.rb

@@ -0,0 +1,116 @@
+# exception definitions
+class BadAuthError < StandardError; end
+class BadSessionError < StandardError; end
+class BadTimeError < StandardError; end
+class ClientBannedError < StandardError; end
+class RequestFailedError < StandardError; end
+
+module Scrobbler
+  class Scrobble
+    SUBMISSION_HOST = 'http://post.audioscrobbler.com:80/'
+    SUBMISSION_PORT = 80
+    SUBMISSION_VERSION = '1.2.1'
+    
+    @@client_id = 'tst'
+    @@client_ver = '1.0'
+    @@default_options = {
+      :handshake_on_init => true
+    }
+
+    def Scrobble.client_id=(cid)
+      @@client_id = cid
+    end
+    
+    def Scrobble.client_ver=(cver)
+      @@client_ver = cver
+    end
+    
+    def initialize(options={})
+      params = @@default_options.merge(options)
+      warn 'Warning: Default client id used, this is for testing only' if @@client_id == 'tst'
+      raise ArgumentError, 'Session is required' if params[:session].nil?
+      raise ArgumentError, 'User is required' if params[:user].nil?
+      @session = params[:session]
+      @user = params[:user]
+    end
+    
+    def handshake
+      ts = Time.now.to_i.to_s
+      auth_token = Digest::MD5.hexdigest(@session.key + ts)
+      params = {
+        :hs => 'true',
+        :ps => SUBMISSION_VERSION,
+        :c => @@client_id,
+        :v => @@client_ver,
+        :u => @user.name,
+        :t => ts,
+        :a => auth_token,
+        :sk => @session.key
+      }
+      url = URI.join(SUBMISSION_HOST)
+      query = []
+      params.each do |k,v|
+        query << [Base.sanitize(k), Base.sanitize(v)]
+      end
+      url.query = query.join('&')
+      req = Net::HTTP::Get.new(url.request_uri)
+      res = Net::HTTP.start(SUBMISSION_HOST, SUBMISSION_PORT) do |conn|
+        conn.request(req)
+      end
+      res = res.body.split("\n")
+      if res[0] == 'OK'
+        # Handshake done, parse and return information
+        @session_id = res[1]
+        @now_playing_url = res[2]
+        @submission_url = res[3]
+      elsif res[0] == 'BANNED'
+        # This indicates that this client version has been banned from the
+        # server. This usually happens if the client is violating the protocol
+        # in a destructive way. Users should be asked to upgrade their client
+        # application.
+        raise ClientBannedError, 'Please update your client to a newer version.'
+      elsif res[0] == 'BADAUTH'
+        # This indicates that the authentication details provided were incorrect. 
+        # The client should not retry the handshake until the user has changed 
+        # their details
+        raise BadAuthError
+      elsif res[0] == 'BADTIME'
+        # The timestamp provided was not close enough to the current time. 
+        # The system clock must be corrected before re-handshaking.
+        raise BadTimeError, "Not close enough to current time: #{ts}"
+      else
+        # This indicates a temporary server failure. The reason indicates the
+        # cause of the failure. The client should proceed as directed in the
+        # failure handling section
+        raise RequestFailedError, res[0]
+      end
+    end #^ handshake
+    
+    def now_playing(track)
+      params = {
+        's' => @session_id,
+        't' => track.name,
+        'a' => track.artist.name,
+        'b' => '',
+        'l' => '',
+        'n' => '',
+        'm' => ''
+      }
+      params['b'] = track.album.name unless track.album.nil?
+      params['l'] = track.duration.to_s unless track.duration.nil? && track.duration > 30
+      # @todo params['n']
+      params['m'] = track.mbid unless track.mbid.nil?
+      res = Net::HTTP.post_form(URI.parse(SUBMISSION_HOST), params).body.split("\n")
+      if res[0] == 'BADSESSION'
+        # This indicates that the Session ID sent was somehow invalid, possibly
+        # because another client has performed a handshake for this user. On
+        # receiving this, the client should re-handshake with the server before
+        # continuing. 
+        raise BadSessionError
+      end
+    end #^ now_playing
+    
+    def submit(tracks={})
+    end #^ submit
+  end
+end