alexandria-book-collection-manager 0.7.3 → 0.7.8

data/lib/alexandria/import_library.rb

@@ -4,24 +4,25 @@
 #
 # See the file README.md for authorship and licensing information.
 
-require 'gettext'
-require 'tmpdir'
+require "gettext"
+require "tmpdir"
 
 module Alexandria
   class ImportFilter
     attr_reader :name, :patterns, :message
 
+    include Logging
     include GetText
     extend GetText
-    bindtextdomain(Alexandria::TEXTDOMAIN, charset: 'UTF-8')
+    bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
     def self.all
       [
-        new(_('Autodetect'), ['*'], :import_autodetect),
-        new(_('Archived Tellico XML (*.bc, *.tc)'),
-            ['*.tc', '*.bc'], :import_as_tellico_xml_archive),
-        new(_('ISBN List (*.txt)'), ['*.txt'], :import_as_isbn_list),
-        new(_('GoodReads CSV'), ['*.csv'], :import_as_csv_file)
+        new(_("Autodetect"), ["*"], :import_autodetect),
+        new(_("Archived Tellico XML (*.bc, *.tc)"),
+            ["*.tc", "*.bc"], :import_as_tellico_xml_archive),
+        new(_("ISBN List (*.txt)"), ["*.txt"], :import_as_isbn_list),
+        new(_("GoodReads CSV"), ["*.csv"], :import_as_csv_file)
       ]
     end
 
@@ -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,122 +51,100 @@ 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]}"
-      if filename[-4..-1] == '.txt'
+      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 => e
-          puts e.message
-          puts e.backtrace.join("\n>> ")
-        end
-      elsif ['.csv'].include? filename[-4..-1]
+      elsif [".tc", ".bc"].include? filename[-3..-1]
+        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')
+      tmpdir = File.join(Dir.tmpdir, "tellico_export")
       FileUtils.rm_rf(tmpdir) if File.exist?(tmpdir)
       Dir.mkdir(tmpdir)
       Dir.chdir(tmpdir) do
-        begin
-          system("unzip -qq \"#{filename}\"")
-          file = File.exist?('bookcase.xml') ? 'bookcase.xml' : 'tellico.xml'
-          xml = REXML::Document.new(File.open(file))
-          raise unless ['bookcase', 'tellico'].include? xml.root.name
-          # FIXME: handle multiple collections
-          raise unless xml.root.elements.size == 1
-
-          collection = xml.root.elements[1]
-          raise unless collection.name == 'collection'
-
-          type = collection.attribute('type').value.to_i
-          raise unless (type == 2) || (type == 5)
-
-          content = []
-          entries = collection.elements.to_a('entry')
-          (total = entries.size).times do |n|
-            entry = entries[n]
-            elements = entry.elements
-            # Feed an array in here, tomorrow.
-            keys = ['isbn', 'publisher', 'pub_year', 'binding']
-
-            book_elements = [neaten(elements['title'].text)]
-            book_elements += if !elements['authors'].nil?
-                               [elements['authors'].elements.to_a.map \
-                                                 { |x| neaten(x.text) }]
-                             else
-                               [[]]
-                             end
-            book_elements += keys.map { |key|
-              neaten(elements[key].text) if elements[key]
-            }
-            # 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[4] = book_elements[4].to_i unless book_elements[4].nil? # publishing_year
-            puts book_elements.inspect
-            cover = (neaten(elements['cover'].text) if elements['cover'])
-            puts cover
-            book = Book.new(*book_elements)
-            if elements['rating'] && Book::VALID_RATINGS.member?(elements['rating'].text.to_i)
-              book.rating = elements['rating'].text.to_i
-            end
-            book.notes = neaten(elements['comments'].text) if elements['comments']
-            content << [book, cover]
-            on_iterate_cb&.call(n + 1, total)
-          end
+        system("unzip -qq \"#{filename}\"")
+        file = File.exist?("bookcase.xml") ? "bookcase.xml" : "tellico.xml"
+        xml = REXML::Document.new(File.open(file))
+        raise unless ["bookcase", "tellico"].include? xml.root.name
+        # FIXME: handle multiple collections
+        raise unless xml.root.elements.size == 1
 
-          library = Library.load(name)
-          content.each do |book, cover|
-            unless cover.nil?
-              library.save_cover(book,
-                                 File.join(Dir.pwd, 'images',
-                                           cover))
-            end
-            library << book
-            library.save(book)
+        collection = xml.root.elements[1]
+        raise unless collection.name == "collection"
+
+        type = collection.attribute("type").value.to_i
+        raise unless (type == 2) || (type == 5)
+
+        content = []
+        entries = collection.elements.to_a("entry")
+        (total = entries.size).times do |n|
+          entry = entries[n]
+          elements = entry.elements
+          # Feed an array in here, tomorrow.
+          keys = ["isbn", "publisher", "pub_year", "binding"]
+
+          book_elements = [neaten(elements["title"].text)]
+          book_elements += if !elements["authors"].nil?
+                             [elements["authors"].elements.to_a.map \
+                                               { |x| neaten(x.text) }]
+                           else
+                             [[]]
+                           end
+          book_elements += keys.map do |key|
+            neaten(elements[key].text) if elements[key]
+          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?
+          log.debug { book_elements.inspect }
+          cover = (neaten(elements["cover"].text) if elements["cover"])
+          log.debug { cover }
+          book = Book.new(*book_elements)
+          if elements["rating"]
+            rating = elements["rating"].text.to_i
+            book.rating = rating if Book::VALID_RATINGS.member? rating
           end
-          return [library, []]
-        rescue StandardError => e
-          puts e.message
-          return nil
+          book.notes = neaten(elements["comments"].text) if elements["comments"]
+          content << [book, cover]
+          on_iterate_cb&.call(n + 1, total)
+        end
+
+        # TODO: Pass in library store as an argument
+        library = LibraryCollection.instance.library_store.load_library name
+        content.each do |book, cover|
+          library.save_cover(book, File.join(Dir.pwd, "images", cover)) unless cover.nil?
+          library << book
+          library.save(book)
         end
+        return [library, []]
+      rescue StandardError => ex
+        log.info { ex.message }
+        return nil
       end
     end
 
     def self.import_as_csv_file(name, filename, on_iterate_cb, _on_error_cb)
-      require 'alexandria/import_library_csv'
+      require "alexandria/import_library_csv"
       books_and_covers = []
       line_count = IO.readlines(filename).reduce(0) { |count, _line| count + 1 }
 
       import_count = 0
       max_import = line_count - 1
 
-      reader = CSV.open(filename, 'r')
+      reader = CSV.open(filename, "r")
       # Goodreads & LibraryThing now use csv header lines
       header = reader.shift
       importer = identify_csv_type(header)
@@ -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,12 +181,12 @@ module Alexandria
           # probably Goodreads' wonky ISBN fields ,,="043432432X",
           # this is a hack to fix up such files
           data = File.read(filename)
-          data.gsub!(/\,\=\"/, ',"')
-          csv_fixed = Tempfile.new('alexandria_import_csv_fixed_')
+          data.gsub!(/,="/, ',"')
+          csv_fixed = Tempfile.new("alexandria_import_csv_fixed_")
           csv_fixed.write(data)
           csv_fixed.close
 
-          reader = CSV.open(csv_fixed.path, 'r')
+          reader = CSV.open(csv_fixed.path, "r")
           header = reader.shift
           importer = identify_csv_type(header)
 
@@ -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 => e
-          puts e.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 => e
-          puts e.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)

data/lib/alexandria/import_library_csv.rb

@@ -20,10 +20,10 @@
 # New CSV import code taken from Palatina and modified for
 # Alexandria. (29 Apr 2010)
 
-require 'csv'
-require 'date'
-require 'htmlentities'
-require 'tempfile'
+require "csv"
+require "date"
+require "htmlentities"
+require "tempfile"
 
 module Alexandria
   class CSVImport
@@ -47,21 +47,21 @@ module Alexandria
   class GoodreadsCSVImport < CSVImport
     def initialize(header)
       super(header)
-      @title = index_of('Title')
-      @author = index_of('Author')
-      @additional_authors = index_of('Additional Authors')
-      @isbn = index_of('ISBN')
-      @publisher = index_of('Publisher')
-      @publishing_year = index_of('Year Published')
-      @edition = index_of('Binding')
+      @title = index_of("Title")
+      @author = index_of("Author")
+      @additional_authors = index_of("Additional Authors")
+      @isbn = index_of("ISBN")
+      @publisher = index_of("Publisher")
+      @publishing_year = index_of("Year Published")
+      @edition = index_of("Binding")
 
       # optional extras
-      @notes = index_of('Private Notes')
-      @rating = index_of('My Rating')
-      @read_count = index_of('Read Count')
-      @date_read = index_of('Date Read')
-      @bookshelves = index_of('Bookshelves') # save names as tags
-      @mainshelf = index_of('Exclusive Shelf')
+      @notes = index_of("Private Notes")
+      @rating = index_of("My Rating")
+      @read_count = index_of("Read Count")
+      @date_read = index_of("Date Read")
+      @bookshelves = index_of("Bookshelves") # save names as tags
+      @mainshelf = index_of("Exclusive Shelf")
     end
 
     def row_to_book(row)
@@ -69,11 +69,10 @@ module Alexandria
       authors = []
       authors << normalize(row[@author])
       additional = row[@additional_authors]
-      additional.split(',').each do |add|
+      additional.split(",").each do |add|
         authors << normalize(add)
       end
-      isbn = row[@isbn] # TODO: canonicalize_ean...
-      isbn = Library.canonicalise_ean(isbn) if isbn
+      isbn = Library.canonicalise_ean(row[@isbn])
       publisher = normalize(row[@publisher])
       year = row[@publishing_year].to_i
       edition = normalize(row[@edition])
@@ -90,29 +89,30 @@ module Alexandria
         book.redd = true if count > 0
       end
       if row[@date_read]
-        date = Date.strptime(str, '%d/%m/%y') # e.g. "14/01/10" => 2010-01-14
+        date = Date.strptime(str, "%d/%m/%y") # e.g. "14/01/10" => 2010-01-14
         book.redd_when = date
         book.redd = true
       end
       if row[@mainshelf]
-        if row[@mainshelf] == 'read'
+        case row[@mainshelf]
+        when "read"
           book.redd = true
-        elsif row[@mainshelf] == 'to-read'
+        when "to-read"
           book.redd = false
-          book.tags = ['to read']
-        elsif row[@mainshelf] == 'currently-reading'
+          book.tags = ["to read"]
+        when "currently-reading"
           book.redd = false
-          book.tags = ['currently reading']
+          book.tags = ["currently reading"]
         end
       end
       if row[@bookshelves]
         shelves = normalize(row[@bookshelves]).split
         shelves.each do |shelf|
-          tag = shelf.tr('-', ' ')
+          tag = shelf.tr("-", " ")
           book.tags << tag unless book.tags.include? tag
         end
       end
-      puts "Goodreads loading #{book.title}" if $DEBUG
+      log.debug { "Goodreads loading #{book.title}" }
       book
     end
   end
@@ -146,10 +146,10 @@ module Alexandria
       # sometimes "Publisher (YEAR), Edition: NUM, Binding, NUM pages"
       publisher_info = normalize(row[@publisher_info])
       publisher = publisher_info
-      publisher = Regexp.last_match[1] if publisher_info =~ /([^\(]+)\(/
+      publisher = Regexp.last_match[1] if publisher_info =~ /([^(]+)\(/
       edition = publisher_info # binding
-      edition_info = publisher_info.split(',')
-      edition = publisher_info.split(',')[-2] if edition_info.size >= 3
+      edition_info = publisher_info.split(",")
+      edition = publisher_info.split(",")[-2] if edition_info.size >= 3
 
       year = row[@publishing_year].to_i
 
@@ -163,13 +163,13 @@ module Alexandria
 
       book.rating = row[@rating].to_i if row[@rating]
       if row[@tags]
-        tags = normalize(row[@tags]).split(',')
+        tags = normalize(row[@tags]).split(",")
         tags.each do |tag|
           book.tags << tag unless book.tags.include? tag
         end
       end
 
-      puts "LibraryThing loading #{book.title}" if $DEBUG
+      log.debug { "LibraryThing loading #{book.title}" }
       book
     end
   end
@@ -183,20 +183,20 @@ module Alexandria
       is_librarything = false
       is_goodreads = false
       header.each do |head|
-        if head == "'PUBLICATION INFO'"
+        case head
+        when "'PUBLICATION INFO'"
           is_librarything = true
           break
-        elsif head == 'Year Published'
+        when "Year Published"
           is_goodreads = true
           break
         end
       end
-      if is_librarything
-        return LibraryThingCSVImport.new(header)
-      elsif is_goodreads
-        return GoodreadsCSVImport.new(header)
-      end
-      raise 'Not Recognized' unless is_librarything || is_goodreads
+
+      return LibraryThingCSVImport.new(header) if is_librarything
+      return GoodreadsCSVImport.new(header) if is_goodreads
+
+      raise _("Not Recognized") unless is_librarything || is_goodreads
     end
   end
 end