beatport 0.1.1

data/lib/beatport/collection.rb

@@ -0,0 +1,37 @@
+require 'forwardable'
+
+module Beatport
+  class Collection
+    include Enumerable
+    extend Forwardable
+    
+    def_delegators :@results, :each, :'<=>', :length, :==, :===, :to_a
+    
+    attr_reader :host, :path, :query, :next_query
+    attr_reader :per_page_options, :page, :per_page, :total_pages, :count
+    attr_reader :facets, :applied_facets, :spellcheck
+    attr_reader :date_filters, :applied_date_filters
+    
+    def initialize(klass, data)
+      raise ArgumentError, "Invalid data passed to Collection.new" unless data['results'].is_a?(Array)
+      
+      data['metadata'].each do |k, v|
+        instance_variable_set(:"@#{k}", v)
+      end
+      
+      @results = if klass == :auto
+        data['results'].map do |r|
+          item_klass = Inflector.constantize("Beatport::Catalog::#{r['type'].capitalize}")
+          item_klass.new(r)
+        end
+      else
+        data['results'].map { |r| klass.new(r) }
+      end
+    end
+    
+    def grouped
+      group_by { |i| i.type.capitalize }
+    end
+    
+  end
+end

data/lib/beatport/inflector.rb

@@ -0,0 +1,44 @@
+module Beatport
+  module Inflector
+    def self.constantize(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 self.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.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+      end
+    end    
+    
+    def self.underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+    
+    def self.process_keys(obj, &block)
+      case obj
+      when Hash
+        Hash[obj.map {|k, v| [yield(k), process_keys(v, &block)]}]
+      when Array
+        obj.map {|o| process_keys(o, &block)}
+      else
+        obj
+      end
+    end
+    
+  end
+end

data/lib/beatport/item.rb

@@ -0,0 +1,81 @@
+module Beatport
+  
+  class Item < OpenStruct
+    class << self
+      def associations
+        @associations ||= {}
+      end
+      
+      def has_one(var, klass)
+        lazy_accessor(var)
+        self.associations[var] = {:list => false, :klass => klass}
+      end
+    
+      def has_many(var, klass)
+        lazy_accessor(var)
+        self.associations[var] = {:list => true, :klass => klass}
+      end
+      
+      def lazy_accessor(var)
+        return if respond_to?(var)
+        class_eval "def #{var}; @#{var}; end"
+      end
+    end
+  
+    def initialize(data = {})
+      raise ArgumentError, "Invalid data passed to Item.new: #{data.inspect}" unless data.is_a?(Hash)
+            
+      # OpenStruct doesn't like id or type, so we store them after the call to super
+      id = data.delete('id')
+      type = data.delete('type')
+      
+      self.class.associations.each do |k, v|
+        associate(data, k, v[:list], v[:klass])
+      end
+      
+      super(data)
+
+      data.each do |k, v|
+        @table[k.to_sym] = Date.parse(v) if k =~ /_date$/
+        @table[k.to_sym] = Regexp.new(v.to_s) if k =~ /_regex$/
+      end
+      
+      @table['id'] = id if id
+      @table['type'] = type if type
+    end
+
+    def id
+      @table['id']
+    end
+    
+    def type
+      @table['type']
+    end
+    
+    # Allow treating the item as a hash
+    def [](key)
+      send(key) if respond_to?(key)
+    end
+    
+    def associate(data, var, collection = false, klass = Item)
+      a = data.delete(var.to_s)
+      
+      return unless a
+      
+      if collection && a.is_a?(Array)
+        a = a.compact.map { |g| klass.new(g) }
+      elsif !collection && a.is_a?(Hash)
+        a = klass.new(a)
+      elsif a == [] # || !a
+        # In some cases, when there's no data returned for an association it'll be an empty array instead of a hash
+        a = nil
+      else
+        raise ArgumentError, "Invalid data for association: '#{var}' = #{a.inspect}"
+      end
+      
+      instance_variable_set(:"@#{var}", a)
+    end
+    
+    
+  end
+end

data/lib/beatport/parser.rb

@@ -0,0 +1,8 @@
+module Beatport
+  # A custom HTTParter parse that underscores the keys of the result
+  class Parser < HTTParty::Parser
+    def parse
+      Inflector.process_keys(super) { |k| Inflector.underscore(k) }
+    end
+  end
+end

data/lib/beatport/price.rb

@@ -0,0 +1,8 @@
+module Beatport
+  class Price < Money
+
+    def initialize(data = {})
+      super(data['value'] || 0, data['code'])
+    end
+  end
+end

data/lib/beatport/query_builder.rb

@@ -0,0 +1,74 @@
+module Beatport
+  # Converts a set of arguments into a format that beatport will understand
+  class QueryBuilder
+    SPECIAL_OPTIONS = ['sortBy', 'facets', 'returnFacets']
+
+    def self.process(*args)
+      new.process(*args)
+    end
+
+    def special_option?(key)
+      SPECIAL_OPTIONS.include?(key)
+    end
+   
+    def process(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}      
+      
+      key = options.delete(:key) || (args.length > 1 ? args.compact : args.first)
+    
+      case key
+      when Integer
+        options[:id] = key
+      when String, Symbol
+        options[:slug] = key.to_s
+      when Array
+        options[:ids] = key
+      end
+      
+      options = camelize_keys(options)
+      
+      options.map do |key, value|
+        options[key] = send(Inflector.underscore("process_#{key}"), value) if special_option?(key)
+      end
+      
+      options
+    end
+
+    # Camelizes all the keys in the options hash
+    def camelize_keys(options)
+      Inflector.process_keys(options) { |k| Inflector.camelize(k.to_s, false) }
+    end
+
+    def process_sort_by(values)
+      map_values(values) do |value|
+        split_value(value, " ").join(" ")
+      end       
+    end
+    
+    def process_facets(values)
+      map_values(values) do |value|
+        k, v = split_value(value, ':')
+        v.to_a.map {|v| "#{k}:#{v}"}.join(',')
+      end       
+    end
+    
+    def process_return_facets(values)
+      map_values(values) do |value|
+        Inflector.camelize(value, false)
+      end
+    end    
+    
+    def map_values(values)
+      values = values.split(/,\s*/) if values.is_a?(String)
+      values.map do |value|
+        yield value
+      end.join(",") 
+    end
+    
+    def split_value(value, seperator)
+      value = value.split(seperator) if value.is_a?(String)
+        
+      [Inflector.camelize(value.first, false), value.last]
+    end
+  end
+end

data/spec/catalog/account_type_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Beatport::Catalog
+  describe AccountType do
+    describe 'structure' do
+     before(:all) { @account_type = AccountType.all.first }
+     
+     it { @account_type.code.should == "AMEX" }
+     it { @account_type.bpid.should == "1" }
+     it { @account_type.cybersource_card_type.should == "003" }
+     it { @account_type.issue_number_or_start_date_required.should == false }
+     it { @account_type.validation_regex.should == /^3[47][0-9]{13}$/ }
+     it { @account_type.images.small.url.should == "https://ak-secure-beatport.bpddn.com/images/creditcard/logo_cc_amex_37x23.gif"}
+    end
+  end
+end

data/spec/catalog/artist_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+module Beatport::Catalog
+  describe Artist do
+    describe 'structure' do
+      before(:all) { @artist = Artist.find(7181) }
+      
+      it { @artist.id.should == 7181 }
+      it { @artist.type.should == "artist" }
+      it { @artist.name.should == "Above & Beyond" }
+      it { @artist.slug.should == "above-and-beyond" }
+      it { @artist.last_publish_date.should == Date.new(2011, 12, 15)}
+      it { @artist.biography.should == "" }
+      it { @artist.genres.length.should be > 1 }
+      it { @artist.sub_genres.length.should be > 1 }            
+      it { @artist.top_downloads.length.should be > 1 }
+      it { @artist.images.small.url.should == "http://geo-media.beatport.com/items/imageCatalog/0/400000/90000/1000/500/20/491527.jpg" }
+      it { @artist.images.medium.url.should == "http://geo-media.beatport.com/items/imageCatalog/0/400000/90000/1000/500/30/491530.jpg" }
+      it { @artist.images.large.url.should == "http://geo-media.beatport.com/items/imageCatalog/4000000/600000/80000/6000/400/20/4686424.jpg" }
+      it { @artist.featured_releases.length.should be > 1 }
+    end
+    
+    describe '.find' do
+      it "should find Above & Beyond when given id 7181" do
+        artist = Artist.find(7181)
+        artist.id.should == 7181
+      end
+    end
+  
+    describe '.all' do
+      it "should get arbitrary artists" do
+        artists = Artist.all
+        artists.length.should == 10
+      end
+    
+      it "should get the first page with 5 artists per page" do
+        artists = Artist.all :per_page => 5, :page => 1
+        artists.length.should == 5
+        artists.page.should == 1
+        artists.per_page.should == 5
+      end
+    
+      it "should get the first page with 5 artists per page, sorted by publish date and artist id, for the House genre" do
+        artists = Artist.all(:sort_by=> {:publish_date  => 'asc', :artist_id => 'asc'}, :genre_id=> 5, :per_page=>5, :page=>1)
+        artists.length.should == 5
+      
+        old_id = nil
+        old_date = artists.first.last_publish_date
+      
+        artists.each do |artist|
+          old_id = nil if old_date.to_s != artist.last_publish_date.to_s
+        
+          # beatport has some bad genre data?
+          # artist.genres.map(&:id).should include(5)
+          artist.id.should be >= old_id if old_id
+          artist.last_publish_date.should be >= old_date if old_date
+        
+          old_id = artist.id
+          old_date = artist.publish_date
+        end
+      end
+    
+      it "should get arbitrary artists with filter metadata for all genre names and artist names" do
+        artists = Artist.all :return_facets => ['genre_name', 'performer_name']
+    
+        artists.facets['fields']['performer_name'].count.should be > 1
+        artists.facets['fields']['genre_name'].count.should be > 1      
+      end
+
+      it "should get all trance artists for above & beyond" do
+        artists = Artist.all :facets => {:genre_name => ['Trance', 'Progessive House']}
+    
+        artists.each do |artist|
+          artists = artist['artists'].map { |a| a['name'] }
+          artists.should include("Above & Beyond")
+        
+          genres = artist['genres'].map { |a| a['name'] }
+          genres.should include('Trance')
+        end
+      end
+    end
+  end
+end

data/spec/catalog/audio_format_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module Beatport::Catalog
+  describe "AudioFormat" do
+    describe 'structure' do
+     before(:all) { @audio_format = AudioFormat.all.first }
+     
+     it { @audio_format.id.should == 1 }
+     it { @audio_format.name.should == "mp3" }
+     it { @audio_format.person_preference_visibility.should == true }
+    end    
+    
+  end
+end

data/spec/catalog/autocomplete_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Beatport::Catalog
+  describe Autocomplete do
+    describe 'stucture' do
+      before(:all) { @result = Autocomplete.query('lutzen').first }
+      it { @result.name.downcase.should match(/lutzen/) }
+    end
+    
+    describe 'collection' do
+      before(:all) { @collection = Autocomplete.query('lutzen') }
+      it { @collection.host.should == "api.beatport.com" }
+      it { @collection.path.should == "/catalog/autocomplete" }
+      it { @collection.query.should == "query=lutzen" }
+      it { @collection.page.should == 1 }
+      it { @collection.per_page.should == 10 }
+      it { @collection.count.should be > 1 }
+      it { @collection.total_pages.should be > 1 }
+      it { @collection.next_query.should == "query=lutzen&page=2"}
+      it { @collection.per_page_options.should_not be_nil }
+      it { @collection.facets.should_not be_nil }
+      it { @collection.spellcheck.should_not be_nil }
+    end
+  end
+end

data/spec/catalog/chart_overview_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Beatport::Catalog
+  describe ChartOverview do
+    describe '.get' do
+      it "should have 16 newest charts and 4 featured charts" do
+        overview = ChartOverview.get
+      
+        overview.newest.length.should == 16
+        overview.featured.length.should == 4
+      end
+    end
+  end
+end
+  

data/spec/catalog/chart_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+module Beatport::Catalog
+  describe Chart do
+  
+    describe 'structure' do
+      before(:all) { @chart = Chart.find(15722) }
+      it { @chart.id.should == 15722 }
+      it { @chart.type.should == "chart" }
+      it { @chart.name.should == "Nitrous Oxide – April Top 10" }    
+      it { @chart.slug.should == "nitrous-oxide-april-top-10" }
+      it { @chart.description.should == "" }
+      it { @chart.publish_date.should == Date.new(2009, 05, 12) }
+      it { @chart.price.to_s.should == '13.91' }
+      it { @chart.audio_format_fee.wav.to_s.should == "9.00" }
+      it { @chart.audio_format_fee.aiff.to_s.should == "9.00" }      
+      it { @chart.genres.map(&:name).should == ["Trance"] }
+      it { @chart.images.small.url.should == "http://geo-media.beatport.com/items/imageCatalog/0/400000/90000/1000/500/30/491534.jpg"}
+      it { @chart.images.medium.url.should == "http://geo-media.beatport.com/items/imageCatalog/0/400000/10000/2000/900/20/412921.jpg"}
+      it { @chart.images.large.url.should == "http://geo-media.beatport.com/items/imageCatalog/0/400000/10000/2000/900/20/412922.jpg"}            
+
+      it { @chart.tracks.length.should == 9 }
+    end
+  
+    describe '.find' do
+      chart = Chart.find(15722)
+      chart.id.should == 15722
+    end
+  
+    describe '.all' do
+      it "should get arbitrary charts" do
+        charts = Chart.all
+        charts.length.should == 10
+      end
+    
+      it "should get the first page with 5 charts per page" do
+        charts = Chart.all :per_page => 5, :page => 1
+        charts.length.should == 5
+        charts.page.should == 1
+        charts.per_page.should == 5
+      end
+    
+      it "should get the first page with 5 charts per page, sorted by publish date and chart id, for the House genre" do
+        charts = Chart.all(:sort_by=> ['publishDate asc', 'chartId asc'], :genre_id=> 5, :per_page=>5, :page=>1)
+        charts.length.should == 5
+      
+        old_id = nil
+        old_date = charts.first.publish_date
+      
+        charts.each do |chart|
+          old_id = nil if old_date.to_s != chart.publish_date.to_s
+        
+          # it's possible that the genre is a subgenre of house, so we'll disable this test for now
+#          chart.genres.map(&:id).should include(5)
+          chart.id.should be >= old_id if old_id
+          chart.publish_date.should be >= old_date if old_date
+        
+          old_id = chart.id
+          old_date = chart.publish_date
+        end
+      end
+    
+      it "should get arbitrary charts with filter metadata for all genre names and artist names" do
+        charts = Chart.all :return_facets => ['genre_name', 'performer_name']
+ 
+        # despite what the beatport api doc says, the query deoesn't return any performer names...
+#        charts.facets['fields']['performer_name'].count.should be > 1
+        charts.facets['fields']['genre_name'].count.should be > 1      
+      end
+
+      it "should get all charts for trance and progressive house" do
+        charts = Chart.all :facets => {:genre_name => ['Trance', 'Progessive House']}
+    
+        charts.each do |chart|
+          genres = chart['genres'].map { |a| a['name'] }
+          pp genres
+        end
+      end
+    end
+    
+    describe '.featured' do
+      it "should get the featured charts for the Home page" do
+        charts = Chart.featured
+        charts.length.should be > 1
+      end
+      
+      it "should get the featured charts for the Trance page" do
+        charts = Chart.featured :genre_id => 7
+        charts.length.should be > 1
+        charts.each do |chart|
+          chart.genres.map(&:id).should include(7)
+        end
+      end
+    end
+  end
+end