dpickett-amazon_associate 0.6.1

data/CHANGELOG

@@ -0,0 +1,34 @@
+0.6.1 2008-11-10
+* renamed to amazon_associate
+
+0.6 2008-11-09
+* separated the classes in ecs.rb
+* filesystem caching available
+* more test coverage
+
+0.5.4 2008-10-21
+* include Chris Martin's patches
+* rename Gem to match Amazon's new name for ECS - Amazon Associates API
+* update to git gemspec format
+
+0.5.3 2007-09-12
+----------------
+* send_request to use default options.
+
+0.5.2 2007-09-08
+----------------
+* Fixed AmazonAssociate::Element.get_unescaped error when result returned for given element path is nil
+
+0.5.1 2007-02-08
+----------------
+* Fixed Amazon Japan and France URL error
+* Removed opts.delete(:search_index) from item_lookup, SearchIndex param is allowed 
+  when looking for a book with IdType other than the ASIN.
+* Check for defined? RAILS_DEFAULT_LOGGER to avoid exception for non-rails ruby app
+* Added check for LOGGER constant if RAILS_DEFAULT_LOGGER is not defined
+* Added Ecs.configure(&proc) method for easier configuration of default options
+* Added Element#search_and_convert method
+
+0.5.0 2006-09-12
+----------------
+Initial Release

data/README

@@ -0,0 +1,108 @@
+== amazon-associate
+
+Generic Amazon E-commerce REST API using Hpricot with configurable 
+default options and method call options. Uses Response and 
+Element wrapper classes for easy access to REST XML output. It supports ECS 4.0.
+
+It is generic, so you can easily extend <tt>AmazonAssociate::Request</tt> to support 
+other not implemented REST operations; and it is also generic because it just wraps around
+Hpricot element object, instead of providing one-to-one object/attributes to XML elements map.
+
+If in the future, there is a change in REST XML output structure, 
+no changes will be required on <tt>amazon-ecs</tt> library, 
+instead you just need to change the element path.
+
+Version: 0.6.1
+
+== WANTS
+ * instance based refactoring (singletons are not ideal here)
+ 
+== INSTALLATION
+
+  $ gem install dpickett-amazon_associate
+
+== EXAMPLE
+
+    require 'amazon_associate'
+	
+    # set the default options; options will be camelized and converted to REST request parameters.
+    AmazonAssociate::Request.options = {:aWS_access_key_id => [your developer token]}
+
+    # options provided on method call will merge with the default options
+    res = AmazonAssociate::Request.item_search('ruby', {:response_group => 'Medium', :sort => 'salesrank'})
+
+    # some common response object methods
+    res.is_valid_request?     # return true if request is valid
+    res.has_error?            # return true if there is an error
+    res.error                 # return error message if there is any
+    res.total_pages           # return total pages
+    res.total_results         # return total results
+    res.item_page             # return current page no if :item_page option is provided
+
+    # traverse through each item (AmazonAssociate::Element)
+    res.items.each do |item|
+      # retrieve string value using XML path
+      item.get('asin')
+      item.get('itemattributes/title')
+
+      # or return AmazonAssociate::Element instance
+      atts = item.search_and_convert('itemattributes')
+      atts.get('title')
+  
+      # return first author or a string array of authors
+      atts.get('author')          # 'Author 1'
+      atts.get_array('author')    # ['Author 1', 'Author 2', ...]
+  
+      # return an hash of children text values with the element names as the keys
+      item.get_hash('smallimage') # {:url => ..., :width => ..., :height => ...}
+  
+      # note that '/' returns Hpricot::Elements array object, nil if not found
+      reviews = item/'editorialreview'
+  
+      # traverse through Hpricot elements
+      reviews.each do |review|
+        # Getting hash value out of Hpricot element
+        AmazonAssociate::Element.get_hash(review) # [:source => ..., :content ==> ...]
+    
+        # Or to get unescaped HTML values
+        AmazonAssociate::Element.get_unescaped(review, 'source')
+        AmazonAssociate::Element.get_unescaped(review, 'content')
+        
+        # Or this way
+        el = AmazonAssociate::Element.new(review)
+        el.get_unescaped('source')
+        el.get_unescaped('content')
+      end
+      
+      # returns AmazonAssociate::Element instead of string
+      item.search_and_convert('itemattributes').
+    end
+
+Refer to Amazon Associate's documentation for more information on Amazon REST request parameters and XML output:
+http://docs.amazonwebservices.com/AWSEcommerceService/2006-09-13/
+
+To get a sample of Amazon REST response XML output, use AWSZone.com scratch pad:
+http://www.awszone.com/scratchpads/aws/ecs.us/index.aws
+
+== CACHING
+
+  Filesystem caching is now available.
+  
+  AmazonAssociate::Request.options = {:aWS_access_key_id => [your developer token], :caching_strategy => :filesystem, 
+    :caching_options => {:disk_quota => 200, :cache_path => <path where you want to store requests>, :sweep_frequency => 4}
+  }
+  
+  The above command will cache up to 200MB of requests. It will purge the cache every 4 hours or when the disk quota has been exceeded.
+  
+  Every request will be stored in the cache path. On every request, AmazonAssociate::Request will check for the presence of the cached file before querying Amazon directly.
+
+== LINKS
+
+* http://amazon-ecs.rubyforge.org
+* http://www.pluitsolutions.com/amazon-ecs
+
+== LICENSE
+
+(The MIT License)
+
+Copyright (c) 2008 Dan Pickett, Enlight Solutions, Inc.

data/lib/amazon_associate.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.dirname(__FILE__))
+
+require "amazon_associate/request"
+require "amazon_associate/element"
+require "amazon_associate/response"
+require "amazon_associate/cache_factory"
+require "amazon_associate/caching_strategy"
+require "amazon_associate/configuration_error"
+require "amazon_associate/request_error"

data/lib/amazon_associate/cache_factory.rb

@@ -0,0 +1,30 @@
+module AmazonAssociate
+  class CacheFactory
+    def self.cache(request, response, strategy)
+      strategy_class_hash[strategy].cache(request, response)
+    end
+  
+    def self.initialize_options(options)
+      #check for a valid caching strategy
+      unless self.strategy_class_hash.keys.include?(options[:caching_strategy])
+        raise AmazonAssociate::ConfigurationError, "Invalid caching strategy" 
+      end
+      strategy_class_hash[options[:caching_strategy]].initialize_options(options)
+    end
+  
+    def self.get(request, strategy)
+      strategy_class_hash[strategy].get(request)
+    end
+  
+    def self.sweep(strategy)
+      strategy_class_hash[strategy].sweep
+    end
+  
+    private
+    def self.strategy_class_hash
+      {
+        :filesystem => AmazonAssociate::CachingStrategy::Filesystem
+      }
+    end
+  end
+end

data/lib/amazon_associate/caching_strategy.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), "caching_strategy/base")
+require File.join(File.dirname(__FILE__), "caching_strategy/filesystem")

data/lib/amazon_associate/caching_strategy/base.rb

@@ -0,0 +1,22 @@
+#abstract class
+module AmazonAssociate
+  module CachingStrategy
+    class Base
+      def self.cache(request, response)
+        raise "This method must be overwritten by a caching strategy"
+      end
+    
+      def self.initialize_options(options)
+        raise "This method must be overwritten by a caching strategy"
+      end
+    
+      def self.get(request)
+        raise "This method must be overwritten by a caching strategy"
+      end
+    
+      def self.sweep
+        raise "This method must be overwritten by a caching strategy"
+      end
+    end
+  end
+end

data/lib/amazon_associate/caching_strategy/filesystem.rb

@@ -0,0 +1,114 @@
+require "fileutils"
+require "find"
+
+module AmazonAssociate
+  module CachingStrategy
+    class Filesystem < AmazonAssociate::CachingStrategy::Base
+      #disk quota in megabytes
+      DEFAULT_DISK_QUOTA = 200
+    
+      #frequency of sweeping in hours
+      DEFAULT_SWEEP_FREQUENCY = 2
+    
+      def self.cache(request, response)
+        path = self.cache_path
+        cached_filename = Digest::SHA1.hexdigest(response.request_url)
+        cached_folder = cached_filename[0..2]
+      
+        FileUtils.mkdir_p(File.join(path, cached_folder, cached_folder))
+      
+        cached_file = File.open(File.join(path, cached_folder, cached_filename), "w")
+        cached_file.puts response.doc.to_s
+        cached_file.close
+      end
+    
+      def self.get(request)
+        path = self.cache_path
+        cached_filename = Digest::SHA1.hexdigest(request)
+        file_path = File.join(path, cached_filename[0..2], cached_filename)
+        if FileTest.exists?(file_path)
+          File.read(file_path).chomp
+        else
+          nil
+        end
+      end
+    
+      def self.initialize_options(options)      
+        #check for required options
+        if options[:caching_options].nil?
+          raise AmazonAssociate::ConfigurationError, "You must specify caching options for filesystem caching: :cache_path is required"
+        end
+      
+        #default disk quota to 200MB
+        @@disk_quota = options[:caching_options][:disk_quota] || DEFAULT_DISK_QUOTA
+      
+        @@sweep_frequency = options[:caching_options][:sweep_frequency] || DEFAULT_SWEEP_FREQUENCY
+      
+        @@cache_path = options[:caching_options][:cache_path]
+      
+        if @@cache_path.nil? || !File.directory?(@@cache_path)
+          raise AmazonAssociate::ConfigurationError, "You must specify a cache path for filesystem caching"
+        end
+      
+        return options
+      end
+    
+      def self.sweep
+        self.perform_sweep if must_sweep?
+      end
+    
+      def self.disk_quota
+        @@disk_quota
+      end
+    
+      def self.sweep_frequency
+        @@sweep_frequency
+      end
+    
+      def self.cache_path
+        @@cache_path
+      end
+    
+      private
+      def self.perform_sweep
+        FileUtils.rm_rf(Dir.glob("#{@@cache_path}/*"))
+      
+        self.timestamp_sweep_performance
+      end
+    
+      def self.timestamp_sweep_performance
+        #remove the timestamp
+        FileUtils.rm_rf(self.timestamp_filename)
+      
+        #create a new one its place
+        timestamp = File.open(self.timestamp_filename, "w")
+        timestamp.puts(Time.now)
+        timestamp.close
+      end
+    
+      def self.must_sweep?
+        sweep_time_expired? || disk_quota_exceeded?
+      end
+    
+      def self.sweep_time_expired?
+        FileTest.exists?(timestamp_filename) && Time.parse(File.read(timestamp_filename).chomp) < Time.now - (sweep_frequency * 3600)
+      end
+    
+      def self.disk_quota_exceeded?
+        cache_size > @@disk_quota
+      end
+    
+      def self.timestamp_filename
+        File.join(self.cache_path, ".amz_timestamp")
+      end
+    
+      def self.cache_size
+        size = 0
+        Find.find(@@cache_path) do|f|
+           size += File.size(f) if File.file?(f)
+        end
+        size / 1000000
+      end
+    end
+  end
+end

data/lib/amazon_associate/configuration_error.rb

@@ -0,0 +1,4 @@
+module AmazonAssociate
+  class ConfigurationError < RuntimeError
+  end
+end

data/lib/amazon_associate/element.rb

@@ -0,0 +1,100 @@
+# Internal wrapper class to provide convenient method to access Hpricot element value.
+module AmazonAssociate
+  class Element
+    # Pass Hpricot::Elements object
+    def initialize(element)
+      @element = element
+    end
+
+    # Returns Hpricot::Elments object    
+    def elem
+      @element
+    end
+
+    # Find Hpricot::Elements matching the given path. Example: element/"author".
+    def /(path)
+      elements = @element/path
+      return nil if elements.size == 0
+      elements
+    end
+
+    # Find Hpricot::Elements matching the given path, and convert to AmazonAssociate::Element.
+    # Returns an array AmazonAssociate::Elements if more than Hpricot::Elements size is greater than 1.
+    def search_and_convert(path)
+      elements = self./(path)
+      return unless elements
+      elements = elements.map{|element| Element.new(element)}
+      return elements.first if elements.size == 1
+      elements
+    end
+
+    # Get the text value of the given path, leave empty to retrieve current element value.
+    def get(path="")
+      Element.get(@element, path)
+    end
+
+    # Get the unescaped HTML text of the given path.
+    def get_unescaped(path="")
+      Element.get_unescaped(@element, path)
+    end
+
+    # Get the array values of the given path.
+    def get_array(path="")
+      Element.get_array(@element, path)
+    end
+
+    # Get the children element text values in hash format with the element names as the hash keys.
+    def get_hash(path="")
+      Element.get_hash(@element, path)
+    end
+
+    # Similar to #get, except an element object must be passed-in.
+    def self.get(element, path="")
+      return unless element
+      result = element.at(path)
+      result = result.inner_html if result
+      result
+    end
+
+    # Similar to #get_unescaped, except an element object must be passed-in.    
+    def self.get_unescaped(element, path="")
+      result = get(element, path)
+      CGI::unescapeHTML(result) if result
+    end
+
+    # Similar to #get_array, except an element object must be passed-in.
+    def self.get_array(element, path="")
+      return unless element
+  
+      result = element/path
+      if (result.is_a? Hpricot::Elements) || (result.is_a? Array)
+        parsed_result = []
+        result.each {|item|
+          parsed_result << Element.get(item)
+        }
+        parsed_result
+      else
+        [Element.get(result)]
+      end
+    end
+
+    # Similar to #get_hash, except an element object must be passed-in.
+    def self.get_hash(element, path="")
+      return unless element
+
+      result = element.at(path)
+      if result
+        hash = {}
+        result = result.children
+        result.each do |item|
+          hash[item.name.to_sym] = item.inner_html
+        end 
+        hash
+      end
+    end
+
+    def to_s
+      elem.to_s if elem
+    end
+  end
+end

data/lib/amazon_associate/request.rb

@@ -0,0 +1,277 @@
+require "net/http"
+require "hpricot"
+require "cgi"
+
+begin
+  require 'md5'
+rescue LoadError
+  require 'digest/md5'
+end
+
+#--
+# Copyright (c) 2006 Herryanto Siatono, Pluit Solutions
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+module AmazonAssociate
+  class Request
+    
+    SERVICE_URLS = {:us => "http://webservices.amazon.com/onca/xml?Service=AWSECommerceService",
+        :uk => "http://webservices.amazon.co.uk/onca/xml?Service=AWSECommerceService",
+        :ca => "http://webservices.amazon.ca/onca/xml?Service=AWSECommerceService",
+        :de => "http://webservices.amazon.de/onca/xml?Service=AWSECommerceService",
+        :jp => "http://webservices.amazon.co.jp/onca/xml?Service=AWSECommerceService",
+        :fr => "http://webservices.amazon.fr/onca/xml?Service=AWSECommerceService"
+    }
+  
+    # The sort types available to each product search index.
+    SORT_TYPES = {
+      "Apparel" => %w[relevancerank salesrank pricerank inverseprice -launch-date sale-flag],
+      "Automotive" => %w[salesrank price -price titlerank -titlerank],
+      "Baby" => %w[psrank salesrank price -price titlerank],
+      "Beauty" => %w[pmrank salesrank price -price -launch-date sale-flag],
+      "Books" => %w[relevancerank salesrank reviewrank pricerank inverse-pricerank daterank titlerank -titlerank],
+      "Classical" => %w[psrank salesrank price -price titlerank -titlerank orig-rel-date],
+      "DigitalMusic" => %w[songtitlerank uploaddaterank],
+      "DVD" => %w[relevancerank salesrank price -price titlerank -video-release-date],
+      "Electronics" => %w[pmrank salesrank reviewrank price -price titlerank],
+      "GourmetFood" => %w[relevancerank salesrank pricerank inverseprice launch-date sale-flag],
+      "HealthPersonalCare" => %w[pmrank salesrank pricerank inverseprice launch-date sale-flag],
+      "Jewelry" => %w[pmrank salesrank pricerank inverseprice launch-date],
+      "Kitchen" => %w[pmrank salesrank price -price titlerank -titlerank],
+      "Magazines" => %w[subslot-salesrank reviewrank price -price daterank titlerank -titlerank],
+      "Merchants" => %w[relevancerank salesrank pricerank inverseprice launch-date sale-flag],
+      "Miscellaneous" => %w[pmrank salesrank price -price titlerank -titlerank],
+      "Music" => %w[psrank salesrank price -price titlerank -titlerank artistrank orig-rel-date release-date],
+      "MusicalInstruments" => %w[pmrank salesrank price -price -launch-date sale-flag],
+      "MusicTracks" => %w[titlerank -titlerank],
+      "OfficeProducts" => %w[pmrank salesrank reviewrank price -price titlerank],
+      "OutdoorLiving" => %w[psrank salesrank price -price titlerank -titlerank],
+      "PCHardware" => %w[psrank salesrank price -price titlerank],
+      "PetSupplies" => %w[+pmrank salesrank price -price titlerank -titlerank],
+      "Photo" => %w[pmrank salesrank titlerank -titlerank],
+      "Restaurants" => %w[relevancerank titlerank],
+      "Software" => %w[pmrank salesrank titlerank price -price],
+      "SportingGoods" => %w[relevancerank salesrank pricerank inverseprice launch-date sale-flag],
+      "Tools" => %w[pmrank salesrank titlerank -titlerank price -price],
+      "Toys" => %w[pmrank salesrank price -price titlerank -age-min],
+      "VHS" => %w[relevancerank salesrank price -price titlerank -video-release-date],
+      "Video" => %w[relevancerank salesrank price -price titlerank -video-release-date],
+      "VideoGames" => %w[pmrank salesrank price -price titlerank],
+      "Wireless" => %w[daterank pricerank invers-pricerank reviewrank salesrank titlerank -titlerank], 
+      "WirelessAccessories" => %w[psrank salesrank titlerank -titlerank]
+    }
+  
+    # Returns an Array of valid sort types for _search_index_, or +nil+ if _search_index_ is invalid.
+    def self.sort_types(search_index)
+      SORT_TYPES.has_key?(search_index) ? SORT_TYPES[search_index] : nil
+    end
+  
+    # Performs BrowseNodeLookup request, defaults to TopSellers ResponseGroup
+    def self.browse_node_lookup(browse_node_id, opts = {})
+      opts = self.options.merge(opts) if self.options
+      opts[:response_group] = opts[:response_group] || "TopSellers"
+      opts[:operation] = "BrowseNodeLookup"
+      opts[:browse_node_id] = browse_node_id
+    
+      self.send_request(opts)
+    end
+  
+    # Cart operations build the Item tags from the ASIN
+    # Item.ASIN.Quantity defaults to 1, unless otherwise specified in _opts_
+  
+    # Creates remote shopping cart containing _asin_
+    def self.cart_create(asin, opts = {})
+      opts = self.options.merge(opts) if self.options
+      opts[:operation] = "CartCreate"
+      opts["Item.#{asin}.Quantity"] = opts[:quantity] || 1
+      opts["Item.#{asin}.ASIN"] = asin
+  
+      self.send_request(opts)
+    end
+  
+    # Adds item to remote shopping cart
+    def self.cart_add(asin, cart_id, hmac, opts = {})
+      opts = self.options.merge(opts) if self.options
+      opts[:operation] = "CartAdd"
+      opts["Item.#{asin}.Quantity"] = opts[:quantity] || 1
+      opts["Item.#{asin}.ASIN"] = asin
+      opts[:cart_id] = cart_id
+      opts[:hMAC] = hmac
+  
+      self.send_request(opts)
+    end
+  
+    # Adds item to remote shopping cart
+    def self.cart_get(cart_id, hmac, opts = {})
+      opts = self.options.merge(opts) if self.options
+      opts[:operation] = "CartGet"
+      opts[:cart_id] = cart_id
+      opts[:hMAC] = hmac
+  
+      self.send_request(opts)
+    end
+  
+    # modifies _cart_item_id_ in remote shopping cart
+    # _quantity_ defaults to 0 to remove the given _cart_item_id_
+    # specify _quantity_ to update cart contents
+    def self.cart_modify(cart_item_id, cart_id, hmac, quantity=0, opts = {})
+      opts = self.options.merge(opts) if self.options
+      opts[:operation] = "CartModify"
+      opts["Item.1.CartItemId"] = cart_item_id
+      opts["Item.1.Quantity"] = quantity
+      opts[:cart_id] = cart_id
+      opts[:hMAC] = hmac
+  
+      self.send_request(opts)
+    end
+  
+    # clears contents of remote shopping cart
+    def self.cart_clear(cart_id, hmac, opts = {})
+      opts = self.options.merge(opts) if self.options
+      opts[:operation] = "CartClear"
+      opts[:cart_id] = cart_id
+      opts[:hMAC] = hmac
+  
+      self.send_request(opts)
+    end
+    @@options = {}
+    @@debug = false
+
+    # Default search options
+    def self.options
+      @@options
+    end
+  
+    # Set default search options
+    def self.options=(opts)
+      @@options = opts
+    end
+  
+    # Get debug flag.
+    def self.debug
+      @@debug
+    end
+  
+    # Set debug flag to true or false.
+    def self.debug=(dbg)
+      @@debug = dbg
+    end
+  
+    def self.configure(&proc)
+      raise ArgumentError, "Block is required." unless block_given?
+      
+      yield @@options
+      if !@@options[:caching_strategy].nil?
+        @@options.merge!(CacheFactory.initialize_options(@@options))
+      end
+    end
+  
+    # Search amazon items with search terms. Default search index option is "Books".
+    # For other search type other than keywords, please specify :type => [search type param name].
+    def self.item_search(terms, opts = {})
+      opts[:operation] = "ItemSearch"
+      opts[:search_index] = opts[:search_index] || "Books"
+    
+      type = opts.delete(:type)
+      if type 
+        opts[type.to_sym] = terms
+      else 
+        opts[:keywords] = terms
+      end
+    
+      self.send_request(opts)
+    end
+
+    # Search an item by ASIN no.
+    def self.item_lookup(item_id, opts = {})
+      opts[:operation] = "ItemLookup"
+      opts[:item_id] = item_id
+    
+      self.send_request(opts)
+    end    
+        
+    # Generic send request to ECS REST service. You have to specify the :operation parameter.
+    def self.send_request(opts)
+      opts = self.options.merge(opts) if self.options
+      request_url = prepare_url(opts)
+      response = nil
+
+      if caching_enabled?
+        AmazonAssociate::CacheFactory.sweep(self.options[:caching_strategy])
+        
+        res = AmazonAssociate::CacheFactory.get(request_url, self.options[:caching_strategy]) 
+        response = Response.new(res, request_url) unless res.nil?
+      end
+      
+      if !caching_enabled? || response.nil?
+        log "Request URL: #{request_url}"
+        res = Net::HTTP.get_response(URI::parse(request_url))
+        unless res.kind_of? Net::HTTPSuccess
+          raise AmazonAssociate::RequestError, "HTTP Response: #{res.code} #{res.message}"
+        end
+        response = Response.new(res.body, request_url)
+        cache_response(request_url, response, self.options[:caching_strategy]) if caching_enabled?
+      end
+        
+      response
+    end
+  
+    protected
+      def self.log(s)
+        return unless self.debug
+        if defined? RAILS_DEFAULT_LOGGER
+          RAILS_DEFAULT_LOGGER.error(s)
+        elsif defined? LOGGER
+          LOGGER.error(s)
+        else
+          puts s
+        end
+      end
+    
+    private 
+      def self.prepare_url(opts)
+        country = opts.delete(:country)
+        country = (country.nil?) ? "us" : country
+        request_url = SERVICE_URLS[country.to_sym]
+        raise AmazonAssociate::RequestError, "Invalid country \"#{country}\"" unless request_url
+      
+        qs = ""
+        opts.each {|k,v|
+          next unless v
+          v = v.join(",") if v.is_a? Array
+          qs << "&#{camelize(k.to_s)}=#{URI.encode(v.to_s)}"
+        }
+        "#{request_url}#{qs}"
+      end
+    
+      def self.camelize(s)
+        s.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+      end
+      
+      def self.caching_enabled?
+        !self.options[:caching_strategy].nil?
+      end
+      
+      def self.cache_response(request, response, options)
+        AmazonAssociate::CacheFactory.cache(request, response, options)
+      end
+  end
+end

data/lib/amazon_associate/request_error.rb

@@ -0,0 +1,4 @@
+module AmazonAssociate
+  class RequestError < RuntimeError
+  end
+end

data/lib/amazon_associate/response.rb

@@ -0,0 +1,74 @@
+module AmazonAssociate
+  # Response object returned after a REST call to Amazon service.
+  class Response
+    
+    attr_accessor :request_url
+    # XML input is in string format
+    def initialize(xml, request_url)
+      @doc = Hpricot(xml)
+      @items = nil
+      @item_page = nil
+      @total_results = nil
+      @total_pages = nil
+    
+      self.request_url = request_url
+    end
+
+    # Return Hpricot object.
+    def doc
+      @doc
+    end
+
+    # Return true if request is valid.
+    def is_valid_request?
+      (@doc/"isvalid").inner_html == "True"
+    end
+
+    # Return true if response has an error.
+    def has_error?
+      !(error.nil? || error.empty?)
+    end
+
+    # Return error message.
+    def error
+      Element.get(@doc, "error/message")
+    end
+
+    # Return an array of AmazonAssociate::Element item objects.
+    def items
+      unless @items
+        @items = (@doc/"item").collect {|item| Element.new(item)}
+      end
+      @items
+    end
+
+    # Return the first item (AmazonAssociate::Element)
+    def first_item
+      items.first
+    end
+
+    # Return current page no if :item_page option is when initiating the request.
+    def item_page
+      unless @item_page
+        @item_page = (@doc/"itemsearchrequest/itempage").inner_html.to_i
+      end
+      @item_page
+    end
+
+    # Return total results.
+    def total_results
+      unless @total_results
+        @total_results = (@doc/"totalresults").inner_html.to_i
+      end
+      @total_results
+    end
+
+    # Return total pages.
+    def total_pages
+      unless @total_pages
+        @total_pages = (@doc/"totalpages").inner_html.to_i
+      end
+      @total_pages
+    end
+  end
+end

data/test/amazon_associate/browse_node_lookup_test.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class AmazonAssociate::BrowseNodeLookupTest < Test::Unit::TestCase
+  
+  ## Test browse_node_lookup
+  def test_browse_node_lookup
+    resp = AmazonAssociate::Request.browse_node_lookup("5")
+    assert resp.is_valid_request?
+    browse_node_tags = resp.doc.get_elements_by_tag_name("browsenodeid")
+    browse_node_tags.each { |node| assert_equal("5", node.inner_text) }
+    assert_equal "TopSellers", resp.doc.get_elements_by_tag_name("responsegroup").inner_text
+  end
+  
+  def test_browse_node_lookup_with_browse_node_info_response
+    resp = AmazonAssociate::Request.browse_node_lookup("5", :response_group => "BrowseNodeInfo")
+    assert resp.is_valid_request?
+    assert_equal "BrowseNodeInfo", resp.doc.get_elements_by_tag_name("responsegroup").inner_text
+  end
+  
+  def test_browse_node_lookup_with_new_releases_response
+    resp = AmazonAssociate::Request.browse_node_lookup("5", :response_group => "NewReleases")
+    assert resp.is_valid_request?
+    assert_equal "NewReleases", resp.doc.get_elements_by_tag_name("responsegroup").inner_text
+  end
+  
+  def test_browse_node_lookup_with_invalid_request
+    resp = AmazonAssociate::Request.browse_node_lookup(nil)
+    assert resp.has_error?
+    assert resp.error
+  end
+
+  def test_browse_node_lookup_with_no_result
+    resp = AmazonAssociate::Request.browse_node_lookup("abc")
+    
+    assert resp.is_valid_request?
+    assert_match(/abc is not a valid value for BrowseNodeId/, resp.error)
+  end
+end

data/test/amazon_associate/cache_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class AmazonAssociate::CacheTest < Test::Unit::TestCase
+  include FilesystemTestHelper
+  context "caching get" do
+    setup do
+      get_cache_directory
+      get_valid_caching_options
+    end
+    
+    teardown do
+      destroy_cache_directory
+      destroy_caching_options
+    end
+    
+    should "optionally allow for a caching strategy in configuration" do
+      assert_nothing_raised do
+        AmazonAssociate::Request.configure do |options|
+          options[:caching_strategy] = :filesystem
+        end
+      end
+    end
+    
+    should "raise an exception if a caching strategy is specified that is not found" do
+      assert_raises(AmazonAssociate::ConfigurationError) do
+        AmazonAssociate::Request.configure do |options|
+          options[:caching_strategy] = "foo"
+        end
+      end
+    end
+    
+    
+  end
+end

data/test/amazon_associate/caching_strategy/filesystem_test.rb

@@ -0,0 +1,183 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+class AmazonAssociate::CachingStrategy::FilesystemTest < Test::Unit::TestCase
+  include FilesystemTestHelper
+  context "setting up filesystem caching" do
+    teardown do
+      AmazonAssociate::Request.configure do |options|
+        options[:caching_strategy] = nil
+        options[:caching_options] = nil
+      end
+    end
+    
+    should "require a caching options hash with a cache_path key" do
+      assert_raises(AmazonAssociate::ConfigurationError) do
+        AmazonAssociate::Request.configure do |options|
+          options[:caching_strategy] = :filesystem
+          options[:caching_options] = nil
+        end
+      end
+    end
+    
+    should "raise an exception when a cache_path is specified that doesn't exist" do
+      assert_raises(AmazonAssociate::ConfigurationError) do
+        AmazonAssociate::Request.configure do |options|
+          options[:caching_strategy] = :filesystem
+          options[:caching_options] = {:cache_path => "foo123"}
+        end
+      end
+    end
+    
+    should "set default values for disk_quota and sweep_frequency" do
+      AmazonAssociate::Request.configure do |options|
+        options[:caching_strategy] = :filesystem
+        options[:caching_options] = {:cache_path => "."}
+      end
+      
+      assert_equal AmazonAssociate::CachingStrategy::Filesystem.disk_quota, AmazonAssociate::CachingStrategy::Filesystem.disk_quota
+      assert_equal AmazonAssociate::CachingStrategy::Filesystem.sweep_frequency, AmazonAssociate::CachingStrategy::Filesystem.sweep_frequency
+    end
+    
+    should "override the default value for disk quota if I specify one" do
+      quota = 400
+      AmazonAssociate::Request.configure do |options|
+        options[:caching_strategy] = :filesystem
+        options[:caching_options] = {:cache_path => ".", :disk_quota => quota}
+      end
+      
+      assert_equal quota, AmazonAssociate::CachingStrategy::Filesystem.disk_quota
+    end
+    
+    should "override the default value for cache_frequency if I specify one" do
+      frequency = 4
+      AmazonAssociate::Request.configure do |options|
+        options[:caching_strategy] = :filesystem
+        options[:caching_options] = {:cache_path => ".", :sweep_frequency => frequency}
+      end
+      
+      assert_equal frequency, AmazonAssociate::CachingStrategy::Filesystem.sweep_frequency
+    end
+  end
+  
+  context "caching a request" do
+    
+    setup do
+      get_cache_directory
+      get_valid_caching_options
+      @resp = AmazonAssociate::Request.item_lookup("0974514055")
+      @filename = Digest::SHA1.hexdigest(@resp.request_url)
+    end
+    
+    teardown do
+      destroy_cache_directory
+      destroy_caching_options
+    end
+    
+    should "create a folder in the cache path with the first three letters of the digested filename" do
+      filename = Digest::SHA1.hexdigest(@resp.request_url)
+      FileTest.exists?(File.join(@@cache_path, @filename[0..2]))      
+    end
+    
+    should "create a file in the cache path with a digested version of the url " do
+      
+      filename = Digest::SHA1.hexdigest(@resp.request_url)
+      assert FileTest.exists?(File.join(@@cache_path, @filename[0..2], @filename))
+    end
+    
+    should "create a file in the cache path with the response inside it" do
+      assert FileTest.exists?(File.join(@@cache_path + @filename[0..2], @filename))
+      assert_equal @resp.doc.to_s, File.read(File.join(@@cache_path + @filename[0..2], @filename)).chomp
+    end
+  end
+  
+  context "getting a cached request" do
+    setup do
+      get_cache_directory
+      get_valid_caching_options
+      do_request
+    end
+    
+    teardown do
+      destroy_cache_directory
+      destroy_caching_options
+    end
+    
+    should "not do an http request the second time the lookup is performed due a cached copy" do
+      Net::HTTP.expects(:get_response).never
+      do_request
+    end
+    
+    should "return the same response as the original request" do
+      original = @resp.doc.to_s
+      do_request
+      assert_equal(original, @resp.doc.to_s)
+    end
+  end
+  
+  context "sweeping cached requests" do
+    setup do
+      get_cache_directory
+      get_valid_caching_options
+      do_request
+    end
+    
+    teardown do
+      destroy_cache_directory
+      destroy_caching_options
+    end
+    
+    should "not perform the sweep if the timestamp is within the range of the sweep frequency and quota is not exceeded" do
+      AmazonAssociate::CachingStrategy::Filesystem.expects(:sweep_time_expired?).returns(false)
+      AmazonAssociate::CachingStrategy::Filesystem.expects(:disk_quota_exceeded?).returns(false)
+      
+      AmazonAssociate::CachingStrategy::Filesystem.expects(:perform_sweep).never
+      
+      do_request
+    end
+    
+    should "perform a sweep if the quota is exceeded" do
+      AmazonAssociate::CachingStrategy::Filesystem.stubs(:sweep_time_expired?).returns(false)
+      AmazonAssociate::CachingStrategy::Filesystem.expects(:disk_quota_exceeded?).once.returns(true)
+      
+      AmazonAssociate::CachingStrategy::Filesystem.expects(:perform_sweep).once
+      
+      do_request
+    end
+    
+    should "perform a sweep if the sweep time is expired" do
+      AmazonAssociate::CachingStrategy::Filesystem.expects(:sweep_time_expired?).once.returns(true)
+      AmazonAssociate::CachingStrategy::Filesystem.stubs(:disk_quota_exceeded?).returns(false)
+      AmazonAssociate::CachingStrategy::Filesystem.expects(:perform_sweep).once
+      
+      do_request
+    end
+    
+    should "create a timestamp file after performing a sweep" do
+      AmazonAssociate::CachingStrategy::Filesystem.expects(:sweep_time_expired?).once.returns(true)
+      
+      do_request
+      assert FileTest.exists?(File.join(@@cache_path, ".amz_timestamp"))
+    end
+    
+    should "purge the cache when performing a sweep" do
+      (0..9).each do |n| 
+        test = File.open(File.join(@@cache_path, "test_file_#{n}"), "w")
+        test.puts Time.now
+        test.close
+      end
+      
+      AmazonAssociate::CachingStrategy::Filesystem.expects(:sweep_time_expired?).once.returns(true)
+      do_request
+      
+      (0..9).each do |n|
+        assert !FileTest.exists?(File.join(@@cache_path, "test_file_#{n}"))
+      end
+    end
+    
+  end
+
+  protected
+  def do_request
+    @resp = AmazonAssociate::Request.item_lookup("0974514055")
+  end
+end

data/test/amazon_associate/cart_test.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class AmazonAssociate::CartTest < Test::Unit::TestCase
+  
+  # create a cart to store cart_id and hmac for add, get, modify, and clear tests
+  def setup
+    @asin = "0672328844"
+    resp = AmazonAssociate::Request.cart_create(@asin)
+    @cart_id = resp.doc.get_elements_by_tag_name("cartid").inner_text
+    @hmac = resp.doc.get_elements_by_tag_name("hmac").inner_text
+    item = resp.first_item
+    # run tests for cart_create with default quantity while we"re at it
+    assert resp.is_valid_request?
+    assert_equal @asin, item.get("asin")
+    assert_equal "1", item.get("quantity")
+    assert_not_nil @cart_id
+    assert_not_nil @hmac
+  end
+  
+  # Test cart_get
+  def test_cart_get
+    resp = AmazonAssociate::Request.cart_get(@cart_id, @hmac)
+    assert resp.is_valid_request?
+    assert_not_nil resp.doc.get_elements_by_tag_name("purchaseurl").inner_text
+  end
+  
+  # Test cart_modify
+  def test_cart_modify
+    resp = AmazonAssociate::Request.cart_get(@cart_id, @hmac)
+    cart_item_id = resp.doc.get_elements_by_tag_name("cartitemid").inner_text
+    resp = AmazonAssociate::Request.cart_modify(cart_item_id, @cart_id, @hmac, 2)
+    item = resp.first_item
+
+    assert resp.is_valid_request?
+    assert_equal "2", item.get("quantity")
+    assert_not_nil resp.doc.get_elements_by_tag_name("purchaseurl").inner_text
+  end
+  
+  # Test cart_clear
+  def test_cart_clear
+    resp = AmazonAssociate::Request.cart_clear(@cart_id, @hmac)
+    assert resp.is_valid_request?
+  end
+  
+  ## Test cart_create with a specified quantity
+  ## note this will create a separate cart
+  def test_cart_create_with_quantity
+    asin = "0672328844"
+    resp = AmazonAssociate::Request.cart_create(asin, :quantity => 2)
+    assert resp.is_valid_request?
+    item = resp.first_item
+    assert_equal asin, item.get("asin")
+    assert_equal "2", item.get("quantity")
+    assert_not_nil resp.doc.get_elements_by_tag_name("cartid").inner_text
+    assert_not_nil resp.doc.get_elements_by_tag_name("hmac").inner_text
+  end
+  
+end

data/test/amazon_associate/request_test.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class AmazonAssociate::RequestTest < Test::Unit::TestCase
+  def setup
+    AmazonAssociate::Request.configure do |options|
+      options[:response_group] = "Large"
+      
+    end
+  end
+  
+  ## Test item_search
+  def test_item_search
+    resp = AmazonAssociate::Request.item_search("ruby")
+    assert(resp.is_valid_request?)
+    assert(resp.total_results >= 3600)
+    assert(resp.total_pages >= 360)
+  end
+
+  def test_item_search_with_paging
+    resp = AmazonAssociate::Request.item_search("ruby", :item_page => 2)
+    assert resp.is_valid_request?
+    assert 2, resp.item_page
+  end
+
+  def test_item_search_with_invalid_request
+    resp = AmazonAssociate::Request.item_search(nil)
+    assert !resp.is_valid_request?
+  end
+
+  def test_item_search_with_no_result
+    resp = AmazonAssociate::Request.item_search("afdsafds")
+    
+    assert resp.is_valid_request?
+    assert_equal "We did not find any matches for your request.", 
+      resp.error
+  end
+  
+  def test_item_search_uk
+    resp = AmazonAssociate::Request.item_search("ruby", :country => :uk)
+    assert resp.is_valid_request?
+  end
+  
+  def test_item_search_by_author
+    resp = AmazonAssociate::Request.item_search("dave", :type => :author)
+    assert resp.is_valid_request?
+  end
+  
+  def test_item_get
+    resp = AmazonAssociate::Request.item_search("0974514055")
+    item = resp.first_item
+        
+    # test get
+    assert_equal "Programming Ruby: The Pragmatic Programmers' Guide, Second Edition", 
+      item.get("itemattributes/title")
+      
+    # test get_array
+    assert_equal ["Dave Thomas", "Chad Fowler", "Andy Hunt"], 
+      item.get_array("author")
+
+    # test get_hash
+    small_image = item.get_hash("smallimage")
+    
+    assert_equal 3, small_image.keys.size
+    assert small_image[:url] != nil
+    assert_equal "75", small_image[:height]
+    assert_equal "59", small_image[:width]
+    
+    # test /
+    reviews = item/"editorialreview"
+    reviews.each do |review|
+      # returns unescaped HTML content, Hpricot escapes all text values
+      assert AmazonAssociate::Element.get_unescaped(review, "source")
+      assert AmazonAssociate::Element.get_unescaped(review, "content")
+    end
+  end
+  
+  ## Test item_lookup
+  def test_item_lookup
+    resp = AmazonAssociate::Request.item_lookup("0974514055")
+    assert_equal "Programming Ruby: The Pragmatic Programmers' Guide, Second Edition", 
+    resp.first_item.get("itemattributes/title")
+  end
+  
+  def test_item_lookup_with_invalid_request
+    resp = AmazonAssociate::Request.item_lookup(nil)
+    assert resp.has_error?
+    assert resp.error
+  end
+
+  def test_item_lookup_with_no_result
+    resp = AmazonAssociate::Request.item_lookup("abc")
+    
+    assert resp.is_valid_request?
+    assert_match(/ABC is not a valid value for ItemId/, resp.error)
+  end  
+  
+  def test_search_and_convert
+    resp = AmazonAssociate::Request.item_lookup("0974514055")
+    title = resp.first_item.get("itemattributes/title")
+    authors = resp.first_item.search_and_convert("author")
+    
+    assert_equal "Programming Ruby: The Pragmatic Programmers' Guide, Second Edition", title
+    assert authors.is_a?(Array)
+    assert 3, authors.size
+    assert_equal "Dave Thomas", authors.first.get
+  end
+  
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: dpickett-amazon_associate
+version: !ruby/object:Gem::Version 
+  version: 0.6.1
+platform: ruby
+authors: 
+- Dan Pickett
+- Herryanto Siatono
+autorequire: amazon_associate
+bindir: bin
+cert_chain: []
+
+date: 2008-11-10 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.6"
+    version: 
+description: 
+email: 
+- dpickett@enlightsolutions.com
+- herryanto@pluitsolutions.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGELOG
+files: 
+- lib/amazon_associate
+- lib/amazon_associate/cache_factory.rb
+- lib/amazon_associate/caching_strategy
+- lib/amazon_associate/caching_strategy/base.rb
+- lib/amazon_associate/caching_strategy/filesystem.rb
+- lib/amazon_associate/caching_strategy.rb
+- lib/amazon_associate/configuration_error.rb
+- lib/amazon_associate/element.rb
+- lib/amazon_associate/request.rb
+- lib/amazon_associate/request_error.rb
+- lib/amazon_associate/response.rb
+- lib/amazon_associate.rb
+- test/amazon_associate/browse_node_lookup_test.rb
+- test/amazon_associate/cache_test.rb
+- test/amazon_associate/caching_strategy/filesystem_test.rb
+- test/amazon_associate/cart_test.rb
+- test/amazon_associate/request_test.rb
+- README
+- CHANGELOG
+has_rdoc: true
+homepage: http://github.com/dpickett/amazon_associate/tree/master
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Generic Amazon Associates Web Service (Formerly ECS) REST API. Supports ECS 4.0.
+test_files: 
+- test/amazon_associate/browse_node_lookup_test.rb
+- test/amazon_associate/cache_test.rb
+- test/amazon_associate/caching_strategy/filesystem_test.rb
+- test/amazon_associate/cart_test.rb
+- test/amazon_associate/request_test.rb