alexandria-book-collection-manager 0.7.3 → 0.7.8

data/lib/alexandria/book_providers/amazon_aws.rb

@@ -1,95 +1,81 @@
 # frozen_string_literal: true
 
-# Copyright (C) 2004-2006 Laurent Sansonetti
-# Copyright (C) 2008 Cathal Mc Ginley
-# Copyright (C) 2014, 2016 Matijs van Zuijlen
+# This file is part of Alexandria.
 #
-# Alexandria is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License as
-# published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version.
-#
-# Alexandria is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public
-# License along with Alexandria; see the file COPYING.  If not,
-# write to the Free Software Foundation, Inc., 51 Franklin Street,
-# Fifth Floor, Boston, MA 02110-1301 USA.
+# See the file README.md for authorship and licensing information.
 
 # http://en.wikipedia.org/wiki/Amazon
 
-require 'hpricot'
-require 'alexandria/book_providers/amazon_ecs_util'
+require "hpricot"
+require "alexandria/book_providers/amazon_ecs_util"
 
 module Alexandria
   class BookProviders
     class AmazonProvider < GenericProvider
       include Logging
       include GetText
-      GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: 'UTF-8')
+      GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
       # CACHE_DIR = File.join(Alexandria::Library::DIR, '.amazon_cache')
 
-      LOCALES = ['ca', 'de', 'fr', 'jp', 'uk', 'us'].freeze
+      LOCALES = ["ca", "de", "fr", "jp", "uk", "us"].freeze
 
       def initialize
-        super('Amazon', 'Amazon')
+        super("Amazon", "Amazon")
         # prefs.add("enabled", _("Enabled"), true, [true,false])
-        prefs.add('locale', _('Locale'), 'us', AmazonProvider::LOCALES)
-        prefs.add('dev_token', _('Access key ID'), '')
-        prefs.add('secret_key', _('Secret access key'), '')
-        prefs.add('associate_tag', _('Associate Tag'), '')
+        prefs.add("locale", _("Locale"), "us", AmazonProvider::LOCALES)
+        prefs.add("dev_token", _("Access key ID"), "")
+        prefs.add("secret_key", _("Secret access key"), "")
+        prefs.add("associate_tag", _("Associate Tag"), "")
 
         prefs.read
-        token = prefs.variable_named('dev_token')
+        token = prefs.variable_named("dev_token")
         # kill old (shorter) tokens, or previously distributed Access Key Id (see #26250)
 
         if token
           token.new_value = token.value.strip if token.value != token.value.strip
+          if (token.value.size != 20) || (token.value == "0J356Z09CN88KB743582")
+            token.new_value = ""
+          end
         end
-        token.new_value = '' if token && ((token.value.size != 20) || (token.value == '0J356Z09CN88KB743582'))
 
-        secret = prefs.variable_named('secret_key')
-        if secret
-          secret.new_value = secret.value.strip if secret.value != secret.value.strip
+        secret = prefs.variable_named("secret_key")
+        if secret && (secret.value != secret.value.strip)
+          secret.new_value = secret.value.strip
         end
 
-        associate = prefs.variable_named('associate_tag')
-        if associate
-          associate.new_value = 'rubyalexa-20' if associate.value.strip.empty?
-          associate.new_value = associate.value.strip if associate.value != associate.value.strip
+        associate = prefs.variable_named("associate_tag") or return
+
+        associate.new_value = "rubyalexa-20" if associate.value.strip.empty?
+        if associate.value != associate.value.strip
+          associate.new_value = associate.value.strip
         end
       end
 
       def search(criterion, type)
         prefs.read
 
-        if prefs['secret_key'].empty?
-          raise(Amazon::RequestError,
-                'Secret Access Key required for Authentication:' \
-                ' you must sign up for your own Amazon AWS account')
+        if prefs["secret_key"].empty?
+          raise(Amazon::RequestError, _("Provide secret key for your Amazon AWS account."))
         end
 
         if (config = Alexandria::Preferences.instance.http_proxy_config)
           host, port, user, pass = config
-          url = 'http://'
-          url += user + ':' + pass + '@' if user && pass
-          url += host + ':' + port.to_s
-          ENV['http_proxy'] = url
+          url = "http://"
+          url += user + ":" + pass + "@" if user && pass
+          url += host + ":" + port.to_s
+          ENV["http_proxy"] = url
         end
 
-        access_key_id = prefs['dev_token']
+        access_key_id = prefs["dev_token"]
 
         Amazon::Ecs.options = { aWS_access_key_id: access_key_id,
-                                associateTag: prefs['associate_tag'] }
-        Amazon::Ecs.secret_access_key = prefs['secret_key']
+                                associateTag: prefs["associate_tag"] }
+        Amazon::Ecs.secret_access_key = prefs["secret_key"]
         # #req.cache = Amazon::Search::Cache.new(CACHE_DIR)
         locales = AmazonProvider::LOCALES.dup
-        locales.delete prefs['locale']
-        locales.unshift prefs['locale']
+        locales.delete prefs["locale"]
+        locales.unshift prefs["locale"]
         locales.reverse!
 
         begin
@@ -99,8 +85,10 @@ module Alexandria
           when SEARCH_BY_ISBN
             criterion = Library.canonicalise_isbn(criterion)
             # This isn't ideal : I'd like to do an ISBN/EAN-specific search
-            res = Amazon::Ecs.item_search(criterion, response_group: 'ItemAttributes,Images',
-                                                     country: request_locale)
+            res = Amazon::Ecs.item_search(criterion,
+                                          response_group: "ItemAttributes,Images",
+                                          country: request_locale)
+
             res.items.each do |item|
               products << item
             end
@@ -120,27 +108,27 @@ module Alexandria
             # result with different ISBNs
 
             if products.length > 1
-              log.warn {
+              log.warn do
                 "ISBN search at Amazon[#{request_locale}] got #{products.length} results;" \
-                ' returning the first result only'
-              }
+                " returning the first result only"
+              end
             end
 
           when SEARCH_BY_TITLE
             res = Amazon::Ecs.item_search(criterion,
-                                          response_group: 'ItemAttributes,Images',
+                                          response_group: "ItemAttributes,Images",
                                           country: request_locale)
 
             res.items.each do |item|
-              products << item if item.get('itemattributes/title') =~ /#{criterion}/i
+              products << item if /#{criterion}/i.match?(item.get("itemattributes/title"))
             end
             # #req.keyword_search(criterion) do |product|
 
           when SEARCH_BY_AUTHORS
             criterion = "author:#{criterion}"
             res = Amazon::Ecs.item_search(criterion,
-                                          response_group: 'ItemAttributes,Images',
-                                          country: request_locale, type: 'Power')
+                                          response_group: "ItemAttributes,Images",
+                                          country: request_locale, type: "Power")
             res.items.each do |item|
               products << item
             end
@@ -148,7 +136,7 @@ module Alexandria
 
           when SEARCH_BY_KEYWORD
             res = Amazon::Ecs.item_search(criterion,
-                                          response_group: 'ItemAttributes,Images',
+                                          response_group: "ItemAttributes,Images",
                                           country: request_locale)
 
             res.items.each do |item|
@@ -158,78 +146,63 @@ module Alexandria
           else
             raise InvalidSearchTypeError
           end
-          raise Amazon::RequestError, 'No products' if products.empty?
+          raise Amazon::RequestError, _("No products") if products.empty?
           # raise NoResultsError if products.empty?
-        rescue Amazon::RequestError => re
-          log.debug { "Got Amazon::RequestError at #{request_locale}: #{re}" }
+        rescue Amazon::RequestError => ex
+          log.debug { "Got Amazon::RequestError at #{request_locale}: #{ex}" }
           retry unless locales.empty?
           raise NoResultsError
         end
 
         results = []
         products.each do |item|
-          next unless item.get('itemattributes/productgroup') == 'Book'
+          next unless item.get("itemattributes/productgroup") == "Book"
 
-          atts = item.search_and_convert('itemattributes')
-          title = normalize(atts.get('title'))
+          atts = item.search_and_convert("itemattributes")
+          title = normalize(atts.get("title"))
 
-          media = normalize(atts.get('binding'))
-          media = nil if media == 'Unknown Binding'
+          media = normalize(atts.get("binding"))
+          media = nil if media == "Unknown Binding"
 
-          isbn = normalize(atts.get('isbn'))
+          isbn = normalize(atts.get("isbn"))
           isbn = (Library.canonicalise_ean(isbn) if isbn && Library.valid_isbn?(isbn))
           # hack, extract year by regexp (not Y10K compatible :-)
-          /([1-9][0-9]{3})/ =~ atts.get('publicationdate')
+          /([1-9][0-9]{3})/ =~ atts.get("publicationdate")
           publishing_year = Regexp.last_match[1] ? Regexp.last_match[1].to_i : nil
           book = Book.new(title,
-                          atts.get_array('author').map { |x| normalize(x) },
+                          atts.get_array("author").map { |x| normalize(x) },
                           isbn,
-                          normalize(atts.get('manufacturer')),
+                          normalize(atts.get("manufacturer")),
                           publishing_year,
                           media)
 
-          image_url = item.get('mediumimage/url')
+          image_url = item.get("mediumimage/url")
           log.info { "Found at Amazon[#{request_locale}]: #{book.title}" }
           results << [book, image_url]
         end
         if type == SEARCH_BY_ISBN
           if results.size == 1
-            return results.first
+            results.first
           else
-            log.info { 'Found multiple results for lookup: checking each' }
-            query_isbn_canon = Library.canonicalise_ean(criterion)
-            results.each do |rslt|
-              book = rslt[0]
-              book_isbn_canon = Library.canonicalise_ean(book.isbn)
-              return rslt if query_isbn_canon == book_isbn_canon
-
-              log.debug { "rejected possible result #{book}" }
-            end
-            # gone through all and no ISBN match, so just return first result
-            log.info { 'no more results to check. Returning first result, just an approximation' }
-            return results.first
+            exact_match_or_first(criterion, results)
           end
         else
-          return results
+          results
         end
       end
 
+      LOCALE_URLS = {
+        "fr" => "http://www.amazon.fr/exec/obidos/ASIN/%s",
+        "uk" => "http://www.amazon.co.uk/exec/obidos/ASIN/%s",
+        "de" => "http://www.amazon.de/exec/obidos/ASIN/%s",
+        "ca" => "http://www.amazon.ca/exec/obidos/ASIN/%s",
+        "jp" => "http://www.amazon.jp/exec/obidos/ASIN/%s",
+        "us" => "http://www.amazon.com/exec/obidos/ASIN/%s"
+      }.freeze
+
       def url(book)
         isbn = Library.canonicalise_isbn(book.isbn)
-        url = case prefs['locale']
-              when 'fr'
-                'http://www.amazon.fr/exec/obidos/ASIN/%s'
-              when 'uk'
-                'http://www.amazon.co.uk/exec/obidos/ASIN/%s'
-              when 'de'
-                'http://www.amazon.de/exec/obidos/ASIN/%s'
-              when 'ca'
-                'http://www.amazon.ca/exec/obidos/ASIN/%s'
-              when 'jp'
-                'http://www.amazon.jp/exec/obidos/ASIN/%s'
-              when 'us'
-                'http://www.amazon.com/exec/obidos/ASIN/%s'
-              end
+        url = LOCALE_URLS.fetch(prefs["locale"])
         url % isbn
       rescue StandardError => ex
         log.warn { "Cannot create url for book #{book}; #{ex.message}" }
@@ -237,9 +210,30 @@ module Alexandria
       end
 
       def normalize(str)
-        str = str.squeeze(' ').strip unless str.nil?
+        str = str.squeeze(" ").strip unless str.nil?
         str
       end
+
+      private
+
+      def exact_match_or_first(criterion, results)
+        log.info { "Found multiple results for lookup: checking for exact isbn match" }
+        query_isbn_canon = Library.canonicalise_ean(criterion)
+        exact_match = results.find do |book, _|
+          book_isbn_canon = Library.canonicalise_ean(book.isbn)
+          query_isbn_canon == book_isbn_canon
+        end
+
+        if exact_match
+          # gone through all and no ISBN match, so just return first result
+          log.info do
+            "no more results to check. Returning first result, just an approximation"
+          end
+          exact_match
+        else
+          results.first
+        end
+      end
     end
   end
 end

data/lib/alexandria/book_providers/amazon_ecs_util.rb

@@ -1,397 +1,362 @@
 # frozen_string_literal: true
 
-#--
-# Copyright (c) 2006 Herryanto Siatono, Pluit Solutions
+# This file is part of Alexandria.
 #
-# 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.
-#++
-
-# 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?
+      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
 
-      yield @@options
-    end
+      @@options = {}
+      @@debug = false
 
-    # 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
+      @@secret_access_key = ""
 
-      send_request(opts)
-    end
+      # Default search options
+      def self.options
+        @@options
+      end
 
-    # Search an item by ASIN no.
-    def self.item_lookup(item_id, opts = {})
-      opts[:operation] = 'ItemLookup'
-      opts[:item_id] = item_id
+      def self.secret_access_key=(key)
+        @@secret_access_key = key
+      end
 
-      send_request(opts)
-    end
+      # Set default search options
+      def self.options=(opts)
+        @@options = opts
+      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
+      # Get debug flag.
+      def self.debug
+        @@debug
+      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}" }
+      # Set debug flag to true or false.
+      def self.debug=(dbg)
+        @@debug = dbg
+      end
 
-      res = transport.get_response(URI.parse(request_url))
-      unless res.is_a? Net::HTTPSuccess
-        raise Amazon::RequestError, "HTTP Response: #{res.code} #{res.message}"
+      def self.configure(&_proc)
+        yield @@options
       end
 
-      Response.new(res.body)
-    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
 
-    # Response object returned after a REST call to Amazon service.
-    class Response
-      # XML input is in string format
-      def initialize(xml)
-        @doc = Hpricot(xml)
+        send_request(opts)
       end
 
-      # Return Hpricot object.
-      attr_reader :doc
+      # Search an item by ASIN no.
+      def self.item_lookup(item_id, opts = {})
+        opts[:operation] = "ItemLookup"
+        opts[:item_id] = item_id
 
-      # 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?)
+      # 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 error message.
-      def error
-        Element.get(@doc, 'error/message')
-      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}" }
+
+        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
 
-      # Return an array of Amazon::Element item objects.
-      def items
-        @items ||= (@doc / 'item').map { |item| Element.new(item) }
-        @items
+        Response.new(res.body)
       end
 
-      # Return the first item (Amazon::Element)
-      def first_item
-        items.first
-      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 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 Hpricot object.
+        attr_reader :doc
 
-      # Return total results.
-      def total_results
-        @total_results ||= (@doc / 'totalresults').inner_html.to_i
-        @total_results
-      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
+          @items ||= (@doc / "item").map { |item| Element.new(item) }
+          @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
+          @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
+        # Return total pages.
+        def total_pages
+          @total_pages ||= (@doc / "totalpages").inner_html.to_i
+          @total_pages
+        end
       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
+        # inner hash
+        d1 = Digest::SHA256.new
+        d1.update(ipad)
+        d1.update(message)
+        msg_hash = d1.digest
 
-      # 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]
+        # outer hash
+        d2 = Digest::SHA256.new
+        d2.update(opad)
+        d2.update(msg_hash)
+        d2.digest
+      end
 
-      # 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}"
+      def self.sign_request(request)
+        raise AmazonNotConfiguredError unless @@secret_access_key
 
-      # Step 2 : URL-encode
-      param_string = param_string.gsub(',', '%2C').gsub(':', '%3A')
-      #   NOTE : take care not to double-encode
+        # 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 3 : Split the parameter/value pairs
-      params = param_string.split('&')
+        # 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 4 : Sort params
-      params.sort!
+        # Step 2 : URL-encode
+        param_string = param_string.gsub(",", "%2C").gsub(":", "%3A")
+        #   NOTE : take care not to double-encode
 
-      # Step 5 : Rejoin the param string
-      canonical_param_string = params.join('&')
+        # Step 3 : Split the parameter/value pairs
+        params = param_string.split("&")
 
-      # Steps 6 & 7: Prepend HTTP request info
-      string_to_sign = "GET\n#{host}\n#{path}\n#{canonical_param_string}"
+        # Step 4 : Sort params
+        params.sort!
 
-      # puts string_to_sign
+        # Step 5 : Rejoin the param string
+        canonical_param_string = params.join("&")
 
-      # 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
+        # Steps 6 & 7: Prepend HTTP request info
+        string_to_sign = "GET\n#{host}\n#{path}\n#{canonical_param_string}"
 
-      # Step 9 : URL-encode + and = in sig
-      base64_sig = CGI.escape(base64_sig)
+        # 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 10 : Add the URL encoded signature to your request
-      "http://#{host}#{path}?#{param_string}&Signature=#{base64_sig}"
-    end
-  end
+        # Step 9 : URL-encode + and = in sig
+        base64_sig = CGI.escape(base64_sig)
 
-  # Internal wrapper class to provide convenient method to access Hpricot element value.
-  class Element
-    # Pass Hpricot::Elements object
-    def initialize(element)
-      @element = element
+        # Step 10 : Add the URL encoded signature to your request
+        "http://#{host}#{path}?#{param_string}&Signature=#{base64_sig}"
+      end
     end
 
-    # Returns Hpricot::Elments object
-    def elem
-      @element
-    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. Example: element/"author".
-    def /(path)
-      elements = @element / path
-      return nil if elements.empty?
+      # Returns Hpricot::Elments object
+      def elem
+        @element
+      end
 
-      elements
-    end
+      # Find Hpricot::Elements matching the given path. Example: element/"author".
+      def /(path)
+        elements = @element / path
+        return nil if elements.empty?
 
-    # 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
+      end
 
-      elements = elements.map { |element| Element.new(element) }
-      return elements.first if elements.size == 1
+      # 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
-    end
+        elements = elements.map { |element| Element.new(element) }
+        return elements.first if elements.size == 1
 
-    # Get the text value of the given path, leave empty to retrieve current element value.
-    def get(path = '')
-      Element.get(@element, path)
-    end
+        elements
+      end
 
-    # Get the unescaped HTML text of the given path.
-    def get_unescaped(path = '')
-      Element.get_unescaped(@element, path)
-    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 array values of the given path.
-    def get_array(path = '')
-      Element.get_array(@element, path)
-    end
+      # Get the unescaped HTML text of the given path.
+      def get_unescaped(path = "")
+        Element.get_unescaped(@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
+      # 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
+      # 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
+        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_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)]
+      # 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
-    end
 
-    # Similar to #get_hash, except an element object must be passed-in.
-    def self.get_hash(element, path = '')
-      return unless element
+      # 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|
@@ -399,10 +364,10 @@ module Amazon
         end
         hash
       end
-    end
 
-    def to_s
-      elem&.to_s
+      def to_s
+        elem&.to_s
+      end
     end
   end
 end