discogs-wrapper 1.0.0

data/lib/wrapper/resources/label_release.rb

@@ -0,0 +1,17 @@
+# Represents a labels release in the Discogs API.
+
+require File.dirname(__FILE__) + "/label"
+
+class Discogs::Label::Release < Discogs::Resource
+
+  attr_accessor :id,
+                :status,
+                :type,
+                :catno,
+                :artist,
+                :title,
+                :format,
+                :year,
+                :trackinfo
+
+end

data/lib/wrapper/resources/release.rb

@@ -0,0 +1,22 @@
+# Represents a release in the Discogs API.
+
+class Discogs::Release < Discogs::Resource
+
+  no_mapping
+
+  attr_accessor :id,
+                :status,
+                :title,
+                :country,
+                :released,
+                :notes,
+                :images,
+                :artists,
+                :extraartists,
+                :labels,
+                :formats,
+                :styles,
+                :genres,
+                :tracklist
+
+end

data/lib/wrapper/resources/release_artist.rb

@@ -0,0 +1,18 @@
+# Represents an release's artist in the Discogs API.
+
+require File.dirname(__FILE__) + "/track"
+
+class Discogs::Release::Artist < Discogs::Resource
+
+  map_to_plural :artists, :extraartists
+
+  attr_accessor :name,
+                :role,
+                :join,
+                :anv,
+                :tracks
+
+end
+
+# Define other classes that also replicate this structure.
+class Discogs::Release::Track::Artist < Discogs::Release::Artist; end

data/lib/wrapper/resources/release_label.rb

@@ -0,0 +1,10 @@
+# Represents a Releases Label in the Discogs API.
+
+require File.dirname(__FILE__) + "/release"
+
+class Discogs::Release::Label < Discogs::Resource
+
+  attr_accessor :catno,
+                :name
+
+end

data/lib/wrapper/resources/search.rb

@@ -0,0 +1,61 @@
+# Represents a search resultset in the Discogs API.
+
+class Discogs::Search < Discogs::Resource
+
+  no_mapping
+
+  attr_accessor :exactresults,
+                :searchresults,
+                :start,
+                :end,
+                :numResults
+
+  def total_results
+    self.numResults.to_i
+  end
+
+  def current_page
+    (start.to_i / page_size) + 1
+  end
+
+  def total_pages
+    (total_results.to_f / page_size).ceil
+  end
+
+  def last_page?
+    current_page == total_pages
+  end
+
+  def exact(filter=nil)
+    filter_results(filter, self.exactresults)
+  end
+
+  def results(filter=nil)
+    filter_results(filter, self.searchresults)
+  end
+
+  # Returns the closest exact result for _filter_, or nil.
+  def closest(filter)
+    exact(filter)[0] rescue nil
+  end
+
+ private
+
+  # An easy way for filtering a particular "type" of result (Artist, Release, etc)
+  def filter_results(filter, results)
+    results ||= []
+
+    if filter.nil?
+      results
+    else
+      results.find_all do |result|
+        result.type == filter.to_s
+      end
+    end
+  end
+
+  def page_size
+    self.end.to_i - (self.start.to_i - 1)
+  end
+
+end

data/lib/wrapper/resources/search_result.rb

@@ -0,0 +1,16 @@
+# Represents a single search result in the Discogs API.
+
+require File.dirname(__FILE__) + "/search"
+
+class Discogs::Search::Result < Discogs::Resource
+
+  map_to_plural :exactresults, :searchresults
+
+  attr_accessor :num,
+                :type,
+                :title,
+                :uri,
+                :anv,
+                :summary
+
+end

data/lib/wrapper/resources/track.rb

@@ -0,0 +1,15 @@
+# Represents a track in the Discogs API.
+
+require File.dirname(__FILE__) + "/release"
+
+class Discogs::Release::Track < Discogs::Resource
+
+  map_to_plural :tracklist
+
+  attr_accessor :position,
+                :title,
+                :duration,
+                :artists,
+                :extraartists
+
+end

data/lib/wrapper/wrapper.rb

@@ -0,0 +1,105 @@
+# Core API wrapper class.
+
+require 'uri'
+require 'net/http'
+require 'rexml/document'
+require 'zlib'
+require 'stringio'
+
+require File.dirname(__FILE__) + "/resource"
+
+class Discogs::Wrapper
+
+  @@root_host = "http://api.discogs.com"
+
+  attr_reader :user_agent
+
+  def initialize(user_agent=nil)
+    @user_agent = user_agent
+  end
+
+  def get_release(id)
+    query_and_build "release/#{id}", Discogs::Release
+  end
+
+  def get_artist(name)
+    query_and_build "artist/#{name}", Discogs::Artist
+  end
+
+  def get_label(name)
+    query_and_build "label/#{name}", Discogs::Label
+  end
+
+  def search(term, options={})
+    opts = { :type => :all, :page => 1 }.merge(options)
+    params = { :q => term, :type => opts[:type], :page => opts[:page] }
+
+    data = query_api("search", params)
+    resource = Discogs::Search.new(data)
+
+    resource.build_with_resp!
+  end
+
+ private
+
+  def query_and_build(path, klass)
+    data = query_api(path)
+    resource = klass.send(:new, data)
+    resource.build!
+  end
+
+  # Queries the API and handles the response.
+  def query_api(path, params={})
+    response = make_request(path, params)
+
+    raise_unknown_resource(path) if response.code == "404"
+    raise_internal_server_error if response.code == "500"
+
+    # Unzip the response data, or just read it in directly
+    # if the API responds without gzipping.
+    response_body = nil
+    begin
+        inflated_data = Zlib::GzipReader.new(StringIO.new(response.body))
+        response_body = inflated_data.read
+    rescue Zlib::GzipFile::Error
+        response_body = response.body
+    end
+    
+    response_body
+  end
+
+  # Generates a HTTP request and returns the response.
+  def make_request(path, params={})
+    uri = build_uri(path, params)
+
+    request = Net::HTTP::Get.new(uri.path + "?" + uri.query)
+    request.add_field("Accept-Encoding", "gzip,deflate")
+    request.add_field("User-Agent", @user_agent)
+
+    Net::HTTP.new(uri.host).start do |http|
+      http.request(request)
+    end
+  end
+
+  def build_uri(path, params={})
+    parameters = { :f => "xml" }.merge(params)
+    querystring = "?" + parameters.map { |key, value| "#{key}=#{value}" }.sort.join("&")
+
+    URI.parse(File.join(@@root_host, sanitize_path(path, querystring)))
+  end
+
+  def sanitize_path(*path_parts)
+    clean_path = path_parts.map { |part| part.gsub(/\s/, '+') }
+
+    clean_path.join
+  end
+
+  def raise_unknown_resource(path='')
+    raise Discogs::UnknownResource, "Unknown Discogs resource: #{path}"
+  end
+
+  def raise_internal_server_error
+    raise Discogs::InternalServerError, "The remote server cannot complete the request"
+  end
+
+end

data/spec/resource_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe Discogs::Resource do
+
+  before do
+    @resource = Discogs::Resource.new(sample_valid_binary)
+  end
+
+  it "should have a default element name" do
+    Discogs::Resource.element_names.should == [ :resource ]
+  end
+
+  it "should have a default plural element name" do
+    Discogs::Resource.plural_element_names.should == [ :resources ]
+  end
+
+  it "should have an original_content method" do
+    @resource.original_content.should == sample_valid_binary
+  end
+
+  it "should be able to build the content"
+
+  it "should remove the <resp> element by default"
+
+  it "should leave the <resp> element if told to"
+
+end

data/spec/resources/artist_release_spec.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Discogs::Artist::Release do
+
+  it "should map to release" do
+    Discogs::Artist::Release.element_names.should == [ :release ]
+  end
+
+  it "should map to plural releases" do
+    Discogs::Artist::Release.plural_element_names.should == [ :releases ]
+  end
+
+  describe "when asking for artist-release information" do
+
+    before do
+      data = File.read(File.join(File.dirname(__FILE__), "..", "samples", "valid_artist_release.xml"))
+      @artist_release = Discogs::Artist::Release.new(data)
+      @artist_release.build!
+    end
+
+    it "should have a ID attribute" do
+      @artist_release.id.should == "999333"
+    end
+
+    it "should have a status attribute" do
+      @artist_release.status.should == "Accepted"
+    end
+
+    it "should have a type attribute" do
+      @artist_release.type.should == "Main"
+    end
+
+    it "should have a title attribute" do
+      @artist_release.title.should == "Temple of the Underworld"
+    end
+
+    it "should have a format attribute" do
+      @artist_release.format.should == "LP"
+    end
+ 
+    it "should have a label attribute" do
+      @artist_release.label.should == "Monitor Records"
+    end
+ 
+    it "should have a year attribute" do
+      @artist_release.year.should == "1992"
+    end
+ 
+    it "should have a trackinfo attribute" do
+      @artist_release.trackinfo.should be_nil
+    end
+
+    it "should have an artist attribute" do
+      @artist_release.artist.should == "ArtIst"
+    end
+ 
+  end
+
+end

data/spec/resources/artist_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Discogs::Artist do
+
+  it "should map to empty array" do
+    Discogs::Artist.element_names.should == []
+  end
+
+  it "should map plural to empty array" do
+    Discogs::Artist.plural_element_names.should == []
+  end
+
+  ## See ./spec/wrapper_methods/get_artist_spec.rb for extensive tests of this class.
+
+end

data/spec/resources/format_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Discogs::Release::Format do
+
+  it "should map to format" do
+    Discogs::Release::Format.element_names.should == [ :format ]
+  end
+
+  it "should map to plural formats" do
+    Discogs::Release::Format.plural_element_names.should == [ :formats ]
+  end
+
+  describe "when asking for format information" do
+
+    before do
+      data = File.read(File.join(File.dirname(__FILE__), "..", "samples", "valid_format.xml"))
+      @format = Discogs::Release::Format.new(data)
+      @format.build!
+    end
+
+    it "should have a name attribute" do
+      @format.name.should == "CD"
+    end
+
+    it "should have a quantity attribute" do
+      @format.qty.should == "1"
+    end
+
+    it "should have an array of descriptions" do
+      @format.descriptions.should be_instance_of(Array)
+    end
+
+    it "should have built each description" do
+      @format.descriptions[0].should == "Album"
+      @format.descriptions[1].should == "Digipak"
+      @format.descriptions[9].should be_nil
+    end
+
+  end
+
+end

data/spec/resources/generic_list_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Discogs::GenericList do
+
+  it "should map to all generic lists" do
+    Discogs::GenericList.element_names.should be_instance_of(Array)
+
+    Discogs::GenericList.element_names.include?(:aliases).should be_true
+    Discogs::GenericList.element_names.include?(:urls).should be_true
+  end
+
+  it "should map to plural lists" do
+    Discogs::GenericList.plural_element_names.should == [ :lists ]
+  end
+
+  describe "when asking for description information" do
+
+    before do
+      data = File.read(File.join(File.dirname(__FILE__), "..", "samples", "valid_description_list.xml"))
+      @descriptions = Discogs::GenericList.new(data)
+    end
+
+    it "should return an array on build" do
+      @descriptions.build!.should be_instance_of(Array)
+    end
+
+    it "should have access to the items after build" do
+      @descriptions.build!
+
+      @descriptions[0].should == "Album"
+      @descriptions[1].should == "LP"
+      @descriptions[2].should == "33 rpm"
+    end
+
+    it "should return nil on unknown index" do
+      @descriptions[9].should be_nil
+    end
+ 
+  end
+
+  describe "when asking for genre information" do
+
+    before do
+      data = File.read(File.join(File.dirname(__FILE__), "..", "samples", "valid_genre_list.xml"))
+      @genres = Discogs::GenericList.new(data)
+    end
+
+    it "should return an array on build" do
+      @genres.build!.should be_instance_of(Array)
+    end
+
+    it "should have access to the items after build" do
+      @genres.build!
+
+      @genres[0].should == "Heavy Metal"
+      @genres[1].should == "Neofolk"
+      @genres[2].should == "Medieval folk"
+    end
+
+    it "should return nil on unknown index" do
+      @genres[9].should be_nil
+    end
+ 
+  end
+
+end