alexandria-book-collection-manager 0.7.5 → 0.7.6

data/lib/alexandria/book_providers/z3950.rb

@@ -37,19 +37,15 @@ module Alexandria
         prefs.read
         criterion = criterion.encode(prefs["charset"])
 
-        # We only decode MARC at the moment.
-        # SUTRS needs to be decoded separately, because each Z39.50 server has a
-        # different one.
-        raise NoResultsError unless marc?
-
         isbn = type == SEARCH_BY_ISBN ? criterion : nil
-        criterion = Library.canonicalise_isbn(criterion) if type == SEARCH_BY_ISBN
-        conn_count = type == SEARCH_BY_ISBN ? 1 : 10 # results to retrieve
+        criterion = canonicalise_criterion(criterion, type)
+        conn_count = request_count(type)
         resultset = search_records(criterion, type, conn_count)
         log.debug { "total #{resultset.length}" }
-        raise NoResultsError if resultset.length == 0
 
-        results = books_from_marc(resultset, isbn)
+        results = books_from_resultset(resultset, isbn)
+        raise NoResultsError if results.empty?
+
         type == SEARCH_BY_ISBN ? results.first : results
       end
 
@@ -57,9 +53,35 @@ module Alexandria
         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 marc_to_book(marc_txt)
+      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
@@ -87,18 +109,17 @@ module Alexandria
 
         return if marc.title.nil? # or marc.authors.empty?
 
-        (isbn = isbn) || marc.isbn
+        isbn ||= marc.isbn
         isbn = Library.canonicalise_ean(isbn)
 
-        book = Book.new(marc.title, marc.authors,
-                        isbn,
-                        (marc.publisher || ""),
-                        marc.respond_to?(:publish_year) ? marc.publish_year.to_i : nil,
-                        (marc.edition || ""))
-        book
+        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)
+      def books_from_marc(resultset, isbn)
         results = []
         resultset[0..9].each do |record|
           marc_txt = record.render(prefs["charset"], "UTF-8")
@@ -119,7 +140,7 @@ module Alexandria
                                                                   mappings)
             if book.nil?
               # failing that, try the genuine MARC parser
-              book = marc_to_book(marc_txt)
+              book = marc_to_book(marc_txt, isbn)
             end
           rescue StandardError => ex
             log.warn { ex }
@@ -132,7 +153,7 @@ module Alexandria
       end
 
       def marc?
-        /MARC$/.match(prefs["record_syntax"])
+        prefs["record_syntax"].end_with?("MARC")
       end
 
       def search_records(criterion, type, conn_count)
@@ -147,9 +168,6 @@ module Alexandria
         conn = ZOOM::Connection.new(options).connect(hostname, port)
         conn.database_name = prefs["database"]
 
-        # HACK: turn off piggybacking, just to see CMcG
-        # #conn.piggyback = false
-
         conn.preferred_record_syntax = prefs["record_syntax"]
         conn.element_set_name = "F"
         conn.count = conn_count
@@ -165,27 +183,21 @@ module Alexandria
         log.debug { "pqf is #{pqf}, syntax #{prefs['record_syntax']}" }
 
         begin
-          if prefs.variable_named("piggyback")
-            unless prefs["piggyback"]
-              log.debug { "setting conn.piggyback to false" }
-              conn.piggyback = false
-            end
+          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)
-            if 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
-              search_records(criterion, type, conn_count)
-              # hopefully these precautions will prevent infinite loops here
-            else
-              raise ex
-            end
-          else
-            raise 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
@@ -243,20 +255,6 @@ module Alexandria
         prefs.read
       end
 
-      def search(criterion, type)
-        return super unless prefs["record_syntax"] == "SUTRS"
-
-        prefs.read
-        criterion = Library.canonicalise_isbn(criterion) if type == SEARCH_BY_ISBN
-        conn_count = type == SEARCH_BY_ISBN ? 1 : 10 # results to retrieve
-        resultset = search_records(criterion, type, conn_count)
-        log.debug { "total #{resultset.length}" }
-        raise NoResultsError if resultset.length == 0
-
-        results = books_from_sutrs(resultset)
-        type == SEARCH_BY_ISBN ? results.first : results
-      end
-
       def url(book)
         "http://copac.ac.uk/openurl?isbn=" + Library.canonicalise_isbn(book.isbn)
       rescue StandardError => ex
@@ -285,7 +283,7 @@ module Alexandria
               authors << md[1]
             elsif (md = /^ISBN:\s+([\dXx]+)/.match(line))
               isbn = Library.canonicalise_ean(md[1])
-            elsif (md = /^Imprint:.+\:\s*(.+)\,/.match(line))
+            elsif (md = /^Imprint:.+:\s*(.+),/.match(line))
               publisher = md[1]
             end
           end
@@ -329,19 +327,6 @@ module Alexandria
         prefs.read
       end
 
-      def search(criterion, type)
-        prefs.read
-
-        isbn = type == SEARCH_BY_ISBN ? criterion : nil
-        criterion = canonicalise_isbn_with_dashes(criterion)
-        resultset = search_records(criterion, type, 0)
-        log.debug { "total #{resultset.length}" }
-        raise NoResultsError if resultset.length == 0
-
-        results = books_from_marc(resultset, isbn)
-        type == SEARCH_BY_ISBN ? results.first : results
-      end
-
       def url(book)
         "http://sbnonline.sbn.it/cgi-bin/zgw/BRIEF.pl?displayquery=" \
           "%253CB%253E%253Cfont%2520color%253D%2523000064%253E" \
@@ -359,6 +344,14 @@ module Alexandria
 
       private
 
+      def canonicalise_criterion(criterion, _type)
+        canonicalise_isbn_with_dashes(criterion)
+      end
+
+      def request_count(_type)
+        0
+      end
+
       def canonicalise_isbn_with_dashes(isbn)
         # The reference for the position of the dashes is
         # http://www.isbn-international.org/converter/ranges.htm
@@ -380,7 +373,7 @@ module Alexandria
           elsif isbn > "8800"
             isbn[0..1] + "-" + isbn[2..3] + "-" + isbn[4..8] + "-" + isbn[9..9]
           else
-            raise "Invalid ISBN"
+            raise _("Invalid ISBN")
           end
 
         else

data/lib/alexandria/default_preferences.rb

@@ -0,0 +1,37 @@
+# This file is automatically generated by the alexandria installer.
+# Do not edit it directly.
+
+module Alexandria
+  class Preferences
+    DEFAULT_VALUES = {
+      "position" => [0, 0],
+      "size" => [640, 480],
+      "maximized" => false,
+      "sidepane_position" => 140,
+      "view_as" => 0,
+      "arrange_icons_mode" => 0,
+      "reverse_icons" => false,
+      "selected_library" => "",
+      "barcode_scanner" => "CueCat",
+      "play_scanning_sound" => true,
+      "play_scan_sound" => true,
+      "toolbar_visible" => true,
+      "sidepane_visible" => true,
+      "statusbar_visible" => true,
+      "col_authors_visible" => true,
+      "col_edition_visible" => true,
+      "col_isbn_visible" => true,
+      "col_publisher_visible" => true,
+      "col_publish_date_visible" => true,
+      "col_loaned_to_visible" => true,
+      "col_rating_visible" => true,
+      "col_redd_visible" => true,
+      "col_own_visible" => true,
+      "col_want_visible" => true,
+      "col_tags_visible" => true,
+      "cols_width" => "{}",
+      "providers_priority" => ["Amazon", "BarnesAndNoble", "AdLibris", "Proxis", "Thalia", "Siciliano", "WorldCat", "LOC", "BL", "SBN"],
+      "view_advanced_settings" => false
+    }
+  end
+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

@@ -51,10 +51,6 @@ module Alexandria
     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 +186,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
@@ -267,7 +263,7 @@ module Alexandria
       escaped.gsub!(/&/, "&")
       escaped.gsub!(/</, "&lt;")
       escaped.gsub!(/>/, "&gt;")
-      escaped.gsub!(/\"/, "&quot;")
+      escaped.gsub!(/"/, "&quot;")
       escaped
     end
 
@@ -398,13 +394,13 @@ module Alexandria
       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!(/\$/, "\\\$")
-      my_str.gsub!(/\"(.+)\"/, "``\1''")
+      my_str.gsub!(/"(.+)"/, "``\1''")
       my_str
     end
   end

data/lib/alexandria/import_library.rb

@@ -11,6 +11,7 @@ module Alexandria
   class ImportFilter
     attr_reader :name, :patterns, :message
 
+    include Logging
     include GetText
     extend GetText
     bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
@@ -34,7 +35,7 @@ module Alexandria
     end
 
     def invoke(library_name, filename)
-      puts "Selected: #{@message} -- #{library_name} -- #{filename}"
+      log.debug { "Selected: #{@message} -- #{library_name} -- #{filename}" }
       Library.send(@message, library_name, filename,
                    @on_iterate_cb, @on_error_cb)
     end
@@ -50,30 +51,24 @@ module Alexandria
 
   class Library
     def self.import_autodetect(*args)
-      puts args.inspect
+      log.debug { args.inspect }
       filename = args[1]
-      puts "Filename is #{filename} and ext is #{filename[-4..-1]}"
-      puts "Beginning import: #{args[0]}, #{args[1]}"
+      log.debug { "Filename is #{filename} and ext is #{filename[-4..-1]}" }
+      log.debug { "Beginning import: #{args[0]}, #{args[1]}" }
       if filename[-4..-1] == ".txt"
         import_as_isbn_list(*args)
       elsif [".tc", ".bc"].include? filename[-3..-1]
-        begin
-          import_as_tellico_xml_archive(*args)
-        rescue StandardError => ex
-          puts ex.message
-          puts ex.backtrace.join("\n>> ")
-        end
+        import_as_tellico_xml_archive(*args)
       elsif [".csv"].include? filename[-4..-1]
         import_as_csv_file(*args)
       else
-        puts "Bailing on this import!"
-        raise "Not supported type"
+        raise _("Unsupported type")
       end
     end
 
     def self.import_as_tellico_xml_archive(name, filename,
                                            on_iterate_cb, _on_error_cb)
-      puts "Starting import_as_tellico_xml_archive... "
+      log.debug { "Starting import_as_tellico_xml_archive... " }
       return nil unless system("unzip -qqt \"#{filename}\"")
 
       tmpdir = File.join(Dir.tmpdir, "tellico_export")
@@ -111,25 +106,12 @@ module Alexandria
           book_elements += keys.map do |key|
             neaten(elements[key].text) if elements[key]
           end
-          # isbn
-          if book_elements[2].nil? || book_elements[2].strip.empty?
-            book_elements[2] = nil
-          else
-            begin
-              book_elements[2] = book_elements[2].strip
-              book_elements[2] = Library.canonicalise_ean(book_elements[2])
-            rescue StandardError => ex
-              puts book_elements[2]
-              puts ex.message
-              puts ex.backtrace.join("\n> ")
-              raise ex
-            end
-          end
+          book_elements[2] = Library.canonicalise_ean(book_elements[2])
           # publishing_year
           book_elements[4] = book_elements[4].to_i unless book_elements[4].nil?
-          puts book_elements.inspect
+          log.debug { book_elements.inspect }
           cover = (neaten(elements["cover"].text) if elements["cover"])
-          puts cover
+          log.debug { cover }
           book = Book.new(*book_elements)
           if elements["rating"]
             rating = elements["rating"].text.to_i
@@ -140,19 +122,16 @@ module Alexandria
           on_iterate_cb&.call(n + 1, total)
         end
 
-        library = Library.load(name)
+        # TODO: Pass in library store as an argument
+        library = LibraryCollection.instance.library_store.load_library name
         content.each do |book, cover|
-          unless cover.nil?
-            library.save_cover(book,
-                               File.join(Dir.pwd, "images",
-                                         cover))
-          end
+          library.save_cover(book, File.join(Dir.pwd, "images", cover)) unless cover.nil?
           library << book
           library.save(book)
         end
         return [library, []]
       rescue StandardError => ex
-        puts ex.message
+        log.info { ex.message }
         return nil
       end
     end
@@ -177,7 +156,7 @@ module Alexandria
           if book.isbn
             # if we can search by ISBN, try to grab the cover
             begin
-              dl_book, dl_cover = Alexandria::BookProviders.isbn_search(book.isbn)
+              dl_book, dl_cover = BookProviders.isbn_search(book.isbn)
               if dl_book.authors.size > book.authors.size
                 # LibraryThing only supports a single author, so
                 # attempt to include more author information if it's
@@ -187,8 +166,7 @@ module Alexandria
               book.edition = dl_book.edition unless book.edition
               cover = dl_cover
             rescue StandardError
-              puts "failed to get cover for #{book.title} #{book.isbn}" if $DEBUG
-              # note failure
+              log.debug { "Failed to get cover for #{book.title} #{book.isbn}" }
             end
           end
 
@@ -203,7 +181,7 @@ module Alexandria
           # probably Goodreads' wonky ISBN fields ,,="043432432X",
           # this is a hack to fix up such files
           data = File.read(filename)
-          data.gsub!(/\,\=\"/, ',"')
+          data.gsub!(/,="/, ',"')
           csv_fixed = Tempfile.new("alexandria_import_csv_fixed_")
           csv_fixed.write(data)
           csv_fixed.close
@@ -216,12 +194,13 @@ module Alexandria
         end
       end
 
-      library = Library.load(name)
+      # TODO: Pass in library store as an argument
+      library = LibraryCollection.instance.library_store.load_library name
 
       books_and_covers.each do |book, cover_uri|
-        puts "Saving #{book.isbn} cover..." if $DEBUG
+        log.debug { "Saving #{book.isbn} cover" }
         library.save_cover(book, cover_uri) unless cover_uri.nil?
-        puts "Saving #{book.isbn}..." if $DEBUG
+        log.debug { "Saving #{book.isbn}" }
         library << book
         library.save(book)
       end
@@ -230,18 +209,12 @@ module Alexandria
 
     def self.import_as_isbn_list(name, filename, on_iterate_cb,
                                  on_error_cb)
-      puts "Starting import_as_isbn_list... "
+      log.debug { "Starting import_as_isbn_list... " }
       isbn_list = IO.readlines(filename).map do |line|
-        puts "Trying line #{line}" if $DEBUG
-        # Let's preserve the failing isbns so we can report them later.
-        begin
-          [line.chomp, canonicalise_isbn(line.chomp)] unless line == "\n"
-        rescue StandardError => ex
-          puts ex.message
-          [line.chomp, nil]
-        end
+        log.debug { "Trying line #{line}" }
+        [line.chomp, canonicalise_isbn(line.chomp)] unless line == "\n"
       end
-      puts "Isbn list: #{isbn_list.inspect}"
+      log.debug { "Isbn list: #{isbn_list.inspect}" }
       isbn_list.compact!
       return nil if isbn_list.empty?
 
@@ -253,27 +226,30 @@ module Alexandria
       isbn_list.each do |isbn|
         begin
           if isbn[1]
-            books << Alexandria::BookProviders.isbn_search(isbn[1])
+            books << BookProviders.isbn_search(isbn[1])
           else
             bad_isbns << isbn[0]
           end
-        rescue StandardError => ex
-          puts ex.message
+        rescue BookProviders::SearchEmptyError => ex
+          log.debug { ex.message }
           failed_lookup_isbns << isbn[1]
-          puts "NOTE : ignoring on_error_cb #{on_error_cb}"
+          log.debug { "NOTE : ignoring on_error_cb #{on_error_cb}" }
           # return nil unless
           #  (on_error_cb and on_error_cb.call(e.message))
         end
 
         on_iterate_cb&.call(current_iteration += 1, max_iterations)
       end
-      puts "Bad Isbn list: #{bad_isbns.inspect}" if bad_isbns
-      library = load(name)
-      puts "Going with these #{books.length} books: #{books.inspect}" if $DEBUG
+      log.debug { "Bad Isbn list: #{bad_isbns.inspect}" } if bad_isbns
+
+      # TODO: Pass in library store as an argument
+      library = LibraryCollection.instance.library_store.load_library name
+
+      log.debug { "Going with these #{books.length} books: #{books.inspect}" }
       books.each do |book, cover_uri|
-        puts "Saving #{book.isbn} cover..." if $DEBUG
+        log.debug { "Saving #{book.isbn} cover..." }
         library.save_cover(book, cover_uri) unless cover_uri.nil?
-        puts "Saving #{book.isbn}..." if $DEBUG
+        log.debug { "Saving #{book.isbn}..." }
         library << book
         library.save(book)
         on_iterate_cb&.call(current_iteration += 1, max_iterations)