7digital 0.0.7 → 0.1.0

data/README.rdoc

@@ -4,22 +4,29 @@ This is a ruby wrapper for the 7digital API.
 
 ==About 7digital
 
-7digital.com is an online music store operating in over 16 countries and offering more than 11 million high quality DRM free MP3s (320kbps) from all major labels and wide range of idependent labels and distributors. 7digital API will give you access to the full catalogue including high quality album art, 30s preview clips for all tracks, commissions on sales, integrated purchasing and full length streaming. More details at http://developer.7digital.net
+7digital.com is an online music store operating in over 30 countries and offering more than 20 million high quality DRM free MP3s (320kbps) from all major labels and wide range of idependent labels and distributors. 7digital API will give you access to the full catalogue including high quality album art, 30s preview clips for all tracks, commissions on sales, integrated purchasing and full length streaming. More details at http://developer.7digital.net
 
 ==Installation
 
 	gem install 7digital
 
+
 ==Quick start example
 
 
 	require "sevendigital"
+
 	api_client = Sevendigital::Client.new(:oauth_consumer_key => "YOUR_KEY_HERE", :country => "GB")
+
 	an_artist = api_client.artist.search("radiohead").first
+
 	a_release = an_artist.releases(:page_size=>100).sort_by{|release| release.year}.last
+
 	puts "the latest #{an_artist.name} release is #{a_release.title} from #{a_release.year}"
+
 	puts "go and buy it at #{a_release.url} !"
 
+
 ==Usage details
 
 ===Initializing & configuring an API Client

data/lib/sevendigital.rb

@@ -43,8 +43,10 @@ module Sevendigital
 
 end  # module 7digital
 
-require 'peachy'
-Peachy.be_quiet
+require 'nokogiri'
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'logger'
 require File.join( File.dirname( File.expand_path(__FILE__)), 'sevendigital', 'client_configuration')
 require File.join( File.dirname( File.expand_path(__FILE__)), 'sevendigital', 'management', 'manager')
 require File.join( File.dirname( File.expand_path(__FILE__)), 'sevendigital', 'digestion_tract', 'digestor')

data/lib/sevendigital/api_operator.rb

@@ -11,121 +11,119 @@ module Sevendigital
   #deals with OAuth signing requests that require signature, making sure parameters are in correct format etc
   class ApiOperator # :nodoc:
 
-  RESERVED_CHARACTERS = /[^a-zA-Z0-9\-\.\_\~]/
+    RESERVED_CHARACTERS = /[^a-zA-Z0-9\-\.\_\~]/
 
-  def initialize(client)
-    @client = client
-  end
+    def initialize(client)
+      @client = client
+    end
 
-  def call_api(api_request)
-    api_response = make_http_request_and_digest(api_request)
-    puts api_response.content.to_s if @client.very_verbose?
-    api_response
-  end
+    def call_api(api_request)
+      make_http_request_and_digest(api_request).tap do |api_response|
+        @client.log(:verbose) { "ApiOperator: API Response: #{api_response}" }
+      end
+    end
 
-  def get_request_uri(api_request)
-    api_request.signature_scheme = :query_string if api_request.requires_signature?
-    http_client, http_request = create_http_request(api_request)
-    path = http_request.instance_variable_get("@path")
-    host = http_client.instance_variable_get("@address")
-    port = http_client.instance_variable_get("@port")
-    scheme = port == 443 ? "https" : "http"
-    return "#{scheme}://#{host}#{path}"
-  end
+    def get_request_uri(api_request)
+      api_request.signature_scheme = :query_string if api_request.requires_signature?
+      http_client, http_request = create_http_request(api_request)
+      path = http_request.instance_variable_get("@path")
+      host = http_client.instance_variable_get("@address")
+      port = http_client.instance_variable_get("@port")
+      scheme = port == 443 ? "https" : "http"
+      "#{scheme}://#{host}#{path}"
+    end
 
-  def make_http_request_and_digest(api_request)
+    def make_http_request_and_digest(api_request)
       digest_http_response(make_http_request(api_request))
-  end
-
-  def make_http_request(api_request)
-
-    http_client, http_request = create_http_request(api_request)
-
-    http_client.set_debug_output($stdout) if @client.very_verbose?
-    log_request(http_request) if @client.verbose?
+    end
 
-    http_client.request(http_request)
-  end
+    def make_http_request(api_request)
+      http_client, http_request = create_http_request(api_request)
+      @client.log(:verbose) { "ApiOperator: Making HTTP Request..." }
+      http_client.request(http_request).tap do |http_response|
+        puts @client.inspect
+        puts http_response.inspect
+        @client.log(:verbose) { "ApiOperator: Response Headers: #{http_response.header.to_yaml}" }
+      end
+    end
 
-  def digest_http_response(http_response)
-    api_response = @client.api_response_digestor.from_http_response(http_response)
-    raise Sevendigital::SevendigitalError.new(api_response.error_code, api_response.error_message), "#{api_response.error_code} - #{api_response.error_message}" if !api_response.ok?
-    api_response
-  end
+    def digest_http_response(http_response)
+      @client.api_response_digestor.from_http_response(http_response).tap do |api_response|
+        unless api_response.ok?
+          raise Sevendigital::SevendigitalError.new(api_response.error_code, api_response.error_message), "#{api_response.error_code} - #{api_response.error_message}"
+        end
+      end
+    end
 
-  def create_http_request(api_request)
-    http_client, http_request = create_standard_http_request(api_request)
-    if (api_request.requires_signature?) then
-      oauth_sign_request(http_client, http_request, api_request)
-    else
+    def create_http_request(api_request)
+      http_client, http_request = create_standard_http_request(api_request)
+      if (api_request.requires_signature?)
+        oauth_sign_request(http_client, http_request, api_request)
+      else
+      end
+      [http_client, http_request]
     end
-    return http_client, http_request
-  end
 
-  def oauth_sign_request(http_client, http_request, api_request)
-    http_request.oauth!( \
-    http_client, \
-      @client.oauth_consumer, \
-      api_request.token, \
-      {:scheme => api_request.signature_scheme}
-    )
-    return http_request
-  end
+    def oauth_sign_request(http_client, http_request, api_request)
+      http_request.oauth!( \
+      http_client, \
+        @client.oauth_consumer, \
+        api_request.token, \
+        {:scheme => api_request.signature_scheme}
+      )
+      http_request
+    end
 
-  def create_standard_http_request(api_request)
-    request_uri = create_request_uri(api_request)
-    http_client = Net::HTTP.new(request_uri.host, request_uri.port)
+    def create_standard_http_request(api_request)
+      request_uri = create_request_uri(api_request)
+      http_client = Net::HTTP.new(request_uri.host, request_uri.port)
 
-    if !api_request.requires_signature? then
-      request_uri.query ||= ""
-      request_uri.query += "&oauth_consumer_key=#{@client.configuration.oauth_consumer_key}"
-    end
+      if !api_request.requires_signature?
+        request_uri.query ||= ""
+        request_uri.query += "&oauth_consumer_key=#{@client.configuration.oauth_consumer_key}"
+      end
 
-    http_request = new_http_request(request_uri.request_uri, api_request.http_method)
+      http_request = new_http_request(request_uri.request_uri, api_request.http_method)
 
-    ensure_secure_connection(http_client) if api_request.requires_secure_connection?
-    add_form_parameters(http_request, api_request)
+      ensure_secure_connection(http_client) if api_request.requires_secure_connection?
+      add_form_parameters(http_request, api_request)
 
-    return http_client, http_request
-  end
+      @client.log(:verbose) { "ApiOperator: Creating HTTP Request: #{request_uri}" }
 
-  def ensure_secure_connection(http_client)
-    http_client.use_ssl = true
-    http_client.verify_mode = OpenSSL::SSL::VERIFY_NONE
-  end
+      [http_client, http_request]
+    end
 
-  def create_request_uri(api_request)
-    host, version = @client.api_host_and_version(api_request.api_service)
-    path = "/#{version}/#{api_request.api_method}"
-    query = api_request.parameters.map{ |k,v| "#{escape(k)}=#{escape(v)}" }.join("&")
-    query = nil if query == ""
-    if api_request.requires_secure_connection? then
-      URI::HTTPS.build(:host => host, :path => path, :query =>query)
-    else
-      URI::HTTP.build(:host => host, :path => path, :query =>query)
+    def ensure_secure_connection(http_client)
+      http_client.use_ssl     = true
+      http_client.verify_mode = OpenSSL::SSL::VERIFY_NONE
     end
-  end
 
-  def new_http_request(request_uri, http_method)
-    request_type = Kernel.const_get("Net").const_get("HTTP").const_get(http_method.to_s.capitalize)
-    request_type.new(request_uri, {"user-agent" => @client.user_agent_info})
-  end
+    def create_request_uri(api_request)
+      host, version = @client.api_host_and_version(api_request.api_service)
+      path = "/#{version}/#{api_request.api_method}"
+      query = api_request.parameters.map{ |k,v| "#{escape(k)}=#{escape(v)}" }.join("&")
+      query = nil if query == ""
+      if api_request.requires_secure_connection? then
+        URI::HTTPS.build(:host => host, :path => path, :query =>query)
+      else
+        URI::HTTP.build(:host => host, :path => path, :query =>query)
+      end
+    end
 
-  def add_form_parameters(http_request, api_request)
-    http_request.body = api_request.form_parameters.map {|k, v| "#{escape(k)}=#{escape(v)}" }.flatten.join('&')
-    http_request.content_type = 'application/x-www-form-urlencoded'
-  end
+    def new_http_request(request_uri, http_method)
+      request_type = Kernel.const_get("Net").const_get("HTTP").const_get(http_method.to_s.capitalize)
+      request_type.new(request_uri, {"user-agent" => @client.user_agent_info})
+    end
 
-  def escape(value)
-    URI::escape(value.to_s, RESERVED_CHARACTERS)
-  rescue ArgumentError
-    URI::escape(value.to_s.force_encoding(Encoding::UTF_8), RESERVED_CHARACTERS)
-  end
+    def add_form_parameters(http_request, api_request)
+      http_request.body = api_request.form_parameters.map {|k, v| "#{escape(k)}=#{escape(v)}" }.flatten.join('&')
+      http_request.content_type = 'application/x-www-form-urlencoded'
+    end
 
-  def log_request(request)
-    puts "ApiOperator calling #{request.inspect}" if @client.verbose?
+    def escape(value)
+      URI::escape(value.to_s, RESERVED_CHARACTERS)
+    rescue ArgumentError
+      URI::escape(value.to_s.force_encoding(Encoding::UTF_8), RESERVED_CHARACTERS)
+    end
   end
-
 end
-
-end

data/lib/sevendigital/api_operator_cached.rb

@@ -1,41 +1,63 @@
 module Sevendigital
+  #@private
+  #Cached version of ApiOperator
+  #If response for an API request is already in cache and
+  #and it hasn't expired returns the cached response is returned instead of making an API call
+  #otherwise uses methods inherited from ApiOperator to make an HTTP call to the API
+  class ApiOperatorCached < ApiOperator # :nodoc:
+    def initialize(client, cache)
+      @cache = cache
+      super(client)
+    end
 
-#@private
-#Cached version of ApiOperator
-#If response for an API request is already in cache and
-#and it hasn't expired returns the cached response is returned instead of making an API call
-#otherwise uses methods inherited from ApiOperator to make an HTTP call to the API
-class ApiOperatorCached < ApiOperator # :nodoc:
+    def call_api(api_request)
+      api_response = retrieve_from_cache(api_request)
+      api_response = cache_response(api_request) if response_out_of_date?(api_response)
 
-  def initialize(client, cache)
-    @cache = cache
-    super(client)
-  end
+      api_response.tap do |api_response|
+        @client.log(:verbose) { "ApiOperatorCached: API Response: #{api_response}" }
+      end
+    end
 
-  def call_api(api_request)
-    request_cache_key = create_request_uri(api_request)
-    http_response = @cache.get(request_cache_key.to_s) if !api_request.requires_signature?
-    puts "ApiOperatorCached: Got from cache #{request_cache_key}" if @client.verbose? && http_response
-    puts "but the response is out of date" if @client.verbose? && http_response && response_out_of_date?(http_response)
-    if (!http_response || response_out_of_date?(http_response)) then
-      http_response = make_http_request(api_request)
-      @cache.set(request_cache_key.to_s, http_response) if !api_request.requires_signature?
-    end
-    api_response = digest_http_response(http_response)
-    p api_response if @client.very_verbose?
-    api_response
-  end
 
-  def response_out_of_date?(http_response, current_time=nil)
-    return true if http_response.header.nil? || http_response.header["Date"].nil? || http_response.header["cache-control"].nil?
-    puts "cache headers present"
-    return true if  !(http_response.header["cache-control"] =~ /max-age=([0-9]+)/)
-    current_time ||= Time.now.utc
-    response_time = Time.parse(http_response.header["Date"])
-    max_age = /max-age=([0-9]+)/.match(http_response.header["cache-control"])[1].to_i
-    response_time + max_age < current_time
-  end
+    def response_out_of_date?(api_response, current_time=nil)
+      puts @client.inspect
+      (api_response.nil? || header_invalid?(api_response.headers) || cache_expired?(api_response.headers, current_time)).tap do |expired|
+        @client.log(:verbose) { "ApiOperatorCached: Cache response out of date" if expired }
+      end
+    end
 
-end
+  private
+
+    def header_invalid?(header)
+      header["Date"].nil? || header["cache-control"].nil? || !(header["cache-control"] =~ /max-age=([0-9]+)/)
+    end
 
+    def cache_expired?(header, current_time=nil)
+      (Time.parse(header["Date"]) + (/max-age=([0-9]+)/.match(header["cache-control"])[1].to_i)) < (current_time || Time.now.utc)
+    end
+
+    def cache_response(api_request)
+      digest_http_response(make_http_request(api_request)).tap do |api_response|
+        unless api_request.requires_signature?
+          key = request_cache_key(api_request)
+          @cache.respond_to?(:write) ? @cache.write(key, api_response) : @cache.set(key, api_response)
+          @client.log(:verbose) { "ApiOperatorCached: Storing response in cache..." }
+        end
+      end
+    end
+
+    def request_cache_key(api_request)
+      create_request_uri(api_request).to_s
+    end
+
+    def retrieve_from_cache(api_request)
+      unless api_request.requires_signature?
+        key = request_cache_key(api_request)
+        (@cache.respond_to?(:read) ? @cache.read(key) : @cache.get(key)).tap do |response|
+          @client.log(:verbose) { "ApiOperatorCached: Got from cache #{key}" if response }
+        end
+      end
+    end
+  end
 end

data/lib/sevendigital/api_request.rb

@@ -1,66 +1,62 @@
 module Sevendigital
+  #@private
+  #Abstraction of a HTTP API request, ApiOperator uses this ApiRequest to build a real HTTP requests
+  class ApiRequest # :nodoc:
+
+    attr_reader :api_method, :parameters, :signed
+    attr_accessor :token, :api_service, :http_method
+    attr_accessor :signature_scheme
+    attr_writer :form_parameters
+
+    def initialize(http_method, api_method, parameters, options={})
+      @api_method = api_method
+      @parameters = parameters
+      @signature_scheme = :header
+      @http_method = http_method
+      comb_parameters(parameters)
+      @form_parameters = Hash.new
+    end
 
-#@private
-#Abstraction of a HTTP API request, ApiOperator uses this ApiRequest to build a real HTTP requests
-class ApiRequest # :nodoc:
-
-  attr_reader :api_method, :parameters, :signed
-  attr_accessor :token, :api_service, :http_method
-  attr_accessor :signature_scheme
-  attr_writer :form_parameters
-
-  def initialize(http_method, api_method, parameters, options={})
-    @api_method = api_method
-    @parameters = parameters
-    @signature_scheme = :header
-    @http_method = http_method
-    comb_parameters(parameters)
-    @form_parameters = Hash.new
-  end
-
-  def form_parameters
-    comb_parameters(@form_parameters)
-  end
+    def form_parameters
+      comb_parameters(@form_parameters)
+    end
 
-  def requires_signature?
-    @signed == true
-  end
+    def requires_signature?
+      @signed == true
+    end
 
-  def require_signature
-    @signed = true
-  end
+    def require_signature
+      @signed = true
+    end
 
-  def requires_secure_connection?
-    @secure == true
-  end
+    def requires_secure_connection?
+      @secure == true
+    end
 
-  def require_secure_connection
-    @secure = true
-  end
+    def require_secure_connection
+      @secure = true
+    end
 
-  def comb_parameters(parameters)
-    comb_parameter(parameters, :pageSize, [:page_size, :per_page])
-    comb_parameter(parameters, :shopId, :shop_id)
-    comb_parameter(parameters, :imageSize, :image_size)
-    remove_empty_parameters(parameters)
-    parameters
-  end
+    def comb_parameters(parameters)
+      comb_parameter(parameters, :pageSize, [:page_size, :per_page])
+      comb_parameter(parameters, :shopId, :shop_id)
+      comb_parameter(parameters, :imageSize, :image_size)
+      remove_empty_parameters(parameters)
+      parameters
+    end
 
-  def comb_parameter(parameters, correct_name, alternative_names)
-    param_value = nil
-    alternative_names = [alternative_names] unless alternative_names.is_a?(Array)
-    alternative_names.each do |alternative_name|
-      param_value ||= parameters[alternative_name]
-      parameters.delete(alternative_name)
+    def comb_parameter(parameters, correct_name, alternative_names)
+      param_value = nil
+      alternative_names = [alternative_names] unless alternative_names.is_a?(Array)
+      alternative_names.each do |alternative_name|
+        param_value ||= parameters[alternative_name]
+        parameters.delete(alternative_name)
+      end
+      parameters[correct_name] ||= param_value if param_value
     end
-    parameters[correct_name] ||= param_value if param_value
-  end
 
-  def remove_empty_parameters(parameters)
-    parameters.delete_if { |key, value| value.nil? }
+    def remove_empty_parameters(parameters)
+      parameters.delete_if { |key, value| value.nil? }
+    end
   end
-
-
 end
-
-end