alexandria-book-collection-manager 0.7.5 → 0.7.9

data/lib/alexandria/book_providers/z3950_provider.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
+#
+# See the file README.md for authorship and licensing information.
+
+require "zoom"
+require "alexandria/book_providers/pseudomarc"
+require "marc"
+
+module Alexandria
+  class BookProviders
+    class Z3950Provider < AbstractProvider
+      include Logging
+      include GetText
+      GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
+
+      def initialize(name = "Z3950", fullname = "Z39.50")
+        super
+        prefs.add("hostname", _("Hostname"), "")
+        prefs.add("port", _("Port"), 7090)
+        prefs.add("database", _("Database"), "")
+        prefs.add("record_syntax", _("Record syntax"), "USMARC",
+                  ["USMARC", "UNIMARC", "SUTRS"])
+        prefs.add("username", _("Username"), "", nil, false)
+        prefs.add("password", _("Password"), "", nil, false)
+        prefs.add("charset", _("Charset encoding"), "ISO-8859-1")
+
+        # HACK : piggybacking support
+        prefs.add("piggyback", "Piggyback", true, [true, false])
+        prefs.read
+      end
+
+      def search(criterion, type)
+        prefs.read
+        criterion = criterion.encode(prefs["charset"])
+
+        isbn = type == SEARCH_BY_ISBN ? criterion : nil
+        criterion = canonicalise_criterion(criterion, type)
+        conn_count = request_count(type)
+        resultset = search_records(criterion, type, conn_count)
+        log.debug { "total #{resultset.length}" }
+
+        results = books_from_resultset(resultset, isbn)
+        raise NoResultsError if results.empty?
+
+        type == SEARCH_BY_ISBN ? results.first : results
+      end
+
+      def url(_book)
+        nil
+      end
+
+      def books_from_resultset(resultset, isbn)
+        case prefs["record_syntax"]
+        when /MARC$/
+          books_from_marc(resultset, isbn)
+        when "SUTRS"
+          books_from_sutrs(resultset)
+        else
+          raise NoResultsError
+        end
+      end
+
+      private
+
+      def request_count(type)
+        type == SEARCH_BY_ISBN ? 1 : 10 # results to retrieve
+      end
+
+      def canonicalise_criterion(criterion, type)
+        criterion = Library.canonicalise_isbn(criterion) if type == SEARCH_BY_ISBN
+        criterion
+      end
+
+      def books_from_sutrs(_resultset)
+        # SUTRS needs to be decoded separately, because each Z39.50 server has a
+        # different one.
+        raise NoResultsError
+      end
+
+      def marc_to_book(marc_txt, isbn)
+        begin
+          marc = MARC::Record.new_from_marc(marc_txt, forgiving: true)
+        rescue StandardError => ex
+          log.error { ex.message }
+          log.error { ex.backtrace.join("> \n") }
+          begin
+            marc = MARC::Record.new(marc_txt)
+          rescue StandardError => ex
+            log.error { ex.message }
+            log.error { ex.backtrace.join("> \n") }
+            raise ex
+          end
+        end
+
+        log.debug do
+          msg = "Parsing MARC"
+          msg += "\n title: #{marc.title}"
+          msg += "\n authors: #{marc.authors.join(', ')}"
+          msg += "\n isbn: #{marc.isbn}, #{isbn}"
+          msg += "\n publisher: #{marc.publisher}"
+          msg += "\n publish year: #{marc.publish_year}" if marc.respond_to?(:publish_year)
+          msg += "\n edition: #{marc.edition}"
+          msg
+        end
+
+        return if marc.title.nil? # or marc.authors.empty?
+
+        isbn ||= marc.isbn
+        isbn = Library.canonicalise_ean(isbn)
+
+        Book.new(marc.title, marc.authors,
+                 isbn,
+                 (marc.publisher || ""),
+                 marc.respond_to?(:publish_year) ? marc.publish_year.to_i : nil,
+                 (marc.edition || ""))
+      end
+
+      def books_from_marc(resultset, isbn)
+        results = []
+        resultset[0..9].each do |record|
+          marc_txt = record.render(prefs["charset"], "UTF-8")
+          log.debug { marc_txt }
+          File.binwrite(",marc.txt", marc_txt) if $DEBUG
+          book = nil
+          begin
+            mappings = Alexandria::PseudoMarcParser::USMARC_MAPPINGS
+            if prefs["hostname"] == "z3950.bnf.fr"
+              mappings = Alexandria::PseudoMarcParser::BNF_FR_MAPPINGS
+            end
+            # try pseudo-marc parser first (it seems to have more luck)
+            book = Alexandria::PseudoMarcParser.marc_text_to_book(marc_txt,
+                                                                  mappings)
+            if book.nil?
+              # failing that, try the genuine MARC parser
+              book = marc_to_book(marc_txt, isbn)
+            end
+          rescue StandardError => ex
+            log.warn { ex }
+            log.warn { ex.backtrace }
+          end
+
+          results << [book] unless book.nil?
+        end
+        results
+      end
+
+      def marc?
+        prefs["record_syntax"].end_with?("MARC")
+      end
+
+      def search_records(criterion, type, conn_count)
+        options = {}
+        unless prefs["username"].empty? || prefs["password"].empty?
+          options["user"] = prefs["username"]
+          options["password"] = prefs["password"]
+        end
+        hostname = prefs["hostname"]
+        port = prefs["port"].to_i
+        log.debug { "hostname #{hostname} port #{port} options #{options}" }
+        conn = ZOOM::Connection.new(options).connect(hostname, port)
+        conn.database_name = prefs["database"]
+
+        conn.preferred_record_syntax = prefs["record_syntax"]
+        conn.element_set_name = "F"
+        conn.count = conn_count
+        attr = case type
+               when SEARCH_BY_ISBN     then [7]
+               when SEARCH_BY_TITLE    then [4]
+               when SEARCH_BY_AUTHORS  then [1, 1003]
+               when SEARCH_BY_KEYWORD  then [1016]
+               end
+        pqf = ""
+        attr.each { |att| pqf += "@attr 1=#{att} " }
+        pqf += '"' + criterion.upcase + '"'
+        log.debug { "pqf is #{pqf}, syntax #{prefs['record_syntax']}" }
+
+        begin
+          if prefs.variable_named("piggyback") && !prefs["piggyback"]
+            log.debug { "setting conn.piggyback to false" }
+            conn.piggyback = false
+          end
+          conn.search(pqf)
+        rescue StandardError => ex
+          if /1005/.match?(ex.message) &&
+              prefs.variable_named("piggyback") && prefs["piggyback"]
+            log.error { "Z39.50 search failed:: #{ex.message}" }
+            log.info { "Turning off piggybacking for this provider" }
+            prefs.variable_named("piggyback").new_value = false
+            retry
+          end
+
+          raise ex
+        end
+      end
+    end
+  end
+end

data/lib/alexandria/book_providers.rb

@@ -35,21 +35,26 @@ module Alexandria
     SEARCH_BY_KEYWORD = (0..3).to_a
 
     class SearchError < StandardError; end
+
     class NoResultsError < SearchError; end
-    class ProviderSkippedError < NoResultsError; end # not an error :^(
-    class SearchEmptyError < SearchError; end # sigh, again not really an error
+
     class TooManyResultsError < SearchError; end
+
     class InvalidSearchTypeError < SearchError; end
 
+    # These errors are not really errors
+    class ProviderSkippedError < NoResultsError; end
+
+    class SearchEmptyError < SearchError; end
+
     def self.search(criterion, type)
       factory_n = 0
-      # puts "book_providers search #{self.instance.count_observers}"
 
       begin
         factory = instance[factory_n]
-        puts factory.fullname + " lookup" if $DEBUG
+        log.debug { factory.fullname + " lookup" }
         unless factory.enabled
-          puts factory.fullname + " disabled!, skipping..." if $DEBUG
+          log.debug { factory.fullname + " disabled!, skipping..." }
           raise ProviderSkippedError
         end
         instance.changed
@@ -83,7 +88,7 @@ module Alexandria
           trace = ex.backtrace.join("\n >")
           log.warn { "Provider #{factory.name} encountered error: #{ex.message} #{trace}" }
         end
-        if last == factory
+        if factory == instance.last
           log.warn { "Error while searching #{criterion}" }
           message = case ex
                     when Timeout::Error
@@ -92,14 +97,9 @@ module Alexandria
 
                     when SocketError
                       format(_("Couldn't reach the provider '%s': socket " \
-                        "error (%s)."), factory.name, ex.message)
-
-                    when NoResultsError
-                      _("No results were found.  Make sure your " \
-                        "search criterion is spelled correctly, and " \
-                        "try again.")
+                               "error (%s)."), factory.name, ex.message)
 
-                    when ProviderSkippedError
+                    when NoResultsError, ProviderSkippedError
                       _("No results were found.  Make sure your " \
                         "search criterion is spelled correctly, and " \
                         "try again.")
@@ -113,8 +113,8 @@ module Alexandria
                     else
                       ex.message
                     end
-          puts "raising empty error #{message}"
-          raise SearchEmptyError, message
+          log.debug { "raising empty error #{message}" }
+          raise SearchEmptyError, message # rubocop:disable I18n/GetText/DecorateFunctionMessage
         else
           factory_n += 1
           retry
@@ -152,9 +152,8 @@ module Alexandria
         end
 
         def new_value=(new_value)
-          message = @provider.variable_name(self) + "="
-          Alexandria::Preferences.instance.send(message,
-                                                new_value)
+          name = @provider.variable_name(self)
+          Alexandria::Preferences.instance.set_variable(name, new_value)
           self.value = new_value
         end
 
@@ -187,8 +186,8 @@ module Alexandria
 
       def read
         each do |var|
-          message = @provider.variable_name(var)
-          val = Alexandria::Preferences.instance.send(message)
+          name = @provider.variable_name(var)
+          val = Alexandria::Preferences.instance.get_variable(name)
           var.value = val unless val.nil? || ((val == "") && var.mandatory?)
         end
       end
@@ -216,22 +215,22 @@ module Alexandria
       end
 
       def reinitialize(fullname)
-        @name << "_" << fullname.hash.to_s
+        @name = "#{name}_#{fullname.hash}"
         @fullname = fullname
         prefs = Alexandria::Preferences.instance
-        ary = prefs.abstract_providers
+        ary = prefs.get_variable :abstract_providers
         ary ||= []
         ary << @name
-        prefs.abstract_providers = ary
-        message = variable_name("name") + "="
-        prefs.send(message, @fullname)
+        prefs.set_variable :abstract_providers, ary
+        message = variable_name("name")
+        prefs.set_variable(message, @fullname)
       end
 
       def remove
         prefs = Alexandria::Preferences.instance
-        if (ary = prefs.abstract_providers)
+        if (ary = prefs.get_variable :abstract_providers)
           ary.delete(@name)
-          prefs.abstract_providers = ary
+          prefs.set_variable :abstract_providers, ary
         end
         if (ary = prefs.providers_priority) && ary.include?(@name)
           ary.delete(@name)
@@ -271,8 +270,8 @@ module Alexandria
         !included_modules.include?(Singleton)
       end
 
-      def <=>(provider)
-        fullname <=> provider.fullname
+      def <=>(other)
+        fullname <=> other.fullname
       end
 
       # FIXME: Clean up this complex abstract/concrete class system
@@ -291,19 +290,14 @@ module Alexandria
 
     require "alexandria/book_providers/douban" # only requires YAML
 
-    # Amazon AWS (Amazon Associates Web Services) provider, needs hpricot
-    require "alexandria/book_providers/amazon_aws"
-
     # Website based providers
-    require "alexandria/book_providers/adlibris"
-    require "alexandria/book_providers/barnes_and_noble"
-    require "alexandria/book_providers/proxis"
-    require "alexandria/book_providers/siciliano"
-    require "alexandria/book_providers/thalia"
+    require "alexandria/book_providers/thalia_provider"
     require "alexandria/book_providers/worldcat"
 
     # Z39.50 based providers
-    require "alexandria/book_providers/z3950"
+    require "alexandria/book_providers/loc_provider"
+    require "alexandria/book_providers/bl_provider"
+    require "alexandria/book_providers/sbn_provider"
 
     attr_reader :abstract_classes
 
@@ -325,10 +319,9 @@ module Alexandria
         next unless md
 
         klass = self.class.module_eval(constant.to_s)
-        if klass.ancestors.include?(AbstractProvider) &&
+        if klass < AbstractProvider &&
             (klass != GenericProvider) &&
-            (klass != WebsiteBasedProvider) &&
-            (klass != AbstractProvider)
+            (klass != WebsiteBasedProvider)
 
           if klass.abstract?
             @abstract_classes << klass
@@ -337,7 +330,7 @@ module Alexandria
           end
         end
       end
-      if (ary = @prefs.abstract_providers)
+      if (ary = @prefs.get_variable :abstract_providers)
         ary.each do |name|
           md = /^(.+)_/.match(name)
           next unless md
@@ -366,37 +359,27 @@ module Alexandria
       compact!
     end
 
-    # FIXME: Define the handful of methods that use this.
-    def self.method_missing(id, *args, &block)
-      if instance.respond_to? id
-        instance.method(id).call(*args, &block)
-      else
-        super
-      end
+    def self.list
+      instance
+    end
+
+    def self.abstract_classes
+      instance.abstract_classes
     end
 
     private
 
     def rejig_providers_priority
       priority = (@prefs.providers_priority || [])
-      unless priority.empty?
-        changed = false
+      return if priority.empty?
 
-        if (ecs_index = priority.index("AmazonECS"))
-          priority[ecs_index] = "Amazon" # replace legacy "AmazonECS" name
-          priority.uniq! # remove any other "Amazon" from the list
-          changed = true
-        end
-        if (worldcat_index = priority.index("Worldcat"))
-          priority[worldcat_index] = "WorldCat"
-          changed = true
-        end
-        if (adlibris_index = priority.index("Adlibris"))
-          priority[adlibris_index] = "AdLibris"
-          changed = true
-        end
-        @prefs.providers_priority = priority if changed
+      changed = false
+
+      if (worldcat_index = priority.index("Worldcat"))
+        priority[worldcat_index] = "WorldCat"
+        changed = true
       end
+      @prefs.providers_priority = priority if changed
     end
   end
 end

data/lib/alexandria/default_preferences.rb

@@ -11,6 +11,7 @@ module Alexandria
       "view_as" => 0,
       "arrange_icons_mode" => 0,
       "reverse_icons" => false,
+      "selected_library" => "",
       "barcode_scanner" => "CueCat",
       "play_scanning_sound" => true,
       "play_scan_sound" => true,
@@ -29,7 +30,7 @@ module Alexandria
       "col_want_visible" => true,
       "col_tags_visible" => true,
       "cols_width" => "{}",
-      "providers_priority" => ["Amazon", "BarnesAndNoble", "AdLibris", "Proxis", "Thalia", "Siciliano", "WorldCat", "LOC", "BL", "SBN"],
+      "providers_priority" => ["Thalia", "WorldCat", "LOC", "BL", "SBN"],
       "view_advanced_settings" => false
     }
   end

data/lib/alexandria/execution_queue.rb

@@ -63,10 +63,11 @@ module Alexandria
 
       id, procedure, args, need_retval = ary
       retval = procedure.call(*args)
-      if need_retval
-        @protect_pending_retvals.synchronize do
-          @pending_retvals << [id, retval]
-        end
+
+      return unless need_retval
+
+      @protect_pending_retvals.synchronize do
+        @pending_retvals << [id, retval]
       end
     end
 
@@ -81,14 +82,14 @@ module Alexandria
         @id += 1
         @pending_calls << [@id, procedure, args, need_retval]
       end
-      if need_retval
-        loop do
-          @protect_pending_retvals.synchronize do
-            ary = @pending_retvals.find { |id, _retval| id == @id }
-            if ary
-              @pending_retvals.delete(ary)
-              return ary[1]
-            end
+      return unless need_retval
+
+      loop do
+        @protect_pending_retvals.synchronize do
+          ary = @pending_retvals.find { |id, _retval| id == @id }
+          if ary
+            @pending_retvals.delete(ary)
+            return ary[1]
           end
         end
       end

data/lib/alexandria/export_library.rb

@@ -36,25 +36,24 @@ module Alexandria
     end
 
     def export_as_onix_xml_archive(filename)
-      File.open(File.join(Dir.tmpdir, "onix.xml"), "w") do |io|
+      dir = Dir.mktmpdir
+      File.open(File.join(dir, "onix.xml"), "w") do |io|
         to_onix_document.write(io, 0)
       end
-      copy_covers(File.join(Dir.tmpdir, "images"))
-      Dir.chdir(Dir.tmpdir) do
+      copy_covers(File.join(dir, "images"))
+      Dir.chdir(dir) do
         output = `tar -cjf \"#{filename}\" onix.xml images 2>&1`
         raise output unless $CHILD_STATUS.success?
       end
-      FileUtils.rm_rf(File.join(Dir.tmpdir, "images"))
-      FileUtils.rm(File.join(Dir.tmpdir, "onix.xml"))
+      FileUtils.rm_rf(File.join(dir, "images"))
+      FileUtils.rm(File.join(dir, "onix.xml"))
+    ensure
+      FileUtils.remove_entry dir
     end
 
     def export_as_tellico_xml_archive(filename)
       File.open(File.join(Dir.tmpdir, "tellico.xml"), "w") do |io|
         to_tellico_document.write(io, 0)
-      rescue StandardError => ex
-        puts ex.message
-        puts ex.backtrace
-        raise ex
       end
       copy_covers(File.join(Dir.tmpdir, "images"))
       Dir.chdir(Dir.tmpdir) do
@@ -190,7 +189,7 @@ module Alexandria
             File.join("images", final_cover(book))
         end
         if book.isbn
-          BookProviders.each do |provider|
+          BookProviders.list.each do |provider|
             elem = prod.add_element("ProductWebsite")
             elem.add_element("ProductWebsiteDescription").text =
               provider.fullname
@@ -252,7 +251,7 @@ module Alexandria
           entry.add_element("cover").text = final_cover(book)
           image = images.add_element("image")
           image.add_attribute("id", final_cover(book))
-          image_s = ImageSize.new(IO.read(cover(book)))
+          image_s = ImageSize.new(File.read(cover(book)))
           image.add_attribute("height", image_s.height.to_s)
           image.add_attribute("width", image_s.width.to_s)
           image.add_attribute("format", image_s.format)
@@ -267,7 +266,7 @@ module Alexandria
       escaped.gsub!(/&/, "&")
       escaped.gsub!(/</, "&lt;")
       escaped.gsub!(/>/, "&gt;")
-      escaped.gsub!(/\"/, "&quot;")
+      escaped.gsub!(/"/, "&quot;")
       escaped
     end
 
@@ -299,7 +298,7 @@ module Alexandria
         EOS
 
         if File.exist?(cover(book))
-          image_s = ImageSize.new(IO.read(cover(book)))
+          image_s = ImageSize.new(File.read(cover(book)))
           xhtml << <<~EOS
             <img class="book_cover"
                  src="#{File.join('pixmaps', final_cover(book))}"
@@ -375,7 +374,7 @@ module Alexandria
         bibtex << 'author = "'
         if book.authors != []
           bibtex << book.authors[0]
-          book.authors[1..-1].each do |author|
+          book.authors[1..].each do |author|
             bibtex << " and #{latex_escape(author)}"
           end
         end
@@ -396,15 +395,15 @@ module Alexandria
       return "" if str.nil?
 
       my_str = str.dup
-      my_str.gsub!(/%/, '\\%')
-      my_str.gsub!(/~/, '\\textasciitilde')
-      my_str.gsub!(/\&/, '\\\\&')
-      my_str.gsub!(/\#/, '\\\\#')
-      my_str.gsub!(/\{/, '\\{')
-      my_str.gsub!(/\}/, '\\}')
-      my_str.gsub!(/_/, '\\_')
+      my_str.gsub!(/%/, "\\%")
+      my_str.gsub!(/~/, "\\textasciitilde")
+      my_str.gsub!(/&/, "\\\\&")
+      my_str.gsub!(/\#/, "\\\\#")
+      my_str.gsub!(/\{/, "\\{")
+      my_str.gsub!(/\}/, "\\}")
+      my_str.gsub!(/_/, "\\_")
       my_str.gsub!(/\$/, "\\\$")
-      my_str.gsub!(/\"(.+)\"/, "``\1''")
+      my_str.gsub!(/"(.+)"/, "``\1''")
       my_str
     end
   end

data/lib/alexandria/image_fetcher.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
+#
+# See the file README.md for authorship and licensing information.
+
+require "alexandria/net"
+
+module Alexandria
+  module ImageFetcher
+    def fetch_image(uri)
+      result = nil
+      if URI.parse(uri).scheme.nil?
+        File.open(uri, "r") do |io|
+          result = io.read
+        end
+      else
+        result = WWWAgent.new.get(uri)
+      end
+      result
+    rescue Errno::ECONNRESET
+      nil
+    end
+  end
+end