alexandria-book-collection-manager 0.7.1 → 0.7.6

data/lib/alexandria/book_providers/adlibris.rb

@@ -1,22 +1,8 @@
-# -*- ruby -*-
-#
-# Copyright (C) 2009 Cathal Mc Ginley
-# Copyright (C) 2014 Matijs van Zuijlen
-#
-# 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.
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
 #
-# 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.
 
 # AdLibris  Bokhandel AB http://www.adlibris.com/se/
 # Swedish online book store
@@ -25,23 +11,23 @@
 # modified to fit the structure of Alexandria book providers.
 # (26 Feb 2009)
 
-require 'cgi'
-require 'alexandria/book_providers/web'
+require "cgi"
+require "alexandria/book_providers/web"
 
 module Alexandria
   class BookProviders
     class AdLibrisProvider < WebsiteBasedProvider
-      include Alexandria::Logging
+      include Logging
 
-      SITE = 'http://www.adlibris.com/se/'.freeze
+      SITE = "http://www.adlibris.com/se/"
 
       BASE_SEARCH_URL = "#{SITE}searchresult.aspx?search=advanced&%s=%s" \
-        '&fromproduct=False'.freeze # type/term
+        "&fromproduct=False" # type/term
 
-      PRODUCT_URL = "#{SITE}product.aspx?isbn=%s".freeze
+      PRODUCT_URL = "#{SITE}product.aspx?isbn=%s"
 
       def initialize
-        super('AdLibris', 'AdLibris (Sweden)')
+        super("AdLibris", "AdLibris (Sweden)")
         prefs.read
         # @ent = HTMLEntities.new
       end
@@ -65,7 +51,7 @@ module Alexandria
       ## url
       def url(book)
         create_search_uri(SEARCH_BY_ISBN, book.isbn)
-      rescue => ex
+      rescue StandardError => ex
         log.warn { "Cannot create url for book #{book}; #{ex.message}" }
         nil
       end
@@ -77,12 +63,12 @@ module Alexandria
           PRODUCT_URL % Library.canonicalise_isbn(search_term)
         else
           (search_type_code = {
-            SEARCH_BY_AUTHORS => 'author',
-            SEARCH_BY_TITLE => 'title',
-            SEARCH_BY_KEYWORD => 'keyword'
-          }[search_type]) || 'keyword'
+            SEARCH_BY_AUTHORS => "author",
+            SEARCH_BY_TITLE   => "title",
+            SEARCH_BY_KEYWORD => "keyword"
+          }[search_type]) || "keyword"
           search_term_encoded = CGI.escape(search_term)
-          BASE_SEARCH_URL % [search_type_code, search_term_encoded]
+          format(BASE_SEARCH_URL, search_type_code, search_term_encoded)
         end
       end
 
@@ -95,20 +81,17 @@ 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 = []
 
         search_hit = doc.search("div'searchResult")[0]
         return [] unless search_hit
 
-        (search_hit / 'ul.ulSearch table').each do |t|
+        (search_hit / "ul.ulSearch table").each do |t|
           result = {}
-          if (title_data = (t % 'div.divTitle'))
+          if (title_data = (t % "div.divTitle"))
             result[:title] = (title_data % :a).inner_text
-            lookup_url = (title_data % :a)['href']
+            lookup_url = (title_data % :a)["href"]
           end
           result[:lookup_url] = "#{SITE}#{lookup_url}"
 
@@ -117,46 +100,25 @@ module Alexandria
         book_search_results
       end
 
-      # def binding_type(binding) # swedish string
-      #  # hrm, this is a HACK and not currently working
-      #  # perhaps use regexes instead...
-      #  {"inbunden" => :hardback,
-      #    "pocket" => :paperback,
-      #    "storpocket" => :paperback,
-      #    "kartonnage" => :hardback,
-      #    "kassettbok" => :audiobook}[binding.downcase] or :paperback
-      #  # H&#228;ftad == Paperback
-      # end
-
       def normalize(text)
-        # unless text.nil?
-        #  text = @ent.decode(text).strip
-        # end
         text
       end
 
       def parse_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)
-        ## File.open(',log.html', 'wb') {|f| f.write('<?xml encoding="utf-8"?>'); f.write(html) } # DEBUG
-        # doc = Hpricot(html)
         doc = html_to_doc(html)
         begin
+          h1 = doc.at("div.productTitleFormat h1")
+          raise NoResultsError, _("title not found on page") unless h1
 
-          title = nil
-          if (h1 = doc.at('div.productTitleFormat h1'))
-            title = text_of(h1)
-          else
-            raise NoResultsError, 'title not found on page'
-          end
+          title = text_of(h1)
 
-          product = doc.at('div.product')
-          ul_info = doc.at('ul.info') # NOTE, two of these
+          product = doc.at("div.product")
+          ul_info = doc.at("ul.info") # NOTE, two of these
 
-          author_cells = ul_info.search('li.liAuthor') # css-like search
+          author_cells = ul_info.search("li.liAuthor") # css-like search
           authors = []
           author_cells.each do |li|
-            author_name = text_of(li.search('h2 > a')[0])
+            author_name = text_of(li.search("h2 > a")[0])
 
             authors << author_name
           end
@@ -167,19 +129,15 @@ module Alexandria
           end
 
           binding = nil
-          if (format = doc.search('div.productTitleFormat span').first)
+          if (format = doc.search("div.productTitleFormat span").first)
             binding = text_of(format)
-            if binding =~ /\(([^\)]+)\)/
-              binding = Regexp.last_match[1]
-            end
+            binding = Regexp.last_match[1] if binding =~ /\(([^)]+)\)/
           end
 
           year = nil
           if (published = product.search('span[@id$="Published"]').first)
             publication = published.inner_text
-            if publication =~ /([12][0-9]{3})/
-              year = Regexp.last_match[1].to_i
-            end
+            year = Regexp.last_match[1].to_i if publication =~ /([12][0-9]{3})/
           end
 
           isbns = []
@@ -188,10 +146,9 @@ module Alexandria
           isbn_tds.each do |isbn_td|
             isbn = isbn_td.inner_text
             next unless isbn =~ /[0-9x]{10,13}/i
-            isbn.gsub(/(\n|\r)/, ' ')
-            if isbn =~ /:[\s]*([0-9x]+)/i
-              isbn = Regexp.last_match[1]
-            end
+
+            isbn.gsub(/(\n|\r)/, " ")
+            isbn = Regexp.last_match[1] if isbn =~ /:\s*([0-9x]+)/i
             isbns << isbn
           end
           isbn = isbns.first
@@ -199,13 +156,15 @@ module Alexandria
 
           # cover
           image_url = nil
-          if (cover_img = doc.search('span.imageWithShadow img[@id$="ProductImageNotLinked"]').first)
-            image_url = if cover_img['src'] =~ /^http\:\/\//
-                          cover_img['src']
+          cover_img =
+            doc.search('span.imageWithShadow img[@id$="ProductImageNotLinked"]').first
+          if cover_img
+            image_url = if cover_img["src"].start_with?("http://")
+                          cover_img["src"]
                         else
                           "#{SITE}/#{cover_img['src']}" # HACK: use html base
                         end
-            if image_url =~ /noimage.gif$/
+            if /noimage.gif$/.match?(image_url)
               # no point downloading a "no image" graphic
               # Alexandria has its own generic book icon...
               image_url = nil
@@ -215,14 +174,15 @@ module Alexandria
 
           book = Book.new(title, authors, isbn, publisher, year, binding)
 
-          return [book, image_url]
-        rescue => ex
+          [book, image_url]
+        rescue StandardError => ex
           raise ex if ex.instance_of? NoResultsError
+
           trace = ex.backtrace.join("\n> ")
-          log.warn {
-            'Failed parsing search results for AdLibris ' \
+          log.warn do
+            "Failed parsing search results for AdLibris " \
             "#{ex.message} #{trace}"
-          }
+          end
           raise NoResultsError
         end
       end

data/lib/alexandria/book_providers/amazon_aws.rb

@@ -1,101 +1,81 @@
-# Copyright (C) 2004-2006 Laurent Sansonetti
-# Copyright (C) 2008 Cathal Mc Ginley
-# Copyright (C) 2014, 2016 Matijs van Zuijlen
-#
-# 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.
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
 #
-# 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
-          if token.value != token.value.strip
-            token.new_value = token.value.strip
+          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
-        if token && ((token.value.size != 20) || (token.value == '0J356Z09CN88KB743582'))
-          token.new_value = ''
-        end
 
-        secret = prefs.variable_named('secret_key')
-        if secret
-          if secret.value != secret.value.strip
-            secret.new_value = secret.value.strip
-          end
+        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
-          if associate.value.strip.empty?
-            associate.new_value = 'rubyalexa-20'
-          end
-          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
 
       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
@@ -105,7 +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
@@ -125,29 +108,36 @@ module Alexandria
             # result with different ISBNs
 
             if products.length > 1
-              log.warn { "ISBN search at Amazon[#{request_locale}] got #{products.length} results; returning the first result only" }
+              log.warn do
+                "ISBN search at Amazon[#{request_locale}] got #{products.length} results;" \
+                " returning the first result only"
+              end
             end
 
           when SEARCH_BY_TITLE
-            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|
-              if item.get('itemattributes/title') =~ /#{criterion}/i
-                products << item
-              end
+              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')
+            res = Amazon::Ecs.item_search(criterion,
+                                          response_group: "ItemAttributes,Images",
+                                          country: request_locale, type: "Power")
             res.items.each do |item|
               products << item
             end
             # #req.author_search(criterion) do |product|
 
           when SEARCH_BY_KEYWORD
-            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
@@ -156,92 +146,94 @@ module Alexandria
           else
             raise InvalidSearchTypeError
           end
-          if products.empty?
-            raise Amazon::RequestError, 'No products'
-          end
+          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'
-          atts = item.search_and_convert('itemattributes')
-          title = normalize(atts.get('title'))
+          next unless item.get("itemattributes/productgroup") == "Book"
+
+          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 = if isbn && Library.valid_isbn?(isbn)
-                   Library.canonicalise_ean(isbn)
-                 end
+          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)
-              if query_isbn_canon == book_isbn_canon
-                return rslt
-              end
-              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 => ex
+      rescue StandardError => ex
         log.warn { "Cannot create url for book #{book}; #{ex.message}" }
         nil
       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