amazon-associates 0.6.3

data/lib/amazon-associates/responses/item_lookup_response.rb

@@ -0,0 +1,16 @@
+module Amazon
+  module Associates
+    class ItemLookupResponse < Response
+      xml_name 'ItemLookupResponse'
+      xml_reader :items, :as => [Item]
+      xml_reader :current_page, :from => 'xmlns:ItemPage', :as => Integer, :else => 1
+      xml_reader :request, :as => Request, :in => 'xmlns:Items', :required => true
+      xml_reader :request_query, :as => ItemLookupRequest, :from => 'xmlns:SimilarityLookupRequest', :in => 'xmlns:Items/xmlns:Request'
+
+      def item
+        raise IndexError, "more than one item" if items.size > 1
+        items.first
+      end
+    end
+  end
+end

data/lib/amazon-associates/responses/item_search_response.rb

@@ -0,0 +1,20 @@
+module Amazon
+  module Associates
+    class SearchResponse < Response
+      attr_accessor :url # TODO would be just a reader if we can figure out xml construction better
+      xml_reader :operation_request, :as => OperationRequest, :required => true
+      xml_reader :request, :as => Request, :in => 'xmlns:Items'
+      delegate :current_page, :to => :request_query
+
+      xml_reader :items, :as => [Item]
+      xml_reader :total_results, :in => 'xmlns:Items', :as => Integer
+      xml_reader :total_pages, :in => 'xmlns:Items', :as => Integer
+    end
+
+    class ItemSearchResponse < SearchResponse
+      xml_name 'ItemSearchResponse'
+
+      xml_reader :request_query, :as => ItemSearchRequest, :in => 'xmlns:Items/xmlns:Request', :required => true
+    end
+  end
+end

data/lib/amazon-associates/responses/response.rb

@@ -0,0 +1,27 @@
+module Amazon
+  module Associates
+    class Response < ApiResult
+      attr_reader :url
+
+      def errors
+        request.errors
+      end
+
+      def initialize(url)
+        @url = url
+      end
+
+      def ==(other)
+        (instance_variables.sort == other.instance_variables.sort) && instance_variables.all? do |v|
+          instance_variable_get(v) == other.instance_variable_get(v)
+        end
+      end
+
+    private
+      def after_parse
+        # these can't be done as blocks because we need @url available
+        raise errors.first unless errors.empty?
+      end
+    end
+  end
+end

data/lib/amazon-associates/responses/similarity_lookup_response.rb

@@ -0,0 +1,9 @@
+module Amazon
+  module Associates
+    class SimilarityLookupResponse < SearchResponse
+      xml_name 'SimilarityLookupResponse'
+
+#      xml_reader :request_query, :as => SimilarityLookupRequest, :in => 'Items/Request', :required => true
+    end
+  end
+end

data/lib/amazon-associates/types/api_result.rb

@@ -0,0 +1,8 @@
+module Amazon
+  module Associates
+    class ApiResult
+      include ROXML
+      xml_convention :camelcase
+    end
+  end
+end

data/lib/amazon-associates/types/browse_node.rb

@@ -0,0 +1,48 @@
+module Amazon
+  module Associates
+    class Item < ApiResult
+      # forward-declaration...
+    end
+
+    class BrowseNode < ApiResult
+      xml_reader :id, :from => 'xmlns:BrowseNodeId', :required => true
+      xml_reader :name, :from => 'Name'
+      xml_reader :parent, :as => BrowseNode, :from => 'xmlns:BrowseNode', :in => 'xmlns:Ancestors'
+      xml_reader :children, :as => [BrowseNode]
+      xml_reader :top_sellers, :as => [Item]
+
+      def initialize(id = nil, name = nil, parent = nil)
+        @id = id
+        @name = name
+        @parent = parent
+      end
+
+      def to_s
+        "#{@name}#{' : ' + @parent.to_s if @parent}"
+      end
+
+      def inspect
+        "#<#{self.class}:#{@id} #{self}>"
+      end
+
+      def ==(other)
+        return false unless other.respond_to?(:name, :id)
+        @name == other.name and @id == other.id
+      end
+
+      {:brand => [:manufacturers, :custom_brands], :type => [:categories]}.each_pair do |name, aliases|
+        define_method("#{name}?") do
+          markers = ([name] + aliases).map {|n| n.to_s.titleize}
+          return true if markers.include? instance_variable_get(:@name)
+
+          parent = instance_variable_get :@parent
+          while parent
+            return true if markers.include? parent.name
+            parent = parent.parent
+          end
+          false
+        end
+      end
+    end
+  end
+end

data/lib/amazon-associates/types/cart.rb

@@ -0,0 +1,87 @@
+require 'roxml'
+
+module Amazon
+  module Associates
+    class Cart < ApiResult
+      xml_reader :items, :as => [CartItem], :from => 'xmlns:CartItem', :in => 'xmlns:CartItems', :frozen => true
+      xml_reader :purchase_url, :from => 'xmlns:PurchaseURL'
+      xml_reader :id, :from => 'xmlns:CartId', :required => true
+      xml_reader :hmac, :from => 'xmlns:HMAC', :required => true
+
+      delegate :empty?, :include?, :to => :items
+
+      def to_hash
+        {:id => id,
+         :hmac => hmac}
+      end
+
+      #  CartCreate
+      # defaults:
+      #   response_group: Cart
+      #   merge_cart: false
+      #   list_item_id: nil
+      def self.create(items, args = nil)
+        if items.is_a?(Array)
+          items = items.inject({}) do |all, (item, count)|
+            all[item] = count || 1
+            all
+          end
+        end
+        Amazon::Associates.cart_create(items, args).cart
+      end
+
+      #  CartGet
+      def self.get(args)
+        Amazon::Associates.cart_get(args).cart
+      end
+
+      def save
+        @changes.each do |action, *args|
+          cart = Amazon::Associates.send(action, *args).cart
+          @items = cart.items
+          @id = cart.id
+          @hmac = cart.hmac
+        end
+        @changes.clear
+        self
+      end
+
+      def changed?
+        !@changes.empty?
+      end
+
+      def add(item, count = 1)
+        raise ArgumentError, "item is nil" if item.nil?
+        raise ArgumentError, "count isn't positive" if count <= 0
+
+        if @items.include? item
+          action = :cart_modify
+          item = @items.find {|i| i == item } # we need the CartItemId for CartModify
+          count += item.quantity
+        else
+          action = :cart_add
+        end
+        # TODO: This could be much more sophisticated, collapsing operations and such
+        @changes << [action, self, {:items => {item => count}}]
+      end
+      alias_method :<<, :add
+
+      def clear
+        @changes << [:cart_clear, self]
+      end
+
+      def quantity
+        items.sum(&:quantity)
+      end
+
+      def ==(other)
+        id == other.id
+      end
+
+    private
+      def initialize
+        @changes = []
+      end
+    end
+  end
+end

data/lib/amazon-associates/types/customer_review.rb

@@ -0,0 +1,15 @@
+module Amazon
+  module Associates
+    class CustomerReview < ApiResult
+      xml_name 'Review'
+      xml_reader :asin, :from => 'ASIN'
+      xml_reader :rating, :as => Integer
+      xml_reader :helpful_votes, :as => Integer
+      xml_reader :total_votes, :as => Integer
+      xml_reader :summary
+      xml_reader :content
+      xml_reader :customer_id
+      xml_reader :date, :as => Date
+    end
+  end
+end

data/lib/amazon-associates/types/editorial_review.rb

@@ -0,0 +1,8 @@
+module Amazon
+  module Associates
+    class EditorialReview < ApiResult
+      xml_reader :source
+      xml_reader :content
+    end
+  end
+end

data/lib/amazon-associates/types/error.rb

@@ -0,0 +1,8 @@
+module Amazon
+  module Associates
+    class Error < ApiResult
+      xml_reader :code
+      xml_reader :message
+    end
+  end
+end

data/lib/amazon-associates/types/image.rb

@@ -0,0 +1,37 @@
+module Amazon
+  module Associates
+    class Image < ApiResult
+      xml_reader :url, :from => 'URL'
+      xml_reader :width, :as => Measurement
+      xml_reader :height, :as => Measurement
+
+      def initialize(url = nil, width = nil, height = nil)
+        @url = url
+        @width = to_measurement(width)
+        @height = to_measurement(height)
+      end
+
+      def ==(other)
+        return nil unless other.is_a? Image
+        url == other.url and width == other.width and height == other.height
+      end
+
+      def size
+        unless height.units == 'pixels' and width.units == 'pixels'
+          raise 'size not available for images not denominated in pixels'
+        end
+
+        "#{width.value.round}x#{height.value.round}"
+      end
+
+      def inspect
+        "#<#{self.class}: #{url},#{width}x#{height}>"
+      end
+
+    private
+      def to_measurement(arg)
+        arg && (arg.is_a?(Measurement) ? arg : Measurement.new(arg, 'pixels'))
+      end
+    end
+  end
+end

data/lib/amazon-associates/types/image_set.rb

@@ -0,0 +1,11 @@
+module Amazon
+  module Associates
+    class ImageSet < ApiResult
+      xml_reader :category, :from => :attr, :required => true
+      xml_reader :small, :as => Image, :from => 'SmallImage'
+      xml_reader :medium, :as => Image, :from => 'MediumImage'
+      xml_reader :large, :as => Image, :from => 'LargeImage'
+      xml_reader :swatch, :as => Image, :from => 'SwatchImage'
+    end
+  end
+end

data/lib/amazon-associates/types/item.rb

@@ -0,0 +1,156 @@
+require 'will_paginate/collection'
+
+module Amazon
+  module Associates
+    class Item < ApiResult
+      xml_name 'Item'
+
+      xml_reader :asin, :from => 'ASIN'
+      xml_reader :detail_page_url
+      xml_reader :list_price, :as => Price, :in => 'xmlns:ItemAttributes'
+      xml_reader :attributes, :as => {:key => :name,
+                                      :value => :content}, :in => 'xmlns:ItemAttributes'
+      xml_reader :small_image, :as => Image
+      xml_reader :medium_image, :as => Image
+      #TODO: would be nice to have :key => '@category' and :value => {[Image] => 'SwatchImage'}
+      xml_reader :image_sets, :as => [ImageSet] do |sets|
+        sets.index_by(&:category)
+      end
+      xml_reader :listmania_lists, :as => [ListmaniaList]
+      xml_reader :browse_nodes, :as => [BrowseNode]
+      xml_reader :offers, :as => [Offer]
+      # TODO: This should be offers.total_new
+      xml_reader :total_new_offers, :from => 'TotalNew', :in => 'xmlns:OfferSummary', :as => Integer
+      # TODO: This should be offers.total
+      xml_reader :total_offers, :in => 'xmlns:Offers', :as => Integer
+
+      xml_reader :creators, :as => {:key => '@Role', :value => :content}, :in => 'xmlns:ItemAttributes'
+      xml_reader :authors, :as => [], :in => 'xmlns:ItemAttributes'
+      xml_reader :edition, :as => Ordinal, :in => 'xmlns:ItemAttributes'
+      xml_reader :lowest_new_price, :as => Price, :in => 'xmlns:OfferSummary'
+      xml_reader :publisher, :studio, :batteries_included?, :label, :brand, :in => 'xmlns:ItemAttributes'
+
+      xml_reader :editorial_reviews, :as => [EditorialReview]
+      xml_reader :customer_reviews, :as => [CustomerReview]
+
+      def ==(other)
+        asin == other.asin
+      end
+
+      def eql?(other)
+        asin == other.asin
+      end
+
+      def author
+        authors.only
+      end
+
+      alias_method :offer_price, :lowest_new_price
+
+      def title
+        root_title || attr_title
+      end
+
+      def inspect
+        "#<#{self.class}: #{asin} #{attributes.inspect}>"
+      end
+
+      PER_PAGE = 10
+
+      def self.find(scope, opts = {})
+        opts = opts.dup # it seems this hash picks up some internal amazon stuff if we don't copy it
+
+        if scope.is_a? String
+          opts.merge!(:item_id => scope, :item_type => 'ASIN')
+          scope = :one
+        end
+
+        case scope
+        when :top_sellers then top_sellers(opts)
+        when :similar then similar(opts)
+        when :all     then all(opts)
+        when :first   then first(opts)
+        when :one     then one(opts)
+        else
+          raise ArgumentError, "scope should be :all, :first, :one, or an item id string"
+        end
+      end
+
+      def self.top_sellers(opts)
+        opts = opts.dup.to_options!
+        opts.merge!(:response_group => 'TopSellers')
+        opts[:browse_node_id] = opts.delete(:browse_node).id if opts[:browse_node]
+        items = Amazon::Associates.browse_node_lookup(opts).top_sellers.map {|i| i.text_at('asin') }
+        Amazon::Associates.item_lookup(:item_id => items * ',', :response_group => SMALL_RESPONSE_GROUPS).items
+      end
+
+      def self.similar(*ids)
+        opts = ids.extract_options!
+        opts.reverse_merge!(:response_group => SMALL_RESPONSE_GROUPS)
+        Amazon::Associates.similarity_lookup(ids, opts).items
+      end
+
+      def self.top_sellers(opts)
+        opts = opts.dup.to_options!
+        opts.merge!(:response_group => 'TopSellers')
+        opts[:browse_node_id] = opts.delete(:browse_node).id if opts[:browse_node]
+        items = Amazon::Associates.browse_node_lookup(opts).browse_nodes.map(&:top_sellers).flatten.map(&:asin)
+        Amazon::Associates.item_lookup(:item_id => items * ',', :response_group => SMALL_RESPONSE_GROUPS).items
+      end
+
+      def self.first(opts)
+        all(opts).first
+      end
+
+      def self.all(opts)
+        opts = opts.dup.to_options!
+        unless %w[All Blended Merchants].include? opts[:search_index]
+          opts.reverse_merge!(:merchant_id => 'Amazon',
+                              :condition => 'All')
+        end
+        opts[:availability] ||= 'Available' unless opts[:condition].nil? or opts[:condition] == 'New'
+        opts[:item_page]    ||= (opts.delete(:page) || 1)
+        prep_responses(opts)
+
+        response = Amazon::Associates.item_search(opts)
+
+        # TODO: Max count is different for different indexes, for example, All only returns 5 pages
+        WillPaginate::Collection.create(response.current_page, PER_PAGE, response.total_results) do |pager|
+          # TODO: Some of the returned items may not include offers, we may need something like this:
+          #.reject {|i| i.offers[:totaloffers] == '0' }
+          pager.replace response.items
+        end
+      end
+
+      def self.one(opts)
+        prep_responses(opts)
+        Amazon::Associates.item_lookup(opts.delete(:item_id), opts).items.first
+      end
+
+      def similar
+        Item.similar(asin)
+      end
+
+    private
+      xml_reader :attr_title, :from => 'xmlns:Title', :in => 'xmlns:ItemAttributes'
+      xml_reader :root_title, :from => 'xmlns:Title'
+
+      SMALL_RESPONSE_GROUPS = %w{Small ItemAttributes Images}
+      DEFAULT_RESPONSE_GROUPS = SMALL_RESPONSE_GROUPS + %w{Offers VariationSummary BrowseNodes}
+
+      def self.prep_responses(opts)
+        opts[:response_group] ||= []
+        unless opts[:response_group].is_a? Array
+          raise ArgumentError, "Response groups are required to be in array form"
+        end
+        opts[:response_group] += DEFAULT_RESPONSE_GROUPS
+      end
+    end
+
+    class CartItem < Item
+      # TODO: This could probably just be #id
+      xml_reader :cart_item_id
+      xml_reader :quantity, :as => Integer, :required => true
+    end
+  end
+end