alexandria-book-collection-manager 0.7.3 → 0.7.8

data/lib/alexandria/book_providers/barnes_and_noble.rb

@@ -28,24 +28,24 @@
 
 # NOTE: this modified version is based on the Alexandria WorldCat provider.
 
-require 'cgi'
-require 'alexandria/net'
-require 'alexandria/book_providers/web'
+require "cgi"
+require "alexandria/net"
+require "alexandria/book_providers/web"
 
 module Alexandria
   class BookProviders
     class BarnesAndNobleProvider < WebsiteBasedProvider
-      include Alexandria::Logging
+      include Logging
 
-      SITE = 'http://www.barnesandnoble.com'
+      SITE = "http://www.barnesandnoble.com"
 
-      BASE_ISBN_SEARCH_URL = 'http://www.barnesandnoble.com/s/%s'
+      BASE_ISBN_SEARCH_URL = "http://www.barnesandnoble.com/s/%s"
 
-      BASE_SEARCH_URL = 'http://search.barnesandnoble.com/booksearch' \
-        '/results.asp?%s=%s' # type, term
+      BASE_SEARCH_URL = "http://search.barnesandnoble.com/booksearch" \
+        "/results.asp?%s=%s" # type, term
 
       def initialize
-        super('BarnesAndNoble', 'BarnesAndNoble')
+        super("BarnesAndNoble", "BarnesAndNoble")
         @agent = nil
         prefs.read
       end
@@ -56,7 +56,7 @@ module Alexandria
       end
 
       def fetch_redirectly(uri_str, limit = 5)
-        raise NoResultsError, 'HTTP redirect too deep' if limit.zero?
+        raise NoResultsError, _("HTTP redirect too deep") if limit.zero?
 
         if limit < 10
           sleep 0.1
@@ -67,9 +67,9 @@ module Alexandria
         response = agent.get(uri_str)
         log.debug { response.inspect }
         case response
-        when Net::HTTPSuccess     then response
-        when Net::HTTPRedirection then
-          redirect = URI.parse response['Location']
+        when Net::HTTPSuccess then response
+        when Net::HTTPRedirection
+          redirect = URI.parse response["Location"]
           redirect = URI.parse(uri_str) + redirect if redirect.relative?
           fetch_redirectly(redirect.to_s, (limit - 1))
         else
@@ -79,7 +79,7 @@ module Alexandria
 
       def search(criterion, type)
         req = create_search_uri(type, criterion)
-        puts "Requesting #{req}" if $DEBUG
+        log.debug { "Requesting #{req}" }
         html_data = fetch_redirectly(req)
 
         if type == SEARCH_BY_ISBN
@@ -101,10 +101,10 @@ module Alexandria
 
       def create_search_uri(search_type, search_term)
         (search_type_code = {
-          SEARCH_BY_AUTHORS => 'ATH',
-          SEARCH_BY_TITLE   => 'TTL',
-          SEARCH_BY_KEYWORD => 'WRD' # SEARCH_BY_PUBLISHER => 'PBL' # not implemented
-        }[search_type]) || ''
+          SEARCH_BY_AUTHORS => "ATH",
+          SEARCH_BY_TITLE   => "TTL",
+          SEARCH_BY_KEYWORD => "WRD" # SEARCH_BY_PUBLISHER => 'PBL' # not implemented
+        }[search_type]) || ""
         if search_type == SEARCH_BY_ISBN
           BASE_ISBN_SEARCH_URL % Library.canonicalise_ean(search_term) # isbn-13
         else
@@ -128,19 +128,19 @@ module Alexandria
             result = {}
             # img = div % 'div.book-image/a/img'
             # result[:image_url] = img['src'] if img
-            title_header = div % 'h2'
-            title_links = title_header / 'a'
+            title_header = div % "h2"
+            title_links = title_header / "a"
             result[:title] = title_links.first.inner_text
-            result[:url] = title_links.first['href']
+            result[:url] = title_links.first["href"]
 
             book_search_results << result
           end
         rescue StandardError => ex
           trace = ex.backtrace.join("\n> ")
-          log.warn {
-            'Failed parsing search results for Barnes & Noble ' \
+          log.warn do
+            "Failed parsing search results for Barnes & Noble " \
             "#{ex.message} #{trace}"
-          }
+          end
         end
         book_search_results
       end
@@ -150,8 +150,8 @@ module Alexandria
         begin
           book_data = {}
 
-          dl = (doc / 'dl').first
-          dts = dl.children_of_type('dt')
+          dl = (doc / "dl").first
+          dts = dl.children_of_type("dt")
           dts.each do |dt|
             value = dt.next_sibling.inner_text
             case dt.inner_text
@@ -166,44 +166,44 @@ module Alexandria
             end
           end
 
-          meta = doc / 'meta'
+          meta = doc / "meta"
           meta.each do |it|
             attrs = it.attributes
-            property = attrs['property']
+            property = attrs["property"]
             next unless property
 
             case property
-            when 'og:title'
-              book_data[:title] = attrs['content']
-            when 'og:image'
-              book_data[:image_url] = attrs['content']
+            when "og:title"
+              book_data[:title] = attrs["content"]
+            when "og:image"
+              book_data[:image_url] = attrs["content"]
             end
           end
 
-          author_links = doc / 'span.contributors a'
+          author_links = doc / "span.contributors a"
           authors = author_links.map(&:inner_text)
           book_data[:authors] = authors
 
-          book_data[:binding] = ''
-          selected_format = (doc / '#availableFormats li.selected a.tabTitle').first
+          book_data[:binding] = ""
+          selected_format = (doc / "#availableFormats li.selected a.tabTitle").first
           book_data[:binding] = selected_format.inner_text if selected_format
 
           book = Book.new(book_data[:title], book_data[:authors],
                           book_data[:isbn], book_data[:publisher],
                           book_data[:publication_year],
                           book_data[:binding])
-          return [book, book_data[:image_url]]
+          [book, book_data[:image_url]]
         rescue StandardError => ex
           raise ex if ex.instance_of? NoResultsError
 
           trace = ex.backtrace.join("\n> ")
-          log.warn {
-            'Failed parsing search results for BarnesAndNoble ' \
+          log.warn do
+            "Failed parsing search results for BarnesAndNoble " \
             "#{ex.message} #{trace}"
-          }
+          end
           raise NoResultsError
         end
       end
-    end # class BarnesAndNobleProvider
-  end # class BookProviders
-end # module Alexandria
+    end
+  end
+end

data/lib/alexandria/book_providers/douban.rb

@@ -1,44 +1,28 @@
 # frozen_string_literal: true
 
-# -*- ruby -*-
+# This file is part of Alexandria.
 #
-# Copyright (C) 2009 Cathal Mc Ginley
-# Copyright (C) 2010 Sun Ning
-#
-# 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://book.douban.com/
 # Douban.com book repository, provides many Chinese books.
 
 # Author: Sun Ning <classicning@gmail.com>, http://sunng.info/
 
-require 'cgi'
-require 'alexandria/net'
-require 'yaml'
+require "cgi"
+require "alexandria/net"
+require "yaml"
 
 module Alexandria
   class BookProviders
     class DoubanProvider < GenericProvider
-      include Alexandria::Logging
+      include Logging
 
-      SITE = 'http://www.douban.com'
-      BASE_URL = 'http://api.douban.com/book/subjects?q=%s&max-results=5&alt=json'
+      SITE = "http://www.douban.com"
+      BASE_URL = "http://api.douban.com/book/subjects?q=%s&max-results=5&alt=json"
 
       def initialize
-        super('Douban', 'Douban (China)')
+        super("Douban", "Douban (China)")
         prefs.read
       end
 
@@ -56,9 +40,9 @@ module Alexandria
         raise NoResultsError if results.empty?
 
         if type == SEARCH_BY_ISBN
-          return results.first
+          results.first
         else
-          return results
+          results
         end
       end
 
@@ -74,10 +58,10 @@ module Alexandria
       def json2yaml(json)
         # insert spaces after : and , except within strings
         # i.e. when followed by numeral, quote, { or [
-        yaml = json.gsub(/(\:|\,)([0-9'"{\[])/) do |_match|
+        yaml = json.gsub(/(:|,)([0-9'"{\[])/) do |_match|
           "#{Regexp.last_match[1]} #{Regexp.last_match[2]}"
         end
-        yaml.gsub!(/\\\//, '/') # unescape forward slashes
+        yaml.gsub!(%r{\\/}, "/") # unescape forward slashes
         yaml
       end
 
@@ -89,27 +73,27 @@ module Alexandria
           # dbresult = JSON.parse(response)
           dbresult = YAML.safe_load(json2yaml(response))
           # File.open(",douban.yaml", "wb") {|f| f.write(json2yaml(response)) }
-          if dbresult['opensearch:totalResults']['$t'].to_i > 0
-            for item in dbresult['entry']
-              name = item['title']['$t']
+          if dbresult["opensearch:totalResults"]["$t"].to_i > 0
+            dbresult["entry"].each do |item|
+              name = item["title"]["$t"]
               isbn = nil
               publisher = nil
               pubdate = nil
               binding = nil
-              for av in item['db:attribute']
-                isbn = av['$t'] if av['@name'] == 'isbn13'
-                publisher = av['$t'] if av['@name'] == 'publisher'
-                pubdate = av['$t'] if av['@name'] == 'pubdate'
-                binding = av['$t'] if av['@name'] == 'binding'
+              item["db:attribute"].each do |av|
+                isbn = av["$t"] if av["@name"] == "isbn13"
+                publisher = av["$t"] if av["@name"] == "publisher"
+                pubdate = av["$t"] if av["@name"] == "pubdate"
+                binding = av["$t"] if av["@name"] == "binding"
               end
-              authors = if item['author']
-                          item['author'].map { |a| a['name']['$t'] }
+              authors = if item["author"]
+                          item["author"].map { |a| a["name"]["$t"] }
                         else
                           []
                         end
               image_url = nil
-              for av in item['link']
-                image_url = av['@href'] if av['@rel'] == 'image'
+              item["link"].each do |av|
+                image_url = av["@href"] if av["@rel"] == "image"
               end
               book = Book.new(name, authors, isbn, publisher, pubdate, binding)
               book_search_results << [book, image_url]

data/lib/alexandria/book_providers/proxis.rb

@@ -7,14 +7,14 @@
 # New Proxis provider, taken from Palatina MetaDataSource and modified
 # for Alexandria. (20 Dec 2009)
 
-require 'cgi'
-require 'alexandria/book_providers/web'
+require "cgi"
+require "alexandria/book_providers/web"
 
 module Alexandria
   class BookProviders
     class ProxisProvider < WebsiteBasedProvider
       # include GetText
-      include Alexandria::Logging
+      include Logging
       # GetText.bindtextdomain(Alexandria::TEXTDOMAIN, :charset => "UTF-8")
 
       # Proxis essentially has three book databases, NL, FR and EN.
@@ -22,14 +22,14 @@ module Alexandria
       # it adds most to Alexandria (Amazon already has French and
       # English titles).
 
-      SITE = 'http://www.proxis.nl'
+      SITE = "http://www.proxis.nl"
       BASE_SEARCH_URL = "#{SITE}/NLNL/Search/IndexGSA.aspx?search=%s" \
-        '&shop=100001NL&SelRubricLevel1Id=100001NL'
+        "&shop=100001NL&SelRubricLevel1Id=100001NL"
       ISBN_REDIRECT_BASE_URL = "#{SITE}/NLNL/Search/Index.aspx?search=%s" \
-        '&shop=100001NL&SelRubricLevel1Id=100001NL'
+        "&shop=100001NL&SelRubricLevel1Id=100001NL"
 
       def initialize
-        super('Proxis', 'Proxis (Belgium)')
+        super("Proxis", "Proxis (Belgium)")
         # prefs.add("lang", _("Language"), "fr",
         #          LANGUAGES.keys)
         prefs.read
@@ -37,7 +37,7 @@ module Alexandria
 
       def search(criterion, type)
         req = create_search_uri(type, criterion)
-        puts req if $DEBUG
+        log.debug { req }
         html_data = transport.get_response(URI.parse(req))
 
         results = parse_search_result_data(html_data.body)
@@ -65,7 +65,9 @@ module Alexandria
       end
 
       def url(book)
-        ISBN_REDIRECT_BASE_URL % Library.canonicalise_ean(book.isbn) if book.isbn.nil? || book.isbn.empty?
+        if book.isbn.nil? || book.isbn.empty?
+          ISBN_REDIRECT_BASE_URL % Library.canonicalise_ean(book.isbn)
+        end
       end
 
       ## from Palatina
@@ -79,7 +81,7 @@ module Alexandria
             nil
           else
             node_text = node.children.map { |n| text_of(n) }.join
-            node_text.strip.squeeze(' ')
+            node_text.strip.squeeze(" ")
           end
         end
       end
@@ -87,14 +89,16 @@ module Alexandria
       def parse_search_result_data(html)
         doc = html_to_doc(html)
         book_search_results = []
-        items = doc.search('table.searchResult tr')
+        items = doc.search("table.searchResult tr")
         items.each do |item|
           result = {}
-          title_link = item % 'h5 a'
+          title_link = item % "h5 a"
           if title_link
             result[:title] = text_of(title_link)
-            result[:lookup_url] = title_link['href']
-            result[:lookup_url] = "#{SITE}#{result[:lookup_url]}" unless result[:lookup_url] =~ /^http/
+            result[:lookup_url] = title_link["href"]
+            unless result[:lookup_url].start_with?("http")
+              result[:lookup_url] = "#{SITE}#{result[:lookup_url]}"
+            end
           end
           book_search_results << result
         end
@@ -104,9 +108,9 @@ module Alexandria
         book_search_results
       end
 
-      def data_for_header(th)
-        tr = th.parent
-        td = tr.at('td')
+      def data_for_header(header)
+        tr = header.parent
+        td = tr.at("td")
         text_of(td) if td
       end
 
@@ -115,19 +119,19 @@ module Alexandria
         book_data = {}
         book_data[:authors] = []
         # TITLE
-        if (title_header = doc.search('div.detailBlock h3'))
-          header_spans = title_header.first.search('span')
+        if (title_header = doc.search("div.detailBlock h3"))
+          header_spans = title_header.first.search("span")
           title = text_of(header_spans.first)
           title = Regexp.last_match[1].strip if title =~ /(.+)-$/
           book_data[:title] = title
         end
 
-        info_headers = doc.search('table.productInfoTable th')
+        info_headers = doc.search("table.productInfoTable th")
 
         isbns = []
         unless info_headers.empty?
           info_headers.each do |th|
-            isbns << data_for_header(th) if th.inner_text =~ /(ISBN|EAN)/
+            isbns << data_for_header(th) if /(ISBN|EAN)/.match?(th.inner_text)
           end
           book_data[:isbn] = Library.canonicalise_ean(isbns.first)
         end
@@ -137,15 +141,16 @@ module Alexandria
         unless info_headers.empty?
           info_headers.each do |th|
             header_text = th.inner_text
-            if header_text =~ /Type/
+            case header_text
+            when /Type/
               book_data[:binding] = data_for_header(th)
-            elsif header_text =~ /Verschijningsdatum/
+            when /Verschijningsdatum/
               date = data_for_header(th)
-              date =~ /\/([\d]{4})/
+              date =~ %r{/(\d{4})}
               book_data[:publish_year] = Regexp.last_match[1].to_i
-            elsif header_text =~ /Auteur/
+            when /Auteur/
               book_data[:authors] << data_for_header(th)
-            elsif header_text =~ /Uitgever/
+            when /Uitgever/
               book_data[:publisher] = data_for_header(th)
             end
           end
@@ -153,12 +158,12 @@ module Alexandria
 
         image_url = nil
         if (cover_img = doc.at("img[@id$='imgProduct']"))
-          image_url = if cover_img['src'] =~ /^http/
-                        cover_img['src']
+          image_url = if cover_img["src"].start_with?("http")
+                        cover_img["src"]
                       else
                         "#{SITE}/#{cover_img['src']}" # TODO: use html <base>
                       end
-          image_url = nil if image_url =~ /ProductNoCover/
+          image_url = nil if /ProductNoCover/.match?(image_url)
         end
 
         book = Book.new(book_data[:title], book_data[:authors],

data/lib/alexandria/book_providers/pseudomarc.rb

@@ -22,103 +22,104 @@ module Alexandria
   # A really simple regex-based parser to grab data out of marc text records.
   class PseudoMarcParser
     BNF_FR_MAPPINGS = {
-      title: ['200', 'a'],
-      authors: ['700', 'a'],
-      isbn: ['010', 'a'],
-      publisher: ['210', 'g'],
-      year: ['210', 'd'],
-      binding: ['225', 'a'],
-      notes: ['520', 'a']
+      title: ["200", "a"],
+      authors: ["700", "a"],
+      isbn: ["010", "a"],
+      publisher: ["210", "g"],
+      year: ["210", "d"],
+      binding: ["225", "a"],
+      notes: ["520", "a"]
     }.freeze
 
     USMARC_MAPPINGS = {
-      title: ['245', 'a', 'b'],
-      authors: ['100', 'a'],
-      isbn: ['020', 'a'],
-      publisher: ['490', 'a'],
-      year: ['260', 'c'],
-      binding: ['020', 'a'], # listed with isbn here
-      notes: ['520', 'a']
+      title: ["245", "a", "b"],
+      authors: ["100", "a"],
+      isbn: ["020", "a"],
+      publisher: ["490", "a"],
+      year: ["260", "c"],
+      binding: ["020", "a"], # listed with isbn here
+      notes: ["520", "a"]
     }.freeze
 
-    def self.get_fields(data, type, stripping, m = USMARC_MAPPINGS)
-      field = ''
-      m[type][1..m[type].length - 1].each do |part|
+    def self.get_fields(data, type, stripping, mappings = USMARC_MAPPINGS)
+      field = ""
+      mappings[type][1..mappings[type].length - 1].each do |part|
         if data.first[part]
           part_data = data.first[part].strip
           if part_data =~ stripping
             part_data = Regexp.last_match[1]
             part_data = part_data.strip
           end
-          field += ': ' if field != ''
+          field += ": " if field != ""
           field += part_data
         end
       end
-      field = nil if field == ''
+      field = nil if field == ""
       field
     end
 
-    def self.marc_text_to_book(marc, m = USMARC_MAPPINGS)
+    def self.marc_text_to_book(marc, mappings = USMARC_MAPPINGS)
       details = marc_text_to_details(marc)
-      unless details.empty?
-        title = nil
-        title_data = details[m[:title][0]]
-        if title_data
-          title_data_all = get_fields(title_data, :title, /(.*)[\/:]$/, m)
-          title = title_data_all if title_data_all
-        end
+      return if details.empty?
 
-        authors = []
-        author_data = details[m[:authors][0]]
-        author_data&.each do |ad|
-          author = ad[m[:authors][1]]
-          if author
-            author = author.strip
-            author = Regexp.last_match[1] if author =~ /(.*),$/
-            authors << author
-          end
-        end
+      title = nil
+      title_data = details[mappings[:title][0]]
+      if title_data
+        title_data_all = get_fields(title_data, :title, %r{(.*)[/:]$}, mappings)
+        title = title_data_all if title_data_all
+      end
 
-        isbn = nil
-        binding = nil
-        isbn_data = details[m[:isbn][0]]
-        if isbn_data
-          isbn = Regexp.last_match[1] if isbn_data.first[m[:isbn][1]] =~ /([-0-9xX]+)/
+      authors = []
+      author_data = details[mappings[:authors][0]]
+      author_data&.each do |ad|
+        author = ad[mappings[:authors][1]]
+        if author
+          author = author.strip
+          author = Regexp.last_match[1] if author =~ /(.*),$/
+          authors << author
         end
+      end
 
-        binding_data = details[m[:binding][0]]
-        if binding_data
-          binding = Regexp.last_match[1] if binding_data.first[m[:binding][1]] =~ /([a-zA-Z][a-z\s]+[a-z])/
-        end
+      isbn = nil
+      binding = nil
+      isbn_data = details[mappings[:isbn][0]]
+      if isbn_data && isbn_data.first[mappings[:isbn][1]] =~ /([-0-9xX]+)/
+        isbn = Regexp.last_match[1]
+      end
 
-        publisher = nil
-        publisher_data = details[m[:publisher][0]]
-        publisher = publisher_data.first[m[:publisher][1]] if publisher_data
+      binding_data = details[mappings[:binding][0]]
+      if binding_data &&
+          binding_data.first[mappings[:binding][1]] =~ /([a-zA-Z][a-z\s]+[a-z])/
+        binding = Regexp.last_match[1]
+      end
 
-        year = nil
-        publication_data = details[m[:year][0]]
-        if publication_data
-          year = publication_data.first[m[:year][1]]
-          year = Regexp.last_match[1].to_i if year =~ /(\d+)/
-        end
+      publisher = nil
+      publisher_data = details[mappings[:publisher][0]]
+      publisher = publisher_data.first[mappings[:publisher][1]] if publisher_data
 
-        notes = ''
-        notes_data = details[m[:notes][0]]
-        notes_data&.each do |note|
-          txt = note[m[:notes][1]]
-          notes += txt if txt
-        end
+      year = nil
+      publication_data = details[mappings[:year][0]]
+      if publication_data
+        year = publication_data.first[mappings[:year][1]]
+        year = Regexp.last_match[1].to_i if year =~ /(\d+)/
+      end
 
-        if title.nil? && isbn.nil?
-          # probably didn't undertand the MARC dialect
-          return nil
-        end
+      notes = ""
+      notes_data = details[mappings[:notes][0]]
+      notes_data&.each do |note|
+        txt = note[mappings[:notes][1]]
+        notes += txt if txt
+      end
 
-        book = Alexandria::Book.new(title, authors, isbn,
-                                    publisher, year, binding)
-        book.notes = notes unless notes.empty?
-        book
+      if title.nil? && isbn.nil?
+        # probably didn't undertand the MARC dialect
+        return nil
       end
+
+      book = Alexandria::Book.new(title, authors, isbn,
+                                  publisher, year, binding)
+      book.notes = notes unless notes.empty?
+      book
     end
 
     def self.marc_text_to_details(marc)
@@ -130,31 +131,22 @@ module Alexandria
 
           this_line_data = {}
 
-          # puts code
-          # puts data
           d_idx = 0
           while d_idx < data.size
             d_str = data[d_idx..-1]
-            # puts d_str
-            if (idx = d_str =~ /\$([a-z]) ([^\$]+)/)
-              # puts idx
-              sub_code = Regexp.last_match[1]
-              sub_data = Regexp.last_match[2]
-              this_line_data[sub_code] = sub_data
-              # puts "  " + $1
-              # puts "    " + $2
-              # puts idx
-              d_idx += idx + 2 # (2 extra to push beyond this '$a' etc.)
-            else
-              break
-            end
+            idx = d_str =~ /\$([a-z]) ([^$]+)/
+            break unless idx
+
+            sub_code = Regexp.last_match[1]
+            sub_data = Regexp.last_match[2]
+            this_line_data[sub_code] = sub_data
+            d_idx += idx + 2 # (2 extra to push beyond this '$a' etc.)
           end
 
           unless this_line_data.empty?
             details[code] = [] unless details.key?(code)
             details[code] << this_line_data
           end
-
         end
       end
       details