alexandria-book-collection-manager 0.7.1 → 0.7.6

data/lib/alexandria/book_providers/pseudomarc.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (C) 2009 Cathal Mc Ginley
 # Copyright (C) 2010 Martin Sucha
 #
@@ -20,117 +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]]
-        if author_data
-          author_data.each do |ad|
-            author = ad[m[:authors][1]]
-            if author
-              author = author.strip
-              if author =~ /(.*),$/
-                author = Regexp.last_match[1]
-              end
-              authors << author
-            end
-          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
-          if isbn_data.first[m[:isbn][1]] =~ /([-0-9xX]+)/
-            isbn = Regexp.last_match[1]
-          end
+      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
-          if binding_data.first[m[:binding][1]] =~ /([a-zA-Z][a-z\s]+[a-z])/
-            binding = Regexp.last_match[1]
-          end
-        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]]
-        if publisher_data
-          publisher = publisher_data.first[m[:publisher][1]]
-        end
+      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]]
-          if year =~ /(\d+)/
-            year = Regexp.last_match[1].to_i
-          end
-        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]]
-        if notes_data
-          notes_data.each do |note|
-            txt = note[m[:notes][1]]
-            notes += txt if txt
-          end
-        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)
@@ -142,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

data/lib/alexandria/book_providers/siciliano.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (C) 2004 Laurent Sansonetti
 # Copyright (C) 2007 Laurent Sansonetti and Marco Costantini
 # Copyright (C) 2009 Cathal Mc Ginley
@@ -23,27 +25,27 @@
 # Almost completely rewritten by Cathal Mc Ginley (21 Feb 2009)
 # based on the new code for Palatina
 
-require 'net/http'
-require 'cgi'
-require 'alexandria/book_providers/web'
+require "net/http"
+require "cgi"
+require "alexandria/book_providers/web"
 
 module Alexandria
   class BookProviders
     class SicilianoProvider < WebsiteBasedProvider
       include Logging
 
-      SITE = 'http://www.siciliano.com.br'.freeze
+      SITE = "http://www.siciliano.com.br"
 
       # The string interpolations in this URL are the search term and search
       # type, respectively.
       BASE_SEARCH_URL = "#{SITE}/pesquisaweb/pesquisaweb.dll/pesquisa?" \
-        '&FIL_ID=102' \
-        '&PALAVRASN1=%s' \
-        '&FILTRON1=%s' \
-        '&ESTRUTN1=0301&ORDEMN2=E'.freeze
+        "&FIL_ID=102" \
+        "&PALAVRASN1=%s" \
+        "&FILTRON1=%s" \
+        "&ESTRUTN1=0301&ORDEMN2=E"
 
       def initialize
-        super('Siciliano', 'Livraria Siciliano (Brasil)')
+        super("Siciliano", "Livraria Siciliano (Brasil)")
         # no preferences for the moment
         prefs.read
       end
@@ -55,7 +57,7 @@ module Alexandria
       end
 
       def search(criterion, type)
-        criterion = criterion.encode('ISO-8859-1') # still needed??
+        criterion = criterion.encode("ISO-8859-1") # still needed??
         trying_again = false
         begin
           req = create_search_uri(type, criterion, trying_again)
@@ -69,14 +71,13 @@ module Alexandria
           else
             results.map { |result| get_book_from_search_result(result) }
           end
-
-        rescue NoResultsError => err
+        rescue NoResultsError => ex
           if (type == SEARCH_BY_ISBN) && (trying_again == false)
             trying_again = true
             retry
-          else
-            raise err
           end
+
+          raise ex
         end
       end
 
@@ -89,10 +90,10 @@ module Alexandria
       private
 
       def create_search_uri(search_type, search_term, trying_again = false)
-        (search_type_code = { SEARCH_BY_ISBN => 'G',
-                              SEARCH_BY_TITLE => 'A',
-                              SEARCH_BY_AUTHORS => 'B',
-                              SEARCH_BY_KEYWORD => 'X' }[search_type]) || 'X'
+        (search_type_code = { SEARCH_BY_ISBN    => "G",
+                              SEARCH_BY_TITLE   => "A",
+                              SEARCH_BY_AUTHORS => "B",
+                              SEARCH_BY_KEYWORD => "X" }[search_type]) || "X"
         search_term_encoded = if search_type == SEARCH_BY_ISBN
                                 if trying_again
                                   # on second attempt, try ISBN-10...
@@ -105,7 +106,7 @@ module Alexandria
                                 CGI.escape(search_term)
                               end
 
-        BASE_SEARCH_URL % [search_term_encoded, search_type_code]
+        format(BASE_SEARCH_URL, search_term_encoded, search_type_code)
       end
 
       def parse_search_result_data(html)
@@ -122,35 +123,33 @@ module Alexandria
         book_search_results = []
         # each result will be a dict with keys :title, :author, :publisher, :url
 
-        list_items = doc.search('div.pesquisa-item-lista-conteudo')
+        list_items = doc.search("div.pesquisa-item-lista-conteudo")
         list_items.each do |item|
-          begin
-            result = {}
+          result = {}
 
-            # author & publisher
-            author_publisher = ''
-            item.children.each do |node|
-              author_publisher += node.to_s if node.text?
-              author_publisher.strip!
-              break unless author_publisher.empty?
-            end
-            author, publisher = author_publisher.split('/')
-            result[:author] = author.strip if author
-            result[:publisher] = publisher.strip if publisher
+          # author & publisher
+          author_publisher = ""
+          item.children.each do |node|
+            author_publisher += node.to_s if node.text?
+            author_publisher.strip!
+            break unless author_publisher.empty?
+          end
+          author, publisher = author_publisher.split("/")
+          result[:author] = author.strip if author
+          result[:publisher] = publisher.strip if publisher
 
-            # title & url
-            link = item % 'a'
-            result[:title] = link.inner_text.strip
-            link_to_description = link['href']
-            slash = ''
-            slash = '/' unless link_to_description =~ /^\//
-            result[:url] = "#{SITE}#{slash}#{link_to_description}"
+          # title & url
+          link = item % "a"
+          result[:title] = link.inner_text.strip
+          link_to_description = link["href"]
+          slash = ""
+          slash = "/" unless link_to_description.start_with?("/")
+          result[:url] = "#{SITE}#{slash}#{link_to_description}"
 
-            book_search_results << result
-          rescue => ex
-            trace = ex.backtrace.join("\n> ")
-            log.error { "Failed parsing Siciliano search page #{ex.message}\n#{trace}" }
-          end
+          book_search_results << result
+        rescue StandardError => ex
+          trace = ex.backtrace.join("\n> ")
+          log.error { "Failed parsing Siciliano search page #{ex.message}\n#{trace}" }
         end
 
         book_search_results
@@ -160,61 +159,60 @@ module Alexandria
         # checked against Siciliano website 21 Feb 2009
         doc = html_to_doc(html)
         # title
-        title_div = doc % 'div#conteudo//div.titulo'
+        title_div = doc % "div#conteudo//div.titulo"
         raise NoResultsError unless title_div
-        title_h = title_div % 'h2'
+
+        title_h = title_div % "h2"
         title = title_h.inner_text if title_h
         # title = first_non_empty_text_node(title_div)
         # author_spans = doc/'span.rotulo'
-        author_hs = title_div / 'h3.autor'
+        author_hs = title_div / "h3.autor"
         authors = []
         author_hs.each do |h|
           authors << h.inner_text.strip
         end
         ## synopsis_div = doc % 'div#sinopse'
-        details_div = doc % 'div#tab-caracteristica'
+        details_div = doc % "div#tab-caracteristica"
         details = string_array_to_map(lines_of_text_as_array(details_div))
         # ISBN
-        isbn =  details['ISBN']
+        isbn =  details["ISBN"]
         ## ean = details["CdBarras"]
-        translator = details['Tradutor']
+        translator = details["Tradutor"]
         authors << translator if translator
-        binding = details['Acabamento']
+        binding = details["Acabamento"]
         publisher = search_result[:publisher]
         # publish year
         publish_year = nil
-        edition = details['Edio']
-        if edition
-          if edition =~ /([12][0-9]{3})/ # publication date
-            publish_year = Regexp.last_match[1].to_i
-          end
-        end
+        edition = details["Edio"]
+        # publication date
+        publish_year = Regexp.last_match[1].to_i if edition && edition =~ /([12][0-9]{3})/
         # cover
         # ImgSrc[1]="/imagem/imagem.dll?pro_id=1386929&PIM_Id=658849";
         image_urls = []
-        (doc / 'script').each do |script|
+        (doc / "script").each do |script|
           next if script.children.nil?
+
           script.children.each do |ch|
             ch_text = ch.to_s
-            if ch_text =~ /ImgSrc\[[\d]\]="(.+)";/
+            if ch_text =~ /ImgSrc\[\d\]="(.+)";/
               img_link = Regexp.last_match[1]
               image_urls << img_link
             end
           end
         end
         book = Book.new(title, authors, isbn, publisher, publish_year, binding)
-        result = [book, image_urls.first]
-        return result
-      rescue => ex
+        [book, image_urls.first]
+      rescue StandardError => ex
         trace = ex.backtrace.join("\n> ")
         log.error { "Failed parsing Siciliano product page #{ex.message}\n#{trace}" }
-        return nil
+        nil
       end
 
       def first_non_empty_text_node(elem)
-        text = ''
+        text = ""
         elem.children.each do |node|
           next unless node.text?
+
           text = node.to_s.strip
           break unless text.empty?
         end
@@ -223,28 +221,28 @@ module Alexandria
 
       def lines_of_text_as_array(elem)
         lines = []
-        current_text = ''
+        current_text = ""
         elem.children.each do |e|
           if e.text?
             current_text += e.to_s
-          elsif e.name == 'br'
+          elsif e.name == "br"
             lines << current_text.strip
-            current_text = ''
+            current_text = ""
           else
             current_text += e.inner_text
           end
         end
         lines << current_text.strip
-        lines.delete('')
+        lines.delete("")
         lines
       end
 
       def string_array_to_map(arr)
         map = {}
         arr.each do |str|
-          key, val = str.split(':')
+          key, val = str.split(":")
           # a real hack for not handling encoding properly :^)
-          map[key.gsub(/[^a-zA-Z]/, '')] = val.strip if val
+          map[key.gsub(/[^a-zA-Z]/, "")] = val.strip if val
         end
         map
       end