alexandria-book-collection-manager 0.7.5 → 0.7.6

data/lib/alexandria/book_providers/adlibris.rb

@@ -17,7 +17,7 @@ require "alexandria/book_providers/web"
 module Alexandria
   class BookProviders
     class AdLibrisProvider < WebsiteBasedProvider
-      include Alexandria::Logging
+      include Logging
 
       SITE = "http://www.adlibris.com/se/"
 
@@ -81,9 +81,6 @@ module Alexandria
       end
 
       def parse_search_result_data(html)
-        # adlibris site presents data in ISO-8859-1, so change it to UTF-8
-        # html = Iconv.conv("UTF-8", "ISO-8859-1", html)
-        # doc = Hpricot(html)
         doc = html_to_doc(html)
         book_search_results = []
 
@@ -110,12 +107,10 @@ module Alexandria
       def parse_result_data(html)
         doc = html_to_doc(html)
         begin
-          title = nil
-          if (h1 = doc.at("div.productTitleFormat h1"))
-            title = text_of(h1)
-          else
-            raise NoResultsError, "title not found on page"
-          end
+          h1 = doc.at("div.productTitleFormat h1")
+          raise NoResultsError, _("title not found on page") unless h1
+
+          title = text_of(h1)
 
           product = doc.at("div.product")
           ul_info = doc.at("ul.info") # NOTE, two of these
@@ -136,7 +131,7 @@ module Alexandria
           binding = nil
           if (format = doc.search("div.productTitleFormat span").first)
             binding = text_of(format)
-            binding = Regexp.last_match[1] if binding =~ /\(([^\)]+)\)/
+            binding = Regexp.last_match[1] if binding =~ /\(([^)]+)\)/
           end
 
           year = nil
@@ -153,7 +148,7 @@ module Alexandria
             next unless isbn =~ /[0-9x]{10,13}/i
 
             isbn.gsub(/(\n|\r)/, " ")
-            isbn = Regexp.last_match[1] if isbn =~ /:[\s]*([0-9x]+)/i
+            isbn = Regexp.last_match[1] if isbn =~ /:\s*([0-9x]+)/i
             isbns << isbn
           end
           isbn = isbns.first
@@ -164,7 +159,7 @@ module Alexandria
           cover_img =
             doc.search('span.imageWithShadow img[@id$="ProductImageNotLinked"]').first
           if cover_img
-            image_url = if %r{^http\://}.match?(cover_img["src"])
+            image_url = if cover_img["src"].start_with?("http://")
                           cover_img["src"]
                         else
                           "#{SITE}/#{cover_img['src']}" # HACK: use html base

data/lib/alexandria/book_providers/amazon_aws.rb

@@ -1,23 +1,8 @@
 # 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
 
@@ -49,22 +34,21 @@ module Alexandria
 
         if token
           token.new_value = token.value.strip if token.value != token.value.strip
-        end
-        if token && ((token.value.size != 20) || (token.value == "0J356Z09CN88KB743582"))
-          token.new_value = ""
+          if (token.value.size != 20) || (token.value == "0J356Z09CN88KB743582")
+            token.new_value = ""
+          end
         end
 
         secret = prefs.variable_named("secret_key")
-        if secret
-          secret.new_value = secret.value.strip if secret.value != secret.value.strip
+        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?
-          if associate.value != associate.value.strip
-            associate.new_value = associate.value.strip
-          end
+        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
 
@@ -72,9 +56,7 @@ module Alexandria
         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")
+          raise(Amazon::RequestError, _("Provide secret key for your Amazon AWS account."))
         end
 
         if (config = Alexandria::Preferences.instance.http_proxy_config)
@@ -106,6 +88,7 @@ module Alexandria
             res = Amazon::Ecs.item_search(criterion,
                                           response_group: "ItemAttributes,Images",
                                           country: request_locale)
+
             res.items.each do |item|
               products << item
             end
@@ -163,7 +146,7 @@ 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 => ex
           log.debug { "Got Amazon::RequestError at #{request_locale}: #{ex}" }
@@ -201,42 +184,25 @@ module Alexandria
           if results.size == 1
             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 do
-              "no more results to check. Returning first result, just an approximation"
-            end
-            results.first
+            exact_match_or_first(criterion, results)
           end
         else
           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}" }
@@ -247,6 +213,27 @@ module Alexandria
         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

@@ -10,368 +10,353 @@ 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
-
-    def self.secret_access_key=(key)
-      @@secret_access_key = key
-    end
-
-    # Set default search options
-    def self.options=(opts)
-      @@options = opts
-    end
-
-    # Get debug flag.
-    def self.debug
-      @@debug
-    end
+module Alexandria
+  module Amazon
+    class RequestError < StandardError; end
+
+    class Ecs
+      include 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
 
-    # Set debug flag to true or false.
-    def self.debug=(dbg)
-      @@debug = dbg
-    end
+      def self.secret_access_key=(key)
+        @@secret_access_key = key
+      end
 
-    def self.configure(&_proc)
-      raise ArgumentError, "Block is required." unless block_given?
+      # Set default search options
+      def self.options=(opts)
+        @@options = opts
+      end
 
-      yield @@options
-    end
+      # Get debug flag.
+      def self.debug
+        @@debug
+      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
+      # Set debug flag to true or false.
+      def self.debug=(dbg)
+        @@debug = dbg
       end
 
-      send_request(opts)
-    end
+      def self.configure(&_proc)
+        yield @@options
+      end
 
-    # Search an item by ASIN no.
-    def self.item_lookup(item_id, opts = {})
-      opts[:operation] = "ItemLookup"
-      opts[:item_id] = item_id
+      # 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
 
-      send_request(opts)
-    end
+        send_request(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
+      # Search an item by ASIN no.
+      def self.item_lookup(item_id, opts = {})
+        opts[:operation] = "ItemLookup"
+        opts[:item_id] = item_id
 
-    # 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}" }
+        send_request(opts)
+      end
 
-      res = transport.get_response(URI.parse(request_url))
-      unless res.is_a? Net::HTTPSuccess
-        raise Amazon::RequestError, "HTTP Response: #{res.code} #{res.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
 
-      Response.new(res.body)
-    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
 
-    # Response object returned after a REST call to Amazon service.
-    class Response
-      # XML input is in string format
-      def initialize(xml)
-        @doc = Hpricot(xml)
+        Response.new(res.body)
       end
 
-      # Return Hpricot object.
-      attr_reader :doc
+      # 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 true if request is valid.
-      def is_valid_request?
-        (@doc / "isvalid").inner_html == "True"
-      end
+        # Return Hpricot object.
+        attr_reader :doc
 
-      # Return true if response has an error.
-      def has_error?
-        !(error.nil? || error.empty?)
-      end
+        # Return true if request is valid.
+        def is_valid_request?
+          (@doc / "isvalid").inner_html == "True"
+        end
 
-      # Return error message.
-      def error
-        Element.get(@doc, "error/message")
-      end
+        # Return true if response has an error.
+        def has_error?
+          !(error.nil? || error.empty?)
+        end
 
-      # Return an array of Amazon::Element item objects.
-      def items
-        @items ||= (@doc / "item").map { |item| Element.new(item) }
-        @items
-      end
+        # Return error message.
+        def error
+          Element.get(@doc, "error/message")
+        end
 
-      # Return the first item (Amazon::Element)
-      def first_item
-        items.first
-      end
+        # Return an array of Amazon::Element item objects.
+        def items
+          @items ||= (@doc / "item").map { |item| Element.new(item) }
+          @items
+        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 the first item (Amazon::Element)
+        def first_item
+          items.first
+        end
 
-      # Return total results.
-      def total_results
-        @total_results ||= (@doc / "totalresults").inner_html.to_i
-        @total_results
-      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 pages.
-      def total_pages
-        @total_pages ||= (@doc / "totalpages").inner_html.to_i
-        @total_pages
-      end
-    end
+        # Return total results.
+        def total_results
+          @total_results ||= (@doc / "totalresults").inner_html.to_i
+          @total_results
+        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 do |k, v|
-        next unless v
-
-        v = v.join(",") if v.is_a? Array
-        qs << "&#{camelize(k.to_s)}=#{URI.encode(v.to_s)}"
+        # Return total pages.
+        def total_pages
+          @total_pages ||= (@doc / "totalpages").inner_html.to_i
+          @total_pages
+        end
       end
-      url = "#{request_url}#{qs}"
-      # puts ">>> base url >> #{url}"
-      signed_url = sign_request(url)
-      # puts ">>> SIGNED >> #{signed_url}"
-      signed_url
-    end
 
-    def self.camelize(s)
-      s.to_s
-        .gsub(%r{/(.?)}) { "::" + Regexp.last_match[1].upcase }
-        .gsub(/(^|_)(.)/) { Regexp.last_match[2].upcase }
-    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.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)
+        qs = ""
+        opts.each do |k, v|
+          next unless v
+
+          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 = ""
-      (0..key.size - 1).each do |i|
-        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 = %r{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
 
-    # Similar to #get, except an element object must be passed-in.
-    def self.get(element, path = "")
-      return unless element
+      # 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
 
-      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, except an element object must be passed-in.
+      def self.get(element, path = "")
+        return unless element
 
-    # 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
+        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_array, except an element object must be passed-in.
-    def self.get_array(element, path = "")
-      return unless element
+      # 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
 
-      result = element / path
-      if (result.is_a? Hpricot::Elements) || (result.is_a? Array)
-        parsed_result = []
-        result.each do |item|
-          parsed_result << Element.get(item)
+      # 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
-        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
+      # 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|
@@ -379,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