bts-mbws 0.0.1

data/lib/mbws/artist.rb

@@ -0,0 +1,84 @@
+module MBWS
+  # Top of the artist documentation page
+  class Artist < Resource
+    
+    attr_accessor :name,:sort_name,:type,:begin,:end,:disambiguation
+    
+    def initialize(hash,options = {})
+      @aliases = nil
+      
+      super
+      
+      attrs = ["name","type","disambiguation","sort-name"]
+      attrs.each do |a|
+        self.instance_variable_set("@#{a.gsub('-','_')}",hash[a])
+      end
+      
+      @begin = hash["life-span"]["begin"] if hash["life-span"]
+      @end = hash["life-span"]["end"] if hash["life-span"]
+      
+    end
+    
+    def aliases
+      return @aliases if @aliases
+      artist_xml = Request.get("artist/#{self.mid}",:inc => "aliases")
+      parse_aliases(artist_xml["artist"][0])
+      @aliases
+    end
+    
+    # Return releases where artist is the primary artist (Single Artist Albums).
+    #
+    # Cached
+    def releases()
+      @releases if @releases
+      @releases = Release.find(:artistid => self.mid, :inc => "counts",:limit => 100)
+    end
+
+    # 
+    def releases_find(options = {})
+      options.merge!(:artistid => self.mid, :inc => "counts")
+      Release.find(options)
+    end
+    
+    #
+    def va_releases(options)
+      _inc_releases("va-",options)
+    end
+
+    def sa_releases(options)
+      _inc_releases("sa-",options)
+    end
+    
+    def all_va_releases
+      _all_inc_releases("va-")
+    end
+    
+    def all_sa_releases
+      _all_inc_releases("sa-")
+    end
+
+    private
+    def _inc_releases(prefix,options)
+      inc = []
+      [:type, :status].each do |k|
+        inc.push(prefix + options[k].to_s) if options.include?(k)
+      end
+      
+      releases = []
+      xml = Request.get("artist/#{self.mid}", :inc => inc)
+      xml["artist"][0]["release-list"]["release"].each do |rxml|
+        releases.push(Release.new(rxml,{}))
+      end if ["artist"][0]["release-list"]
+      releases
+    end
+
+    def _all_inc_releases(prefix)
+      all = []
+      [:Official, :Promotion, :Bootleg, :PseudoRelease].each do |status|
+        sleep 1
+        all.push(_inc_releases(prefix,:status => status))
+      end
+      all.compact
+    end
+  end
+end

data/lib/mbws/artist_relations.rb

@@ -0,0 +1,6 @@
+module MBWS
+  module Relations
+      class ArtistRelations < RelationsBase
+      end
+    end
+end

data/lib/mbws/base.rb

@@ -0,0 +1,7 @@
+module MBWS
+  class Base
+    DEFAULT_HOST = "www.musicbrainz.org"
+    DEFAULT_PATH = "/ws/1/"
+    DEFAULT_LIMIT = 25
+  end
+end

data/lib/mbws/exceptions.rb

@@ -0,0 +1,25 @@
+module MBWS
+  class MBWSException < StandardError
+  end
+  
+  class ResponseError < MBWSException
+  end
+
+  class MBIDNotFound < ResponseError
+  end
+
+  class BadRequest < ResponseError
+  end
+
+  class InvalidUUID < MBWSException
+    def initialize(invalid_id)
+      message = "'#{invalid_id} is not a valid MBID (UUID).  "  +
+                "MBIDs must be 36 characters long "             +
+                "(ex. c0b2500e-0cef-4130-869d-732b23ed9df5). "  +
+                "Please consult the Web Service Documentation " +
+                "(http://musicbrainz.org/doc/XMLWebService) for"+
+                " more information. "
+      super(message)
+    end
+  end
+end

data/lib/mbws/label.rb

@@ -0,0 +1,35 @@
+module MBWS
+  class Label < Resource
+    attr_accessor :name,:type,:disambiguation,:begin,:end,:label_code,:country
+    
+    def initialize(hash,options)
+      @aliases = nil
+      
+      super
+
+      attrs = ["name","type","disambiguation","label-code","country"]
+      attrs.each do |a|
+        self.instance_variable_set("@#{a.gsub('-','_')}",hash[a])
+      end
+
+      if options.has_key?(:inc)
+        options[:inc].map {|i| i.gsub(/-/,"_")}.each do |s|
+          self.send "parse_" + s,hash unless s.match(/rels/)
+        end
+      end
+      
+      @begin = hash["life-span"]["begin"] if hash["life-span"]
+      @end = hash["life-span"]["end"] if hash["life-span"]
+    end
+    
+    def aliases
+      return @aliases if @aliases
+      label_xml = Request.get("label/#{self.mid}",:inc => "aliases")
+      parse_aliases(label_xml["label"][0])
+      @aliases
+    end
+
+    private
+
+  end
+end

data/lib/mbws/label_relations.rb

@@ -0,0 +1,6 @@
+module MBWS
+  module Relations
+    class LabelRelations < RelationsBase
+    end
+  end
+end

data/lib/mbws/parsing.rb

@@ -0,0 +1,43 @@
+#:stopdoc:
+# A lot of this is based on...errr taken...from the AWS::S3 module (http://amazon.rubyforge.org/) 
+# by Marcel Molina <marcel@vernix.org>
+module MBWS
+  module Parsing
+    class XmlParser < Hash
+      
+      attr_reader :body, :xml_in, :root
+
+      def initialize(body)
+        @body = body
+        update(parse)
+#        set_root
+ #       typecast_xml_in
+      end
+
+      private
+        
+        def parse
+          @xml_in = XmlSimple.xml_in(@body, parsing_options)
+        end
+
+        def parsing_options
+          {
+          # Force nested elements to be put into an array, even if there is only on of them.
+          'forcearray' => ['relation','artist','release','relation-list','disc','track','label','url'],
+
+          'KeyAttr' => ['target-type']
+          }
+        end
+        def set_root
+          @root = @xml_in.keys.first.underscore
+        end
+        def typecast_xml_in
+          typecast_xml = {}
+          @xml_in.dup.each do |k,v|
+            #typecast_xml[k.underscore] = typecast(v)
+          end
+          update(typecast_xml[root]) if typecase_xml[root].is_a?(Hash)
+        end
+    end
+  end
+end

data/lib/mbws/relations.rb

@@ -0,0 +1,43 @@
+module MBWS
+  module Relations
+    class RelationsBase < Array
+      
+      def initialize(xml = {})
+        parse(xml)
+      end
+      
+      def relations_by_type(type)
+        rels = []
+        self.each do |r|  
+          rels.push(r) if r[:type] == type
+        end
+        rels
+      end
+      
+      private    
+
+      def parse(xml)
+        klass_str = self.class.to_s.split("::")[2].gsub(/Relations$/,'')
+        klass = MBWS.const_get(klass_str)
+        obj_sym = klass_str.downcase.to_sym
+        
+        xml["relation"].each do |r|
+          h = Hash.new
+
+          h[:type] = r["type"]
+          h[:direction] = r["direction"] if r["direction"]
+          
+          # Url's don't have their own tag
+          if obj_sym == :url
+            h[obj_sym] = klass.new(r)
+          else
+            h[obj_sym] = klass.new(r[klass_str.downcase][0])
+          end
+          
+          self.push(h)
+        end if xml["relation"]
+      end
+      
+    end
+  end
+end

data/lib/mbws/release.rb

@@ -0,0 +1,78 @@
+module MBWS
+  class Release < Resource
+
+    attr_accessor :title,:mid,:type,:status,:release_events,:asin
+    
+    def initialize(hash,options = {})
+      @discs = nil
+      @discs_count = nil
+      @tracks_count = nil
+      @artist = nil
+      @tracks = nil
+      @release_events = nil
+      
+      super
+      
+      @title = hash["title"]
+      @asin = hash["asin"]
+      @mid = hash["id"]
+      @type = hash["type"].split(" ")[0] if hash["type"]
+      @status = hash["type"].split(" ")[1] if hash["type"]
+    end
+    
+    def artist
+      return @artist if @artist
+      release_xml = Request.get("release/#{self.mid}",:inc => "artist")
+      parse_artist(release_xml["release"][0])
+    end
+
+    def discs
+      return @discs if @discs
+      release_xml = Request.get("release/#{self.mid}",:inc => "discs")
+      parse_discs(release_xml["release"][0])
+    end
+    
+    def tracks
+      return @tracks if @tracks
+      release_xml = Request.get("release/#{self.mid}",:inc => "tracks")
+      parse_tracks(release_xml["release"][0])
+      @tracks
+    end
+    
+    def tracks_count
+      return @tracks_count if @tracks_count
+      nil
+      #release_xml = Request.get("release/#{self.mid}",:inc => "counts")
+      #parse_counts(release_xml["release"][0])
+      #@tracks_count
+    end
+
+    private
+      
+      def parse_counts(xml)
+      	@tracks_count = xml["track-list"]["count"]
+      end
+
+      def parse_discs(xml)
+        @discs = []
+        xml["disc-list"]["disc"].each do |d|
+          @discs.push({:sectors => d["sectors"], :id => d["id"]})
+        end
+        @discs_count = @discs.size
+      end
+
+      def parse_tracks(xml)
+        @tracks = []
+        xml["track-list"]["track"].each do |t|
+          @tracks.push(Track.new(t))
+        end
+      end
+
+      def parse_release_events(xml)
+        @release_events = []
+        xml["release-event-list"]["event"].each do |re|
+          @release_events.push(re)
+        end
+      end
+  end
+end

data/lib/mbws/release_relations.rb

@@ -0,0 +1,6 @@
+module MBWS
+  module Relations
+    class ReleaseRelations < RelationsBase
+    end 
+  end
+end

data/lib/mbws/request.rb

@@ -0,0 +1,45 @@
+module MBWS
+  class Request
+    @@requests = []
+    def self.get(path,options = {})
+      # MB limits us to 13 requests every 10 seconds.
+      # We police ourselves a bit stricter to make certain
+      # that we don't exceed this limit.
+      #
+      # Another way to do this would be to pace ourselves
+      # so that there is always 10/13 of a second between
+      # requests but this method allows short bursts
+      
+      # Delete requests if they happened more than 11 seconds ago
+      now = Time.now
+      @@requests.delete_if{ |t| (now - t) > 11}
+
+      # If there are 11 or more requests sleep until
+      # only 10 have occured in the past 10 seconds
+      if @@requests.size > 10
+        interval = 10 - (now - @@requests[-11])
+        sleep interval if interval > 0
+      end
+
+      opts = options.collect {|k,v|
+        if k == :inc and v.class == Array
+          k.to_s + "=" + v.join("+")
+        else
+          k.to_s + "=" + v.to_s
+        end
+      }.join("&")
+      path += "?type=xml&" + opts
+      http = Net::HTTP.new('musicbrainz.org',80)
+      http.start do
+        request = Net::HTTP::Get.new('/ws/1/' + URI.escape(path))
+        @@requests.push(Time.now)
+        res = http.request(request)
+        if res.code == 404
+          raise MBIDNotFound
+        else
+          return Parsing::XmlParser.new(res.body)
+        end
+      end
+    end
+  end
+end

data/lib/mbws/resource.rb

@@ -0,0 +1,117 @@
+module MBWS #:nodoc:
+  class Resource
+    include Relations
+
+    attr_accessor :mid, :score
+    
+    def initialize(hash,options)
+      @mid = hash["id"]
+      @score = hash["ext:score"]
+      @artist_rels = nil
+      @url_rels = nil
+      @track_rels = nil
+      @release_rels = nil
+      if options.has_key?(:inc)
+        options[:inc].map {|i| i.to_s.gsub(/-/,"_")}.each do |s|
+          self.send "parse_" + s,hash #if s.match(/rels/)
+        end
+      end
+    end
+    
+    def self.find(*args)
+      case args[0]
+        when String
+          self.find_by_mbid(args)
+        when Hash
+          self.find_by_query(args)
+      end
+    end
+    
+    # Relations
+
+    def track_rels
+      return @track_rels if @track_rels
+      xml = Request.get("#{self.resource_name}/#{self.mid}",:inc => "track-rels")
+      parse_track_rels(xml[self.resource_name][0])
+      @track_rels
+    end
+    
+    def url_rels
+      return @url_rels if @url_rels
+      xml = Request.get("#{self.resource_name}/#{self.mid}",:inc => "url-rels")
+      parse_url_rels(xml[self.resource_name][0])
+      @url_rels
+    end
+    
+    def artist_rels
+      return @artist_rels if @artist_rels
+      xml = Request.get("#{self.resource_name}/#{self.mid}",:inc => "artist-rels")
+      parse_artist_rels(xml[self.resource_name][0])
+      @artist_rels
+    end
+    
+    def release_rels
+      return @release_rels if @release_rels
+      xml = Request.get("#{self.resource_name}/#{self.mid}",:inc => "release-rels")
+      parse_release_rels(xml[self.resource_name][0])
+      @release_rels
+    end
+    
+    def resource_name
+      self.class.to_s.downcase.split("::")[1]
+    end
+    
+    def self.resource_name
+      self.to_s.downcase.split("::")[1]
+    end
+
+    private
+    
+    def self.find_by_mbid(args)
+      mid = args[0]
+      options = args[1] || {}
+
+      raise InvalidUUID.new(mid) unless mid =~ /^\w{8}-\w{4}-\w{4}-\w{4}-\w{12}$/
+
+      xml = Request.get("#{self.resource_name}/#{mid}",options)
+      return self.new(xml[self.resource_name][0],options)
+    end
+
+    def self.find_by_query(args)
+      options = args[0]
+      
+      objs = []
+      
+      xml = Request.get("#{self.resource_name}/",options)
+      xml[self.resource_name + "-list"][self.resource_name].each do |o|
+        objs.push(self.new(o,options))
+      end
+      objs.sort_by { |o| o.score }
+      objs
+    end
+    
+    def parse_aliases(xml)
+      @aliases = []
+      xml["alias-list"]["alias"].each do |a|
+        @aliases.push(a)
+      end if xml["alias-list"]
+    end
+
+    def parse_artist(xml)
+      @artist = Artist.new(xml["artist"][0])
+    end
+
+    [:track, :artist, :release, :label, :url].each do |symbol|
+      class_eval(<<-EVAL,__FILE__,__LINE__)
+        def parse_#{symbol}_rels(xml)
+          if xml["relation-list"] && xml["relation-list"]["#{symbol.to_s.capitalize}"]
+            @#{symbol}_rels = 
+              #{symbol.to_s.capitalize}Relations.new(xml["relation-list"]["#{symbol.to_s.capitalize}"])  
+          else
+            @#{symbol}_rels = #{symbol.to_s.capitalize}Relations.new
+          end
+        end
+      EVAL
+    end
+  end
+end