amazon-ecs 0.5.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+0.5.0 2006-09-12
+----------------
+Initial Release

data/README

@@ -0,0 +1,101 @@
+== amazon-ecs
+
+Generic Amazon E-commerce REST API using Hpricot with configurable 
+default options and method call options. Uses Response and 
+Element classes for easy access access to REST XML output. 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.0
+
+Links:
+* http://amazon-ecs.rubyforge.org
+* http://www.pluitsolutions.com/amazon-ecs
+
+== INSTALLATION
+
+  $ gem install amazon-ecs
+
+== EXAMPLE
+
+    # 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 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 pages
+    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 element text value, following the XML output structure
+      item.get('asin')
+      item.get('itemattributes/title')
+
+      # or you can also do it this way, to retrieve the title
+      atts = item.get('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 can retrieve them seperately
+        Amazon::Element.get(review, 'source')
+        Amazon::Element.get(review, 'content')
+      end
+    end
+
+Refer to Amazon ECS documentation for more information on Amazon REST request parameters and XML output:
+http://docs.amazonwebservices.com/AWSEcommerceService/2005-10-05/index.html
+
+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
+
+== LICENSE
+
+(The MIT License)
+
+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.

data/lib/amazon/ecs.rb

@@ -0,0 +1,264 @@
+require 'net/http'
+require 'hpricot'
+require 'cgi'
+
+module Amazon
+  class RequestError < StandardError; end
+  
+  # :include: README 
+  class Ecs
+    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.de/onca/xml?Service=AWSECommerceService',
+        :fr => 'http://webservices.amazon.co.jp/onca/xml?Service=AWSECommerceService'
+    }
+    
+    @@debug, @@options = nil
+
+    # 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    
+    
+    # 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 = self.options.merge(opts) if self.options
+      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 = self.options.merge(opts) if self.options
+      opts[:operation] = 'ItemLookup'
+      opts[:item_id] = item_id
+      
+      # not allowed in item_lookup
+      opts.delete(:search_index)
+      
+      self.send_request(opts)
+    end
+    
+    # Generic send request to ECS REST service. You have to specify the :operation parameter.
+    def self.send_request(opts)
+      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 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 RAILS_DEFAULT_LOGGER
+          RAILS_DEFAULT_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
+        
+        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
+  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
+
+    # 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='')
+      CGI::unescapeHTML(get(element, path))
+    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,91 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class Amazon::EcsTest < Test::Unit::TestCase
+
+  Amazon::Ecs.options = {:response_group => 'Large', :aWS_access_key_id => '0XQXXC6YV2C85DX1BF02'}
+
+  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 "images/P/0974514055.01._SCTHUMBZZZ_V1128790749_.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
+  
+  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  
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: amazon-ecs
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+date: 2006-12-07 00:00:00 +08:00
+summary: Generic Amazon E-commerce Service (ECS) REST API. Supports ECS 4.0.
+require_paths: 
+- lib
+email: herryanto@pluitsolutions.com
+homepage: http://amazon-ecs.rubyforge.net/
+rubyforge_project: 
+description: 
+autorequire: name
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Herryanto Siatono
+files: 
+- lib/amazon
+- lib/amazon/ecs.rb
+- README
+- CHANGELOG
+test_files: 
+- test/amazon/ecs_test.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- CHANGELOG
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.4"
+    version: