alexandria-book-collection-manager 0.7.1 → 0.7.6

data/lib/alexandria/book_providers/amazon_ecs_util.rb

@@ -1,393 +1,362 @@
-#--
-# 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.
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
 #
-# 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.
-#++
-
-# Modified by Cathal Mc Ginley 2008-02-18
-# added Amazon::Ecs.transport - to enable Alexandria's proxy support
-# Modified by Cathal Mc Ginley 2008-08-26
-# Amazon::Element.get now uses inner_text, not inner_html, fixing #21659
-# Modified by Cathal Mc Ginley 2009-08-13
-# Added sign_request and hmac_sha256 methods for Authentication support
-
-require 'net/http'
-require 'hpricot'
-require 'cgi'
-
-require 'digest/sha2'
-
-module Amazon
-  class RequestError < StandardError; end
-
-  class Ecs
-    include Alexandria::Logging
-
-    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' }.freeze
-
-    @@options = {}
-    @@debug = false
-
-    @@secret_access_key = ''
-
-    # Default search options
-    def self.options
-      @@options
-    end
+# See the file README.md for authorship and licensing information.
 
-    def self.secret_access_key=(key)
-      @@secret_access_key = key
-    end
+require "net/http"
+require "hpricot"
+require "cgi"
 
-    # Set default search options
-    def self.options=(opts)
-      @@options = opts
-    end
+require "digest/sha2"
 
-    # Get debug flag.
-    def self.debug
-      @@debug
-    end
+module Alexandria
+  module Amazon
+    class RequestError < StandardError; end
 
-    # Set debug flag to true or false.
-    def self.debug=(dbg)
-      @@debug = dbg
-    end
+    class Ecs
+      include Logging
 
-    def self.configure(&_proc)
-      raise ArgumentError, 'Block is required.' unless block_given?
-      yield @@options
-    end
+      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"
+      }.freeze
 
-    # 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
+      @@options = {}
+      @@debug = false
 
-      send_request(opts)
-    end
+      @@secret_access_key = ""
 
-    # Search an item by ASIN no.
-    def self.item_lookup(item_id, opts = {})
-      opts[:operation] = 'ItemLookup'
-      opts[:item_id] = item_id
+      # Default search options
+      def self.options
+        @@options
+      end
 
-      send_request(opts)
-    end
+      def self.secret_access_key=(key)
+        @@secret_access_key = key
+      end
 
-    # HACK : copied from book_providers.rb
-    def self.transport
-      config = Alexandria::Preferences.instance.http_proxy_config
-      config ? Net::HTTP.Proxy(*config) : Net::HTTP
-    end
+      # Set default search options
+      def self.options=(opts)
+        @@options = opts
+      end
 
-    # Generic send request to ECS REST service. You have to specify the :operation parameter.
-    def self.send_request(opts)
-      opts = options.merge(opts) if options
-      request_url = prepare_url(opts)
-      log.debug { "Request URL: #{request_url}" }
+      # Get debug flag.
+      def self.debug
+        @@debug
+      end
 
-      res = transport.get_response(URI.parse(request_url))
-      unless res.is_a? Net::HTTPSuccess
-        raise Amazon::RequestError, "HTTP Response: #{res.code} #{res.message}"
+      # Set debug flag to true or false.
+      def self.debug=(dbg)
+        @@debug = dbg
       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)
+      def self.configure(&_proc)
+        yield @@options
       end
 
-      # Return Hpricot object.
-      attr_reader :doc
+      # 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
 
-      # Return true if request is valid.
-      def is_valid_request?
-        (@doc / 'isvalid').inner_html == 'True'
+        send_request(opts)
       end
 
-      # Return true if response has an error.
-      def has_error?
-        !(error.nil? || error.empty?)
+      # Search an item by ASIN no.
+      def self.item_lookup(item_id, opts = {})
+        opts[:operation] = "ItemLookup"
+        opts[:item_id] = item_id
+
+        send_request(opts)
       end
 
-      # Return error message.
-      def error
-        Element.get(@doc, 'error/message')
+      # HACK : copied from book_providers.rb
+      def self.transport
+        config = Alexandria::Preferences.instance.http_proxy_config
+        config ? Net::HTTP.Proxy(*config) : Net::HTTP
       end
 
-      # Return an array of Amazon::Element item objects.
-      def items
-        unless @items
-          @items = (@doc / 'item').map { |item| Element.new(item) }
+      # Generic send request to ECS REST service. You have to specify the
+      # :operation parameter.
+      def self.send_request(opts)
+        opts = options.merge(opts) if options
+        request_url = prepare_url(opts)
+        log.debug { "Request URL: #{request_url}" }
+
+        res = transport.get_response(URI.parse(request_url))
+        unless res.is_a? Net::HTTPSuccess
+          raise Amazon::RequestError, format(_("HTTP Response: %<code>s %<message>s"),
+                                             code: res.code, message: res.message)
         end
-        @items
-      end
 
-      # Return the first item (Amazon::Element)
-      def first_item
-        items.first
+        Response.new(res.body)
       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
+      # 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
-        @item_page
-      end
 
-      # Return total results.
-      def total_results
-        unless @total_results
-          @total_results = (@doc / 'totalresults').inner_html.to_i
+        # Return Hpricot object.
+        attr_reader :doc
+
+        # 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
+          @items ||= (@doc / "item").map { |item| Element.new(item) }
+          @items
         end
-        @total_results
-      end
 
-      # Return total pages.
-      def total_pages
-        unless @total_pages
-          @total_pages = (@doc / 'totalpages').inner_html.to_i
+        # 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
+          @item_page ||= (@doc / "itemsearchrequest/itempage").inner_html.to_i
+          @item_page
+        end
+
+        # Return total results.
+        def total_results
+          @total_results ||= (@doc / "totalresults").inner_html.to_i
+          @total_results
+        end
+
+        # Return total pages.
+        def total_pages
+          @total_pages ||= (@doc / "totalpages").inner_html.to_i
+          @total_pages
         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
-
-    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)}"
-      }
-      url = "#{request_url}#{qs}"
-      # puts ">>> base url >> #{url}"
-      signed_url = sign_request(url)
-      # puts ">>> SIGNED >> #{signed_url}"
-      signed_url
-    end
+      def self.prepare_url(opts)
+        country = opts.delete(:country)
+        country = country.nil? ? "us" : country
+        request_url = SERVICE_URLS[country.to_sym]
+        unless request_url
+          raise Amazon::RequestError,
+                format(_("Invalid country '%<country>s'"), country: country)
+        end
 
-    def self.camelize(s)
-      s.to_s.gsub(/\/(.?)/) { '::' + Regexp.last_match[1].upcase }.gsub(/(^|_)(.)/) { Regexp.last_match[2].upcase }
-    end
+        qs = ""
+        opts.each do |k, v|
+          next unless v
 
-    def self.hmac_sha256(message, key)
-      block_size = 64
-      ipad = "\x36" * block_size
-      opad = "\x5c" * block_size
-      if key.size > block_size
-        d = Digest::SHA256.new
-        key = d.digest(key)
+          v = v.join(",") if v.is_a? Array
+          qs << "&#{camelize(k.to_s)}=#{CGI.escape(v.to_s)}"
+        end
+        url = "#{request_url}#{qs}"
+        sign_request(url)
       end
 
-      ipad_bytes = ipad.bytes.map { |b| b }
-      opad_bytes = opad.bytes.map { |b| b }
-      key_bytes = key.bytes.map { |b| b }
-      ipad_xor = ''
-      opad_xor = ''
-      for i in 0..key.size - 1
-        ipad_xor << (ipad_bytes[i] ^ key_bytes[i])
-        opad_xor << (opad_bytes[i] ^ key_bytes[i])
+      def self.camelize(string)
+        string.to_s
+          .gsub(%r{/(.?)}) { "::" + Regexp.last_match[1].upcase }
+          .gsub(/(^|_)(.)/) { Regexp.last_match[2].upcase }
       end
 
-      ipad = ipad_xor + ipad[key.size..-1]
-      opad = opad_xor + opad[key.size..-1]
+      def self.hmac_sha256(message, key)
+        block_size = 64
+        ipad = "\x36" * block_size
+        opad = "\x5c" * block_size
+        if key.size > block_size
+          d = Digest::SHA256.new
+          key = d.digest(key)
+        end
 
-      # inner hash
-      d1 = Digest::SHA256.new
-      d1.update(ipad)
-      d1.update(message)
-      msg_hash = d1.digest
+        ipad_bytes = ipad.bytes.map { |b| b }
+        opad_bytes = opad.bytes.map { |b| b }
+        key_bytes = key.bytes.map { |b| b }
+        ipad_xor = ""
+        opad_xor = ""
+        (0..key.size - 1).each do |i|
+          ipad_xor << (ipad_bytes[i] ^ key_bytes[i])
+          opad_xor << (opad_bytes[i] ^ key_bytes[i])
+        end
 
-      # outer hash
-      d2 = Digest::SHA256.new
-      d2.update(opad)
-      d2.update(msg_hash)
-      d2.digest
-    end
+        ipad = ipad_xor + ipad[key.size..-1]
+        opad = opad_xor + opad[key.size..-1]
 
-    def self.sign_request(request)
-      raise AmazonNotConfiguredError unless @@secret_access_key
-      # Step 0 : Split apart request string
-      url_pattern = /http:\/\/([^\/]+)(\/[^\?]+)\?(.*$)/
-      url_pattern =~ request
-      host = Regexp.last_match[1]
-      path = Regexp.last_match[2]
-      param_string = Regexp.last_match[3]
+        # inner hash
+        d1 = Digest::SHA256.new
+        d1.update(ipad)
+        d1.update(message)
+        msg_hash = d1.digest
 
-      # Step 1: enter the timestamp
-      t = Time.now.getutc # MUST be in UTC
-      stamp = t.strftime('%Y-%m-%dT%H:%M:%SZ')
-      param_string += "&Timestamp=#{stamp}"
+        # outer hash
+        d2 = Digest::SHA256.new
+        d2.update(opad)
+        d2.update(msg_hash)
+        d2.digest
+      end
 
-      # Step 2 : URL-encode
-      param_string = param_string.gsub(',', '%2C').gsub(':', '%3A')
-      #   NOTE : take care not to double-encode
+      def self.sign_request(request)
+        raise AmazonNotConfiguredError unless @@secret_access_key
 
-      # Step 3 : Split the parameter/value pairs
-      params = param_string.split('&')
+        # Step 0 : Split apart request string
+        url_pattern = %r{http://([^/]+)(/[^?]+)\?(.*$)}
+        url_pattern =~ request
+        host = Regexp.last_match[1]
+        path = Regexp.last_match[2]
+        param_string = Regexp.last_match[3]
 
-      # Step 4 : Sort params
-      params.sort!
+        # Step 1: enter the timestamp
+        t = Time.now.getutc # MUST be in UTC
+        stamp = t.strftime("%Y-%m-%dT%H:%M:%SZ")
+        param_string += "&Timestamp=#{stamp}"
 
-      # Step 5 : Rejoin the param string
-      canonical_param_string = params.join('&')
+        # Step 2 : URL-encode
+        param_string = param_string.gsub(",", "%2C").gsub(":", "%3A")
+        #   NOTE : take care not to double-encode
 
-      # Steps 6 & 7: Prepend HTTP request info
-      string_to_sign = "GET\n#{host}\n#{path}\n#{canonical_param_string}"
+        # Step 3 : Split the parameter/value pairs
+        params = param_string.split("&")
 
-      # puts string_to_sign
+        # Step 4 : Sort params
+        params.sort!
 
-      # Step 8 : Calculate RFC 2104-compliant HMAC with SHA256 hash algorithm
-      sig = hmac_sha256(string_to_sign, @@secret_access_key)
-      base64_sig = [sig].pack('m').strip
+        # Step 5 : Rejoin the param string
+        canonical_param_string = params.join("&")
 
-      # Step 9 : URL-encode + and = in sig
-      base64_sig = CGI.escape(base64_sig)
+        # Steps 6 & 7: Prepend HTTP request info
+        string_to_sign = "GET\n#{host}\n#{path}\n#{canonical_param_string}"
 
-      # Step 10 : Add the URL encoded signature to your request
-      "http://#{host}#{path}?#{param_string}&Signature=#{base64_sig}"
-    end
-  end
+        # Step 8 : Calculate RFC 2104-compliant HMAC with SHA256 hash algorithm
+        sig = hmac_sha256(string_to_sign, @@secret_access_key)
+        base64_sig = [sig].pack("m").strip
 
-  # Internal wrapper class to provide convenient method to access Hpricot element value.
-  class Element
-    # Pass Hpricot::Elements object
-    def initialize(element)
-      @element = element
-    end
+        # Step 9 : URL-encode + and = in sig
+        base64_sig = CGI.escape(base64_sig)
 
-    # Returns Hpricot::Elments object
-    def elem
-      @element
+        # Step 10 : Add the URL encoded signature to your request
+        "http://#{host}#{path}?#{param_string}&Signature=#{base64_sig}"
+      end
     end
 
-    # Find Hpricot::Elements matching the given path. Example: element/"author".
-    def /(path)
-      elements = @element / path
-      return nil if elements.empty?
-      elements
-    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
 
-    # 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
+      # Returns Hpricot::Elments object
+      def elem
+        @element
+      end
 
-    # Get the text value of the given path, leave empty to retrieve current element value.
-    def get(path = '')
-      Element.get(@element, path)
-    end
+      # Find Hpricot::Elements matching the given path. Example: element/"author".
+      def /(path)
+        elements = @element / path
+        return nil if elements.empty?
 
-    # Get the unescaped HTML text of the given path.
-    def get_unescaped(path = '')
-      Element.get_unescaped(@element, path)
-    end
+        elements
+      end
 
-    # Get the array values of the given path.
-    def get_array(path = '')
-      Element.get_array(@element, path)
-    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
 
-    # 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
+        elements = elements.map { |element| Element.new(element) }
+        return elements.first if elements.size == 1
 
-    # Similar to #get, except an element object must be passed-in.
-    def self.get(element, path = '')
-      return unless element
-      result = element.at(path)
-      ## inner_html doesn't decode entities, hence bug #21659
-      # result = result.inner_html if result
-      result = result.inner_text if result
-      result
-    end
+        elements
+      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
+      # Get the text value of the given path, leave empty to retrieve current element value.
+      def get(path = "")
+        Element.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)]
+      # Get the unescaped HTML text of the given path.
+      def get_unescaped(path = "")
+        Element.get_unescaped(@element, path)
       end
-    end
 
-    # Similar to #get_hash, except an element object must be passed-in.
-    def self.get_hash(element, path = '')
-      return unless element
+      # 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)
+        ## inner_html doesn't decode entities, hence bug #21659
+        # result = result.inner_html if result
+        result = result.inner_text 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 do |item|
+            parsed_result << Element.get(item)
+          end
+          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 = "")
+        result = element&.at(path)
+        return unless result
 
-      result = element.at(path)
-      if result
         hash = {}
         result = result.children
         result.each do |item|
@@ -395,10 +364,10 @@ module Amazon
         end
         hash
       end
-    end
 
-    def to_s
-      elem.to_s if elem
+      def to_s
+        elem&.to_s
+      end
     end
   end
 end