7digital 0.0.2 → 0.0.5

data/lib/sevendigital/model/artist.rb

@@ -1,11 +1,31 @@
 module Sevendigital
 
+  #==Basic properties
+  #<tt>*id*</tt>:: \Artist ID
+  #<tt>*name*</tt>:: \Artist\'s name
+  #<tt>*appears_as*</tt>:: \Artist\'s name as it appears on the release or track (only available when artist is linked from release or track)
+  #
+  #==Optional properties
+  #with lazy loading enabled these will be automatically populated by calling get_details
+  #<tt>*sort_name*</tt>:: \Artist name used for sorting, e.g. Beatles, The
+  #<tt>*image*</tt>:: \Artist image URL
+  #<tt>*url*</tt>:: \Artist buy link URL
+  #
+  #==Extended properties
+  #with lazy loading enabled these will be automatically populated by calling the method in brackets
+  #<tt>*releases*</tt>:: array of artist\'s releases (retrieved using get_releases)
+  #<tt>*top_tracks*</tt>:: array of artist\'s top tracks (get_top_tracks)
+  #<tt>*similar*</tt>:: array of artists similar to this artist (get_similar)
+  #additional options can be passed in when accessing lazy loaded properties, e.g.
+  #   artist.releases({:page_size => 5, :image_size =>250})
+
   class Artist < SevendigitalObject
 
-    attr_accessor :id, :name, :appears_as
+    attr_accessor :id, :name, :appears_as #:nodoc:
 
     sevendigital_basic_property :sort_name, :image, :url
 
+    #Retrieves artist\'s details by calling *artist/details* API method
     def get_details(options={})
       artist_with_details = @api_client.artist.get_details(@id, options)
       copy_basic_properties_from(artist_with_details)
@@ -15,24 +35,22 @@ module Sevendigital
     sevendigital_extended_property :top_tracks
     sevendigital_extended_property :similar
 
+    #Retrieves releases by this artist by calling *artist/releases* API method
     def get_releases(options={})
-      @releases = @api_client.artist.get_releases(@id, options).collect do |release|
-        release.artist = self
-        release
-      end
+    @api_client.artist.get_releases(@id, options)
     end
 
+    #Retrieves top tracks by this artist by calling *artist/topTracks* API method
     def get_top_tracks(options={})
-      @tracks = @api_client.artist.get_top_tracks(@id, options).collect do |track|
-        track.artist = self
-        track
-      end
+    @api_client.artist.get_top_tracks(@id, options)
     end
 
+    #Retrieves artists similar to this artist by calling *artist/similar* API method
     def get_similar(options={})
       @similar = @api_client.artist.get_similar(@id, options)
     end
 
+    #True if this artist represents various artists
     def various?
       joined_names = "#{name} #{appears_as}".downcase
 

data/lib/sevendigital/model/basket.rb

@@ -0,0 +1,16 @@
+module Sevendigital
+
+  class Basket < SevendigitalObject
+    attr_accessor :id, :basket_items
+
+    def add_item(release_id, track_id=nil, options={})
+      @basket_items = @api_client.basket.add_item(id, release_id, track_id, options).basket_items
+    end
+
+    def remove_item(item_id, options={})
+      @basket_items = @api_client.basket.remove_item(id, item_id, options).basket_items
+    end
+
+  end
+
+end

data/lib/sevendigital/model/basket_item.rb

@@ -0,0 +1,15 @@
+module Sevendigital
+
+  class BasketItem < SevendigitalObject
+
+    attr_accessor :id
+
+    sevendigital_basic_property  :type, :artist_name, :item_name, :price, :track_id, :release_id
+
+    sevendigital_extended_property :artist
+    sevendigital_extended_property :release
+    sevendigital_extended_property :track
+
+  end
+  
+end

data/lib/sevendigital/model/download_url.rb

@@ -0,0 +1,7 @@
+module Sevendigital
+
+  class DownloadUrl
+    attr_accessor :url, :format
+  end
+
+end

data/lib/sevendigital/model/format.rb

@@ -1,5 +1,3 @@
-require "peachy"
-
 module Sevendigital
 
   class Format

data/lib/sevendigital/model/label.rb

@@ -1,9 +1,7 @@
-require "peachy"
-
 module Sevendigital
 
   class Label
     attr_accessor :id, :name
-	end
+  end
 
 end

data/lib/sevendigital/model/locker.rb

@@ -0,0 +1,5 @@
+module Sevendigital
+  class Locker < SevendigitalObject
+    attr_accessor :locker_releases
+  end
+end

data/lib/sevendigital/model/locker_release.rb

@@ -0,0 +1,9 @@
+module Sevendigital
+
+  class LockerRelease < SevendigitalObject
+
+    attr_accessor :release, :locker_tracks
+    
+  end
+
+end

data/lib/sevendigital/model/locker_track.rb

@@ -0,0 +1,9 @@
+module Sevendigital
+
+  class LockerTrack < SevendigitalObject
+
+    attr_accessor :track, :download_urls, :remaining_downloads, :purchase_date
+    
+  end
+
+end

data/lib/sevendigital/model/price.rb

@@ -1,5 +1,3 @@
-require "peachy"
-
 module Sevendigital
 
   class Price

data/lib/sevendigital/model/release.rb

@@ -1,6 +1,3 @@
-require "peachy"
-require "will_paginate"
-
 module Sevendigital
 
   class Release < SevendigitalObject
@@ -8,7 +5,7 @@ module Sevendigital
     attr_accessor :id, :title
 
     sevendigital_basic_property  :version, :type, :artist, :image, :url, :release_date,
-                      :added_date, :barcode, :year, :explicit_content, :formats, :label, :price
+                      :added_date, :barcode, :year, :explicit_content, :formats, :label
                          
     sevendigital_extended_property :tracks
     sevendigital_extended_property :recommendations
@@ -16,19 +13,36 @@ module Sevendigital
     def get_details(options={})
       release_with_details = @api_client.release.get_details(@id, options)
       copy_basic_properties_from(release_with_details)
+      @price = release_with_details.instance_variable_get("@price")
+      release_with_details
     end
     
     def get_tracks(options={})
-      @tracks = @api_client.release.get_tracks(@id, options).collect do |track|
-        track.release = self
-        track
-      end
+      @api_client.release.get_tracks(@id, options)
     end
 
     def get_recommendations(options={})
       @recommendations = @api_client.release.get_recommendations(@id, options)
     end
 
+    def demand_price(options={})
+      get_details(options) if @price.nil? || @price.value.nil?
+    end
+
+    def price(options={})
+      begin
+        demand_price(options) if @api_client.configuration.lazy_load?
+      rescue
+        puts "Error whilst lazyloading price - #{error.error_code} #{error.error_message}" if @api_client.verbose?
+        raise error if !@api_client.configuration.ignorant_lazy_load?
+      end
+      @price
+    end
+
+    def price=(value)
+      @price = value
+    end
+
   end
   
 end

data/lib/sevendigital/model/sevendigital_error.rb

@@ -1,3 +1,11 @@
 module Sevendigital
-  class SevendigitalError < StandardError; end
+  class SevendigitalError < StandardError;
+    attr_accessor :error_code, :error_message
+
+    def initialize(error_code = 10000, error_message=nil)
+      @error_code = error_code
+      @error_message = error_message
+    end
+
+  end
 end

data/lib/sevendigital/model/sevendigital_object.rb

@@ -8,22 +8,27 @@ class Class
     end
   end
 
- def sevendigital_extended_property(accessor, get_method = nil)
+  def sevendigital_extended_property(accessor, get_method = nil)
 
     get_method ||= "get_#{accessor.to_s}".to_sym
     demand_method = "demand_#{accessor.to_s}".to_sym
 
-     define_method(demand_method) do |*options|
-       if instance_variable_get("@#{accessor}") == nil then
-         value = send(get_method, *options)
-         instance_variable_set("@#{accessor}", value) if get_method != :get_details
-       end
-     end
+    define_method(demand_method) do |*options|
+      if instance_variable_get("@#{accessor}").nil?  then
+        value = send(get_method, *options)
+        instance_variable_set("@#{accessor}", value) if get_method != :get_details
+      end
+    end
 
-     define_method("#{accessor}") do |*options|
-       send(demand_method, *options) if instance_variable_get("@#{accessor}").nil? && @api_client.configuration.lazy_load?
-       instance_variable_get("@#{accessor}")
-     end
+    define_method("#{accessor}") do |*options|
+      begin
+        send(demand_method, *options) if instance_variable_get("@#{accessor}").nil? && @api_client.configuration.lazy_load
+      rescue Sevendigital::SevendigitalError => error
+        puts "Error whilst lazyloading #{accessor} - #{error.error_code} #{error.error_message}" if @api_client.verbose?
+        raise error if !@api_client.configuration.ignorant_lazy_load
+      end
+      instance_variable_get("@#{accessor}")
+    end
 
      define_method("#{accessor}=") do |val|
        instance_variable_set("@#{accessor}",val)

data/lib/sevendigital/model/tag.rb

@@ -0,0 +1,7 @@
+module Sevendigital
+
+  class Tag
+    attr_accessor :id, :text, :url, :count
+  end
+
+end

data/lib/sevendigital/model/track.rb

@@ -1,18 +1,18 @@
 module Sevendigital 
 
   class Track < SevendigitalObject
-    attr_accessor :id, :title, :version, :artist
+    attr_accessor :id, :title, :version, :release, :artist
                   
-    sevendigital_basic_property :track_number,:duration, :explicit_content, :isrc, :release, :url, :price
+    sevendigital_basic_property :track_number,:duration, :explicit_content, :isrc, :url, :price
 
     def get_details(options={})
-      track_with_details = @api_client.track.get_details(@id, options)
+      track_with_details = @api_client.track.get_details_from_release(@id, @release.id, options)
       copy_basic_properties_from(track_with_details)
     end
     
     def short_title
   #   return title.gsub(/\s+[\(\[](album|lp|single|short|edit|radio)\s+version[\)\]]/ , "")
-      return title.gsub(/\s+\(.*\s?(version|mix|remix|edit|edition|live|feat|explicit|original)\s?.*\)/i, "")
+      return title.gsub(/\s+\(.*\s?(version|mix|remix|edit|edition|live|feat|explicit|original|remaster)\s?.*\)/i, "")
     end
 
     def alternate_version_of?(another_track)

data/lib/sevendigital/model/user.rb

@@ -0,0 +1,34 @@
+module Sevendigital
+
+  class User < SevendigitalObject
+
+    attr_accessor :oauth_access_token
+
+    sevendigital_extended_property :locker
+
+    def authenticated?
+      return !@oauth_access_token.nil?
+    end
+
+    def get_locker(options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user.get_locker(@oauth_access_token, options)
+    end
+
+    def purchase!(release_id, track_id, price, options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user.purchase(release_id, track_id, price, @oauth_access_token, options)
+    end
+
+    def stream_track_url(release_id, track_id, options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user.get_stream_track_url(release_id, track_id, @oauth_access_token, options)
+    end
+
+    def add_card_url(return_url, options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user.get_add_card_url(return_url, @oauth_access_token, options)
+    end
+
+  end
+end

data/lib/sevendigital/pager.rb

@@ -1,11 +1,17 @@
-require "will_paginate/collection"
+begin
+  require "will_paginate/collection"
+rescue LoadError
+end
 
 module Sevendigital
 
-  class Pager
+  #internal class used to page array results if will_paginate is available
+  class Pager # :nodoc:
+
     attr_accessor :page, :page_size, :total_items
 
     def paginate_list(list)
+      return list unless defined?(WillPaginate)
       paged_list = WillPaginate::Collection.create(@page, @page_size, @total_items) do |pager|
         pager.replace(list)
       end

data/lib/sevendigital/proxy_police.rb

@@ -1,5 +1,8 @@
 module Sevendigital
-  class ProxyPolice
+
+  #internal class used to ensure the XML being processed is a Peachy::Proxy object
+  #if not it checks the expected element name matches the supplied XML string and converts it to Peachy::Proxy
+  class ProxyPolice # :nodoc:
 
     def ProxyPolice.ensure_is_proxy(xml_or_proxy, element_name)
       if xml_or_proxy.kind_of? Peachy::Proxy then
@@ -14,6 +17,7 @@ module Sevendigital
       parent_proxy = Peachy::Proxy.new(xml)
       if element_name
 #        parent_proxy.send(element_name)
+        puts element_name.to_s
         eval "parent_proxy.#{element_name.to_s}"
       else
         parent_proxy

data/lib/sevendigital/version.rb

@@ -0,0 +1,5 @@
+module Sevendigital
+  # The version of the gem
+  NAME = "7digital"
+  VERSION = '0.0.5'
+end

data/spec/api_operator_cached_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), %w[spec_helper])
+require "spec_helper"
 require 'ostruct'
 
 describe "ApiOperatorCached" do
@@ -9,29 +9,50 @@ describe "ApiOperatorCached" do
     @client.stub!(:very_verbose?).and_return(false)
     @cache = stub(Hash)
     @cached_operator = Sevendigital::ApiOperatorCached.new(@client, @cache)
+    @stub_api_request = stub_api_request()
+  end
+
+  it "should not look into cache if request requires signature" do
+    @stub_api_request.stub!(:requires_signature?).and_return(true)
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.stub!(:get).with("key").and_return(nil)
+    @cached_operator.should_receive(:make_http_request_and_digest).with(@stub_api_request).and_return(stub_api_response())
+    @cached_operator.call_api(@stub_api_request)
   end
 
   it "should not make an http request if response already in cache " do
     @cached_operator.stub(:create_request_uri).and_return("key")
-    @cache.stub!(:get).with("key").and_return(:something)
+    @cache.stub!(:get).with("key").and_return(stub_api_response())
     @cached_operator.should_not_receive(:make_http_request_and_digest)
     @cached_operator.call_api(@stub_api_request)
   end
+
+  it "should make an http request if cached response is out of date " do
+ 
+    expired_response = stub_api_response()
+    expired_response.stub!(:out_of_date?).and_return(true)
+
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.stub!(:get).with("key").and_return(expired_response)
+    @cache.stub!(:set).and_return(nil)
+    @cached_operator.should_receive(:make_http_request_and_digest)
+    @cached_operator.call_api(@stub_api_request)
+  end
   
   it "should make an http request if response not yet in cache and return the result " do
-    api_response = fake_api_response()
+    api_response = stub_api_response()
 
     @cached_operator.stub(:create_request_uri).and_return("key")
     @cache.stub!(:get).with("key").and_return(nil)
     @cache.stub!(:set).and_return(nil)
-    @cached_operator.should_receive(:make_http_request_and_digest).with("key").and_return(api_response)
+    @cached_operator.should_receive(:make_http_request_and_digest).with(@stub_api_request).and_return(api_response)
     
     response = @cached_operator.call_api(@stub_api_request)
     response.should == api_response
   end
 
-  it "should cache uncached api response" do
-    api_response = fake_api_response()
+  it "should cache uncached api response if request was not signed" do
+    api_response = stub_api_response()
 
     @cached_operator.stub(:create_request_uri).and_return("key")
     @cache.stub!(:get).with("key").and_return(nil)
@@ -41,8 +62,42 @@ describe "ApiOperatorCached" do
     response = @cached_operator.call_api(@stub_api_request)
   end
 
-  def fake_api_response
+  it "should not cache api response if request was signed" do
+    api_response = stub_api_response()
+    @stub_api_request.stub!(:requires_signature?).and_return(true)
+
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.stub!(:get).with("key").and_return(nil)
+    @cached_operator.stub!(:make_http_request_and_digest).and_return(api_response)
+
+    @cache.should_not_receive(:set)
+    response = @cached_operator.call_api(@stub_api_request)
+  end
+
+  def fake_http_response
     return Net::HTTP.new("1.1", 200, "response_body")
   end
+  
+  def stub_time(time)
+    Time.stub!(:now).and_return(time)
+  end
+
+  def stub_api_response
+    api_response = stub(Sevendigital::ApiResponse)
+    api_response.stub!(:out_of_date?).and_return(false)
+    api_response
+  end
+
+  def stub_api_request
+  api_request = stub(Sevendigital::ApiRequest)
+
+  api_request.stub!(:parameters).and_return({})
+  api_request.stub!(:api_service).and_return(nil)
+  api_request.stub!(:api_method).and_return("m")
+  api_request.stub!(:requires_signature?).and_return(false)
+  api_request.stub!(:requires_secure_connection?).and_return(false)
+  api_request.stub!(:ensure_country_is_set)
+  return api_request
+end
 
 end