7digital 0.0.5 → 0.0.6

data/lib/sevendigital/model/tag.rb

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

data/lib/sevendigital/model/track.rb

@@ -1,29 +1,84 @@
-module Sevendigital 
-
-  class Track < SevendigitalObject
-    attr_accessor :id, :title, :version, :release, :artist
-                  
-    sevendigital_basic_property :track_number,:duration, :explicit_content, :isrc, :url, :price
-
-    def get_details(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|remaster)\s?.*\)/i, "")
-    end
-
-    def alternate_version_of?(another_track)
-      return another_track && short_title.downcase == another_track.short_title.downcase \
-            && another_track.artist && artist.name.downcase == another_track.artist.name.downcase
-    end
-
-     def preview_url(options={})
-      #url = "http://previews.7digital.com/clips/34/#{id}.clip.mp3"
-      @api_client.track.build_preview_url(@id, options)
-    end
-
-  end
+module Sevendigital 
+
+  class Track < SevendigitalObject
+
+    #track id
+    #@return [Integer]
+    attr_accessor :id
+
+    #title of the track
+    #@return [String]
+    attr_accessor :title
+
+    #version of the track (e.g. remix, radio edit)
+    #@return [String]
+    attr_accessor :version
+
+    #release the track appears on
+    #@return [Release]
+    attr_accessor :release
+
+    #Artist of the track
+    #@return [Artist]
+    attr_accessor :artist
+                  
+    #Number of the track as it appears on the release
+    #@return [Integer]
+    sevendigital_basic_property :track_number
+
+    #The length of the track in seconds
+    #@return [Integer]
+    sevendigital_basic_property :duration
+
+    #parental advisory - explicit content tag
+    #@return [Boolean]
+    sevendigital_basic_property :explicit_content
+
+    #ISRC code
+    #@return [String]
+    sevendigital_basic_property :isrc
+
+    #URL link to 7digital page where this track can be purchased
+    #@return [String]
+    sevendigital_basic_property :url
+
+    #Pricing information of the track
+    #@return [Price]
+    sevendigital_basic_property :price
+
+    #Retrieves and populates all track properties
+    #
+    #useful with lazy loading turned off
+    #@param [Hash] options optional hash of additional API parameters, e.g. image_size => 75, etc
+    #@return [Track]
+    def get_details(options={})
+      track_with_details = @api_client.track.get_details_from_release(@id, @release.id, options)
+      copy_basic_properties_from(track_with_details)
+      self
+    end
+
+    #Title of the track stripped out of any version information if it's included the title of the track rather than version property
+    #e.g. if title is "Some Song (Radio Edit)" it will return "Some Song"
+    #@return [String]
+    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|remaster)\s?.*\)/i, "")
+    end
+
+    #Compares 2 songs whether they're just different versions of the same song by the same artist
+    #e.g. track "Some Song (Radio Edit)" is alternate version of "Some Song (Remastered)"
+    #returns true also if the 2 songs are the same
+    #@return [Boolean]
+    def alternate_version_of?(another_track)
+      return another_track && short_title.downcase == another_track.short_title.downcase \
+            && another_track.artist && artist.name.downcase == another_track.artist.name.downcase
+    end
+
+    #URL of mp3 preview for this track
+    #@return [String]
+    def preview_url(options={})
+      @api_client.track.build_preview_url(@id, options)
+    end
+
+  end
 end

data/lib/sevendigital/model/user.rb

@@ -1,34 +1,64 @@
-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
+module Sevendigital
+
+  class User < SevendigitalObject
+
+    attr_accessor :oauth_access_token, :id, :type, :email_address
+
+    sevendigital_extended_property :locker
+
+    sevendigital_extended_property :cards
+
+    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 get_cards(options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user_payment_card.get_card_list(@oauth_access_token, options)
+    end
+
+    def add_card(card_number, card_type, card_holder_name, card_start_date, card_expiry_date, card_issue_number,
+            card_verification_code, card_post_code, card_country, options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user_payment_card.add_card(card_number, card_type, card_holder_name, card_start_date, card_expiry_date, card_issue_number,
+            card_verification_code, card_post_code, card_country, @oauth_access_token, options)
+    end
+
+    def select_card(card_id, options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user_payment_card.select_card(card_id, @oauth_access_token, options)
+    end
+
+    # <b>DEPRECATED:</b> Please use <tt>purchase_item!</tt> instead.
+    def purchase!(release_id, track_id, price, token, options={})
+      warn "[DEPRECATION] `purchase!` is deprecated.  Please use 'purchase_item!' instead."
+      purchase_item!(release_id, track_id, price, options={})
+    end
+
+    def purchase_item!(release_id, track_id, price, options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user.purchase_item(release_id, track_id, price, @oauth_access_token, options)
+    end
+
+    def purchase_basket!(basket_id, options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user.purchase_basket(basket_id, @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,23 +1,24 @@
-begin
-  require "will_paginate/collection"
-rescue LoadError
-end
-
-module Sevendigital
-
-  #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
-      return paged_list
-    end
-
-  end
-
+begin
+  require "will_paginate/collection"
+rescue LoadError
+end
+
+module Sevendigital
+
+  #@private
+  #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
+      return paged_list
+    end
+
+  end
+
 end

data/lib/sevendigital/peachy_patchy.rb

@@ -0,0 +1,9 @@
+module Peachy
+  class MethodName
+
+    # let's also allow numbers and trailing underscores in element(method) names
+    def matches_convention?
+      @method_name =~ /^[a-z0-9]+(?:[_a-z0-9]+)*(?:NS[a-z0-9]+(?:[_a-z0-9]+)*)?$/
+    end
+  end
+end

data/lib/sevendigital/proxy_police.rb

@@ -1,28 +1,28 @@
-module Sevendigital
-
-  #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
-          return xml_or_proxy
-      else
-          return ProxyPolice.create_release_proxy(xml_or_proxy, element_name)
-      end
-    end
-
-    def ProxyPolice.create_release_proxy(xml, element_name)
-      #TODO don't use eval
-      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
-      end
-    end
-
-  end
+module Sevendigital
+
+  #@private
+  #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) || xml_or_proxy.kind_of?(Peachy::SimpleContent) then
+        return xml_or_proxy
+      else
+        return ProxyPolice.create_release_proxy(xml_or_proxy, element_name)
+      end
+    end
+
+    def ProxyPolice.create_release_proxy(xml, element_name)
+      #TODO don't use eval
+      parent_proxy = Peachy::Proxy.new(xml)
+      if element_name
+#        parent_proxy.send(element_name)
+        eval "parent_proxy.#{element_name.to_s}"
+      else
+        parent_proxy
+      end
+    end
+
+  end
 end

data/lib/sevendigital/version.rb

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

data/spec/api_operator_cached_spec.rb

@@ -1,103 +1,179 @@
-require "spec_helper"
-require 'ostruct'
-
-describe "ApiOperatorCached" do
-
-  before do
-    @client = stub(Sevendigital::Client)
-    @client.stub!(:verbose?).and_return(false)
-    @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(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 = 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(@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 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)
-   @cached_operator.stub!(:make_http_request_and_digest).and_return(api_response)
-
-    @cache.should_receive(:set).with("key", api_response).and_return(nil)
-    response = @cached_operator.call_api(@stub_api_request)
-  end
-
-  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
-
+require "spec_helper"
+require 'ostruct'
+
+describe "ApiOperatorCached" do
+
+  before do
+    @client = stub(Sevendigital::Client)
+    @client.stub!(:verbose?).and_return(false)
+    @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
+    http_response = stub_http_response
+    @stub_api_request.stub!(:requires_signature?).and_return(true)
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.should_not_receive(:get)
+    @cached_operator.should_receive(:make_http_request).with(@stub_api_request).and_return(http_response)
+    @cached_operator.should_receive(:digest_http_response).with(http_response)
+    @cached_operator.call_api(@stub_api_request)
+  end
+
+  it "should not cache api response if request was signed" do
+
+    http_response = stub_http_response
+    @stub_api_request.stub!(:requires_signature?).and_return(true)
+    @cached_operator.stub(:create_request_uri).and_return("key")
+
+    @cached_operator.stub!(:make_http_request).and_return(http_response)
+    @cached_operator.stub!(:digest_http_response)
+    @cache.should_not_receive(:set)
+    @cached_operator.call_api(@stub_api_request)
+  end
+
+  it "should not make an http request if response already in cache and not out of date " do
+    http_response = stub_http_response
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.stub!(:get).with("key").and_return(http_response)
+    @cached_operator.stub!(:response_out_of_date?).with(http_response).and_return(false)
+    @cached_operator.should_not_receive(:make_http_request)
+    @cached_operator.should_receive(:digest_http_response).with(http_response)
+    @cached_operator.call_api(@stub_api_request)
+  end
+
+  it "should make an http request if cached response is out of date " do
+
+    expired_http_response = stub_http_response
+    fresh_http_response = stub_http_response
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.stub!(:get).with("key").and_return(expired_http_response)
+    @cached_operator.stub!(:response_out_of_date?).with(expired_http_response).and_return(true)
+
+    @cache.stub!(:set).and_return(nil)
+    @cached_operator.should_receive(:make_http_request).and_return(fresh_http_response)
+    @cached_operator.should_receive(:digest_http_response).with(fresh_http_response)
+    @cached_operator.call_api(@stub_api_request)
+  end
+
+  it "should make an http request if response not yet in cache, digest it and return the result " do
+    api_response = stub_api_response()
+    http_response = fake_http_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).with(@stub_api_request).and_return(http_response)
+    @cached_operator.should_receive(:digest_http_response).with(http_response).and_return(api_response)
+
+    response = @cached_operator.call_api(@stub_api_request)
+    response.should == api_response
+  end
+
+  it "should cache uncached api response if request was not signed" do
+    http_response = stub_http_response()
+
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.stub!(:get).with("key").and_return(nil)
+    @cached_operator.stub!(:make_http_request).and_return(http_response)
+    @cached_operator.stub!(:digest_http_response)
+
+    @cache.should_receive(:set).with("key", http_response).and_return(nil)
+    @cached_operator.call_api(@stub_api_request)
+  end
+
+  it "response should be out of date if it's past its cache max age" do
+    now = Time.now.utc
+    yesterday = now - 24*60*60
+    max_age = 12*60*60
+
+    http_response = stub_http_response
+    http_response.stub!(:header).and_return({
+      "cache-control" => "private, max-age=#{max_age}",
+      "Date" => yesterday.httpdate
+    })
+
+    @cached_operator.response_out_of_date?(http_response, now).should == true
+
+  end
+
+
+  it "response should not be out of date if it's within its cache max age" do
+    now = Time.now.utc
+    yesterday = now - 24*60*60
+    max_age = 48*60*60
+
+    http_response = stub_http_response
+    http_response.stub!(:header).and_return({
+      "cache-control" => "private, max-age=#{max_age}",
+      "Date" => yesterday.httpdate
+    })
+
+    @cached_operator.response_out_of_date?(http_response, now).should == false
+
+  end
+
+  it "response should be out of date if it is missing caching headers" do
+
+    http_response = stub_http_response
+    http_response.stub!(:header).and_return({})
+    @cached_operator.response_out_of_date?(http_response, Time.now.utc).should == true
+
+    http_response.stub!(:header).and_return({
+      "Date" => Time.now.utc.httpdate
+    })
+    @cached_operator.response_out_of_date?(http_response, Time.now.utc).should == true
+
+  end
+
+  it "response should be out of date if no max-age has been specified" do
+
+    http_response = stub_http_response
+    http_response.stub!(:header).and_return({"cache-control" => "no-cache", "Date" => Time.now.utc.httpdate})
+    @cached_operator.response_out_of_date?(http_response, Time.now.utc).should == true
+
+  end
+
+  it "response should be out of date if it is missing Date header" do
+
+    http_response = stub_http_response
+    http_response.stub!(:header).and_return({"cache-control" => "private, max-age=#{2**30}"})
+    @cached_operator.response_out_of_date?(http_response, Time.now.utc).should == true
+    
+  end
+
+
+  def fake_http_response
+    return Net::HTTP.new("1.1", 200, "response_body")
+  end
+  
+  def stub_http_response
+    http_response = stub(Net::HTTP)
+    http_response
+  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