alexandria-book-collection-manager 0.7.2 → 0.7.3

data/lib/alexandria/import_library.rb

@@ -1,24 +1,11 @@
 # frozen_string_literal: true
 
-# Copyright (C) 2004-2006 Laurent Sansonetti
-# Copyright (C) 2010 Cathal Mc Ginley
-# Copyright (C) 2014,2015 Matijs van Zuijlen
+# This file is part of Alexandria.
 #
-# 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.
+
 require 'gettext'
+require 'tmpdir'
 
 module Alexandria
   class ImportFilter
@@ -72,7 +59,7 @@ module Alexandria
       elsif ['.tc', '.bc'].include? filename[-3..-1]
         begin
           import_as_tellico_xml_archive(*args)
-        rescue => e
+        rescue StandardError => e
           puts e.message
           puts e.backtrace.join("\n>> ")
         end
@@ -88,6 +75,7 @@ module Alexandria
                                            on_iterate_cb, _on_error_cb)
       puts 'Starting import_as_tellico_xml_archive... '
       return nil unless system("unzip -qqt \"#{filename}\"")
+
       tmpdir = File.join(Dir.tmpdir, 'tellico_export')
       FileUtils.rm_rf(tmpdir) if File.exist?(tmpdir)
       Dir.mkdir(tmpdir)
@@ -99,8 +87,10 @@ module Alexandria
           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)
 
@@ -129,7 +119,7 @@ module Alexandria
               begin
                 book_elements[2] = book_elements[2].strip
                 book_elements[2] = Library.canonicalise_ean(book_elements[2])
-              rescue => ex
+              rescue StandardError => ex
                 puts book_elements[2]
                 puts ex.message
                 puts ex.backtrace.join("\n> ")
@@ -160,7 +150,7 @@ module Alexandria
             library.save(book)
           end
           return [library, []]
-        rescue => e
+        rescue StandardError => e
           puts e.message
           return nil
         end
@@ -196,7 +186,7 @@ module Alexandria
               end
               book.edition = dl_book.edition unless book.edition
               cover = dl_cover
-            rescue
+            rescue StandardError
               puts "failed to get cover for #{book.title} #{book.isbn}" if $DEBUG
               # note failure
             end
@@ -246,7 +236,7 @@ module Alexandria
         # Let's preserve the failing isbns so we can report them later.
         begin
           [line.chomp, canonicalise_isbn(line.chomp)] unless line == "\n"
-        rescue => e
+        rescue StandardError => e
           puts e.message
           [line.chomp, nil]
         end
@@ -254,6 +244,7 @@ module Alexandria
       puts "Isbn list: #{isbn_list.inspect}"
       isbn_list.compact!
       return nil if isbn_list.empty?
+
       max_iterations = isbn_list.length * 2
       current_iteration = 1
       books = []
@@ -266,7 +257,7 @@ module Alexandria
           else
             bad_isbns << isbn[0]
           end
-        rescue => e
+        rescue StandardError => e
           puts e.message
           failed_lookup_isbns << isbn[1]
           puts "NOTE : ignoring on_error_cb #{on_error_cb}"

data/lib/alexandria/import_library_csv.rb

@@ -90,12 +90,9 @@ module Alexandria
         book.redd = true if count > 0
       end
       if row[@date_read]
-        begin
-          date = Date.strptime(str, '%d/%m/%y') # e.g. "14/01/10" => 2010-01-14
-          book.redd_when = date
-          book.redd = true
-        rescue
-        end
+        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'

data/lib/alexandria/library_collection.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
+#
+# See the file README.md for authorship and licensing information.
+
+require 'observer'
+require 'singleton'
+
+module Alexandria
+  class LibraryCollection
+    attr_reader :all_libraries, :ruined_books, :deleted_books
+    attr_accessor :library_store
+
+    include Observable
+    include Singleton
+
+    def reload
+      @all_libraries.clear
+      @all_libraries.concat(library_store.load_all_libraries)
+      @all_libraries.concat(library_store.load_all_smart_libraries)
+
+      ruined = []
+      deleted = []
+      all_regular_libraries.each { |library|
+        ruined += library.ruined_books
+        # make deleted books from each library accessible so we don't crash on smart libraries
+        deleted += library.deleted_books
+      }
+      @ruined_books = ruined
+      @deleted_books = deleted
+    end
+
+    def all_regular_libraries
+      @all_libraries.select { |x| x.is_a?(Library) }
+    end
+
+    def all_smart_libraries
+      @all_libraries.select { |x| x.is_a?(SmartLibrary) }
+    end
+
+    LIBRARY_ADDED = 1
+    LIBRARY_REMOVED = 2
+
+    def add_library(library)
+      @all_libraries << library
+      notify(LIBRARY_ADDED, library)
+    end
+
+    def remove_library(library)
+      @all_libraries.delete(library)
+      notify(LIBRARY_REMOVED, library)
+    end
+
+    def really_delete_deleted_libraries
+      Library.really_delete_deleted_libraries
+      SmartLibrary.really_delete_deleted_libraries
+    end
+
+    def really_save_all_books
+      all_regular_libraries.each do |library|
+        library.each { |book| library.save(book, true) }
+      end
+    end
+
+    private
+
+    def initialize
+      @all_libraries = []
+      @deleted_books = []
+    end
+
+    def notify(action, library)
+      changed
+      notify_observers(self, action, library)
+    end
+  end
+end

data/lib/alexandria/library_sort_order.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
+#
+# See the file README.md for authorship and licensing information.
+
+module Alexandria
+  class LibrarySortOrder
+    include Logging
+
+    def initialize(book_attribute, ascending = true)
+      @book_attribute = book_attribute
+      @ascending = ascending
+    end
+
+    def sort(library)
+      sorted = library.sort_by do |book|
+        book.send(@book_attribute)
+      end
+      sorted.reverse! unless @ascending
+      sorted
+    rescue StandardError => ex
+      log.warn { "Could not sort library by #{@book_attribute.inspect}: #{ex.message}" }
+      library
+    end
+
+    def to_s
+      "#{@book_attribute} #{@ascending ? '(ascending)' : '(descending)'}"
+    end
+
+    class Unsorted < LibrarySortOrder
+      def initialize; end
+
+      def sort(library)
+        library
+      end
+
+      def to_s
+        'default order'
+      end
+    end
+  end
+end

data/lib/alexandria/library_store.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
+#
+# See the file README.md for authorship and licensing information.
+
+module Alexandria
+  class LibraryStore
+    include Logging
+
+    FIX_BIGNUM_REGEX =
+      /loaned_since:\s*(\!ruby\/object\:Bignum\s*)?(\d+)\n/.freeze
+
+    include GetText
+    bindtextdomain(Alexandria::TEXTDOMAIN, charset: 'UTF-8')
+
+    def initialize(dir)
+      @dir = dir
+    end
+
+    def load_all_libraries
+      a = []
+      begin
+        Dir.entries(library_dir).each do |file|
+          # Skip hidden files.
+          next if file =~ /^\./
+          # Skip non-directory files.
+          next unless File.stat(File.join(library_dir, file)).directory?
+
+          a << load_library(file)
+        end
+      rescue Errno::ENOENT
+        FileUtils.mkdir_p(library_dir)
+      end
+      # Create the default library if there is no library yet.
+
+      a << load_library(_('My Library')) if a.empty?
+
+      a
+    end
+
+    def load_library(name)
+      test = [0, nil]
+      ruined_books = []
+      library = Library.new(name, self)
+      FileUtils.mkdir_p(library.path) unless File.exist?(library.path)
+      Dir.chdir(library.path) do
+        Dir['*' + Library::EXT[:book]].each do |filename|
+          test[1] = filename if (test[0]).zero?
+
+          unless File.size? test[1]
+            log.warn { "Book file #{test[1]} was empty" }
+            md = /([\dxX]{10,13})#{Library::EXT[:book]}/.match(filename)
+            if md
+              file_isbn = md[1]
+              ruined_books << [nil, file_isbn, library]
+            else
+              log.warn { "Filename #{filename} does not contain an ISBN" }
+              # TODO: delete this file...
+            end
+            next
+          end
+          book = regularize_book_from_yaml(test[1])
+          old_isbn = book.isbn
+          old_pub_year = book.publishing_year
+          begin
+            raise "Not a book: #{book.inspect}" unless book.is_a?(Book)
+
+            ean = Library.canonicalise_ean(book.isbn)
+            book.isbn = ean if ean
+
+            book.publishing_year = book.publishing_year.to_i unless book.publishing_year.nil?
+
+            # Or if isbn has changed
+            raise "#{test[1]} isbn is not okay" unless book.isbn == old_isbn
+
+            # Re-save book if Alexandria::DATA_VERSION changes
+            raise "#{test[1]} version is not okay" unless book.version == Alexandria::DATA_VERSION
+
+            # Or if publishing year has changed
+            raise "#{test[1]} pub year is not okay" unless book.publishing_year == old_pub_year
+
+            # ruined_books << [book, book.isbn, library]
+            book.library = library.name
+
+            ## TODO copy cover image file, if necessary
+            # due to #26909 cover files for books without ISBN are re-saved as "g#{ident}.cover"
+            if book.isbn.nil? || book.isbn.empty?
+              if File.exist? library.old_cover(book)
+                log.debug { "#{library.name}; book #{book.title} has no ISBN, fixing cover image" }
+                FileUtils::Verbose.mv(library.old_cover(book), library.cover(book))
+              end
+            end
+
+            library << book
+          rescue StandardError
+            book.version = Alexandria::DATA_VERSION
+            savedfilename = library.simple_save(book)
+            test[0] = test[0] + 1
+            test[1] = savedfilename
+
+            # retries the Dir.each block...
+            # but gives up after three tries
+            redo unless test[0] > 2
+          else
+            test = [0, nil]
+          end
+        end
+
+        # Since 0.4.0 the cover files '_small.jpg' and
+        # '_medium.jpg' have been deprecated for a single medium
+        # cover file named '.cover'.
+
+        Dir['*' + '_medium.jpg'].each do |medium_cover|
+          FileUtils.mv(medium_cover,
+                       medium_cover.sub(/_medium\.jpg$/,
+                                        Library::EXT[:cover]))
+        end
+
+        Dir['*' + Library::EXT[:cover]].each do |cover|
+          next if cover[0] == 'g'
+
+          md = /(.+)\.cover/.match(cover)
+          ean = Library.canonicalise_ean(md[1]) || md[1]
+          FileUtils.mv(cover, ean + Library::EXT[:cover]) unless cover == ean + Library::EXT[:cover]
+        end
+
+        FileUtils.rm_f(Dir['*_small.jpg'])
+      end
+      library.ruined_books = ruined_books
+
+      library
+    end
+
+    def load_all_smart_libraries
+      a = []
+      begin
+        # Deserialize smart libraries.
+        Dir.chdir(smart_library_dir) do
+          Dir['*' + SmartLibrary::EXT].each do |filename|
+            # Skip non-regular files.
+            next unless File.stat(filename).file?
+
+            text = IO.read(filename)
+            hash = YAML.safe_load(text, permitted_classes: [Symbol])
+            smart_library = SmartLibrary.from_hash(hash, self)
+            a << smart_library
+          end
+        end
+      rescue Errno::ENOENT
+        # First run and no smart libraries yet? Provide some default
+        # ones.
+        SmartLibrary.sample_smart_libraries(self).each do |smart_library|
+          smart_library.save
+          a << smart_library
+        end
+      end
+      a.each(&:refilter)
+      a
+    end
+
+    def library_dir
+      @dir
+    end
+
+    def smart_library_dir
+      File.join(@dir, '.smart_libraries')
+    end
+
+    private
+
+    def regularize_book_from_yaml(name)
+      text = IO.read(name)
+
+      # Code to remove the mystery string in books imported from Amazon
+      # (In the past, still?) To allow ruby-amazon to be removed.
+
+      # The string is removed on load, but can't make it stick, maybe has to do with cache
+
+      if text =~ /!str:Amazon::Search::Response/
+        log.debug { "Removing Ruby/Amazon strings from #{name}" }
+        text.gsub!('!str:Amazon::Search::Response', '')
+      end
+
+      # Backward compatibility with versions <= 0.6.0, where the
+      # loaned_since field was a numeric.
+      if (md = FIX_BIGNUM_REGEX.match(text))
+        new_yaml = Time.at(md[2].to_i).to_yaml
+        # Remove the "---" prefix.
+        new_yaml.sub!(/^\s*\-+\s*/, '')
+        text.sub!(md[0], "loaned_since: #{new_yaml}\n")
+      end
+
+      # TODO: Ensure book loading passes through Book#initialize
+      book = YAML.safe_load(text, permitted_classes: [Book, Time])
+
+      unless book.isbn.class == String
+        # HACK
+        md = /isbn: (.+)/.match(text)
+        if md
+          string_isbn = md[1].strip
+          book.isbn = string_isbn
+        end
+      end
+
+      # another HACK of the same type as above
+      unless book.saved_ident.class == String
+
+        md2 = /saved_ident: (.+)/.match(text)
+        if md2
+          string_saved_ident = md2[1].strip
+          log.debug { "fixing saved_ident #{book.saved_ident} -> #{string_saved_ident}" }
+          book.saved_ident = string_saved_ident
+        end
+      end
+      if (book.isbn.class == String) && book.isbn.empty?
+        book.isbn = nil # save trouble later
+      end
+      book
+    end
+  end
+end