willnet-amazon-ecs 0.5.5

data/CHANGELOG

@@ -0,0 +1,29 @@
+0.5.5 2009-07-10
+----------------
+* Added function of managing new request authentication
+
+0.5.4 2008-01-02
+----------------
+* Add Response#error_code
+
+0.5.3 2007-09-12
+----------------
+* send_request to use default options.
+
+0.5.2 2007-09-08
+----------------
+* Fixed Amazon::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,97 @@
+== amazon-ecs
+
+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>Amazon::Ecs</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.5.5
+
+== INSTALLATION
+
+  $ gem install amazon-ecs
+
+== EXAMPLE
+
+    require 'amazon/ecs'
+	
+    # set the default options; options will be camelized and converted to REST request parameters.
+    Amazon::Ecs.options = {:aWS_access_key_id => [your developer token]}
+
+    # options provided on method call will merge with the default options
+    res = Amazon::Ecs.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 (Amazon::Element)
+    res.items.each do |item|
+      # retrieve string value using XML path
+      item.get('asin')
+      item.get('itemattributes/title')
+
+      # or return Amazon::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
+        Amazon::Element.get_hash(review) # [:source => ..., :content ==> ...]
+    
+        # Or to get unescaped HTML values
+        Amazon::Element.get_unescaped(review, 'source')
+        Amazon::Element.get_unescaped(review, 'content')
+        
+        # Or this way
+        el = Amazon::Element.new(review)
+        el.get_unescaped('source')
+        el.get_unescaped('content')
+      end
+      
+      # returns Amazon::Element instead of string
+      item.search_and_convert('itemattributes').
+    end
+
+Refer to Amazon ECS 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
+
+== SOURCE CODES
+
+* http://github.com/jugend/amazon-ecs/tree/master
+
+== LINKS
+
+* http://amazon-ecs.rubyforge.org
+* http://www.pluitsolutions.com/amazon-ecs
+
+== LICENSE
+
+(The MIT License)
+
+Copyright (c) 2006 Herryanto Siatono, Pluit Solutions

data/lib/amazon/ecs.rb

@@ -0,0 +1,335 @@
+#--
+# 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.
+#++
+
+require 'net/http'
+require 'hpricot'
+require 'cgi'
+require 'openssl'
+require 'uri'
+require 'digest/sha2'
+require 'base64'
+
+module Amazon
+  class RequestError < StandardError; end
+  
+  class Ecs
+    SERVICE_URLS = {:us => 'http://webservices.amazon.com/onca/xml',
+        :uk => 'http://webservices.amazon.co.uk/onca/xml',
+        :ca => 'http://webservices.amazon.ca/onca/xml',
+        :de => 'http://webservices.amazon.de/onca/xml',
+        :jp => 'http://webservices.amazon.co.jp/onca/xml',
+        :fr => 'http://webservices.amazon.fr/onca/xml'
+    }
+    
+    @@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
+    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)
+      log "Request URL: #{request_url}"
+      
+      res = Net::HTTP.get_response(URI::parse(request_url))
+      unless res.kind_of? Net::HTTPSuccess
+        raise Amazon::RequestError, "HTTP Response: #{res.code} #{res.message}"
+      end
+      Response.new(res.body)
+    end
+
+    # Response object returned after a REST call to Amazon service.
+    class Response
+      # XML input is in string format
+      def initialize(xml)
+        @doc = Hpricot(xml)
+      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 error code
+      def error_code
+        Element.get(@doc, "error/code")
+      end
+      
+      # Return an array of Amazon::Element item objects.
+      def items
+        unless @items
+          @items = (@doc/"item").collect {|item| Element.new(item)}
+        end
+        @items
+      end
+      
+      # Return the first item (Amazon::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
+    
+    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 Amazon::RequestError, "Invalid country '#{country}'" unless request_url
+      secret_access_key = opts.delete(:secret_access_key)
+      raise Amazon::RequestError, "secret_access_key is nil" unless secret_access_key
+      opts[:Timestamp] = DateTime.now.new_offset.strftime('%Y-%m-%dT%XZ')
+      opts[:Service] = "AWSECommerceService"
+      opts[:Version] = "2009-01-06"
+      qs = opts.map do |k, v|
+        [camelize(k.to_s), v]
+      end
+      qs.reject! do |k,v| v.to_s.empty? end
+      qs.sort!
+      qs.map! do |k,v|
+        v = v.join(',') if v.is_a? Array
+        [k, CGI.escape(v.to_s)] * "="
+      end
+      qs = qs * "&"
+      uri = URI.parse(request_url + "?" + qs)
+      msg = [ 'GET', uri.host, uri.path, uri.query ].join("\n")
+      dig = hmac_sha256(secret_access_key, msg)
+      sig = CGI.escape(Base64.encode64(dig).chomp)
+      "#{request_url}?#{qs}&Signature=#{sig}"
+    end
+
+    IPAD = "\x36"
+    OPAD = "\x5c"
+    def self.hmac_sha256(key, message)
+      ikey = IPAD * 64
+      okey = OPAD * 64
+      key.size.times do |i|
+        ikey[i] = key[i] ^ ikey[i]
+        okey[i] = key[i] ^ okey[i]
+      end
+      value = Digest::SHA256.digest(ikey + message)
+      value = Digest::SHA256.digest(okey + value)
+    end
+
+    def self.camelize(s)
+      s.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    end
+  end
+
+  # Internal wrapper class to provide convenient method to access Hpricot element value.
+  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 Amazon::Element.
+    # Returns an array Amazon::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/test/amazon/ecs_test.rb

@@ -0,0 +1,110 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class Amazon::EcsTest < Test::Unit::TestCase
+
+  AWS_ACCESS_KEY_ID = '1ZD53WRGR730ZCVWBSG2'
+  raise "Please specify set your AWS_ACCESS_KEY_ID" if AWS_ACCESS_KEY_ID.empty?
+  
+  Amazon::Ecs.configure do |options|
+    options[:response_group] = 'Large'
+    options[:aWS_access_key_id] = AWS_ACCESS_KEY_ID
+  end
+
+  ## Test item_search
+
+  def test_item_search
+    resp = Amazon::Ecs.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 = Amazon::Ecs.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 = Amazon::Ecs.item_search(nil)
+    assert !resp.is_valid_request?
+  end
+
+  def test_item_search_with_no_result
+    resp = Amazon::Ecs.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 = Amazon::Ecs.item_search('ruby', :country => :uk)
+    assert resp.is_valid_request?
+  end
+  
+  def test_item_search_by_author
+    resp = Amazon::Ecs.item_search('dave', :type => :author)
+    assert resp.is_valid_request?
+  end
+  
+  def test_item_get
+    resp = Amazon::Ecs.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_match ".jpg", small_image[:url]
+    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 Amazon::Element.get_unescaped(review, 'source')
+		assert Amazon::Element.get_unescaped(review, 'content')
+	end
+  end
+  
+  ## Test item_lookup
+  def test_item_lookup
+    resp = Amazon::Ecs.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 = Amazon::Ecs.item_lookup(nil)
+    assert resp.has_error?
+    assert resp.error
+  end
+
+  def test_item_lookup_with_no_result
+    resp = Amazon::Ecs.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 = Amazon::Ecs.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,66 @@
+--- !ruby/object:Gem::Specification 
+name: willnet-amazon-ecs
+version: !ruby/object:Gem::Version 
+  version: 0.5.5
+platform: ruby
+authors: 
+- Herryanto Siatono
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.4"
+    version: 
+description: 
+email: herryanto@pluitsolutions.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGELOG
+files: 
+- lib/amazon
+- lib/amazon/ecs.rb
+- README
+- CHANGELOG
+has_rdoc: true
+homepage: http://amazon-ecs.rubyforge.net/
+post_install_message: 
+rdoc_options: []
+
+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 E-commerce Service (ECS) REST API. Supports ECS 4.0.
+test_files: 
+- test/amazon/ecs_test.rb