alexandria-book-collection-manager 0.7.1 → 0.7.6

data/lib/alexandria/library_collection.rb

@@ -0,0 +1,79 @@
+# 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 do |library|
+        ruined += library.ruined_books
+        # make deleted books from each library accessible so we don't crash on
+        # smart libraries
+        deleted += library.deleted_books
+      end
+      @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,45 @@
+# 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
+        super(nil, nil)
+      end
+
+      def sort(library)
+        library
+      end
+
+      def to_s
+        "default order"
+      end
+    end
+  end
+end

data/lib/alexandria/library_store.rb

@@ -0,0 +1,233 @@
+# 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 =
+      %r{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.start_with?(".")
+          # 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]].sort.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 format(_("Not a book: %<book>s"), book.inspect) unless book.is_a?(Book)
+
+            ean = Library.canonicalise_ean(book.isbn)
+            book.isbn = ean if ean
+
+            unless book.publishing_year.nil?
+              book.publishing_year = book.publishing_year.to_i
+            end
+
+            # Or if isbn has changed
+            unless book.isbn == old_isbn
+              raise format(_("%<file>s isbn is not okay"), file: test[1])
+            end
+
+            # Re-save book if Alexandria::DATA_VERSION changes
+            unless book.version == Alexandria::DATA_VERSION
+              raise format(_("%<file>s version is not okay"), file: test[1])
+            end
+
+            # Or if publishing year has changed
+            unless book.publishing_year == old_pub_year
+              raise format(_("%<file>s pub year is not okay"), file: test[1])
+            end
+
+            # 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?) && File.exist?(library.old_cover(book))
+              log.debug do
+                "#{library.name}; book #{book.title} has no ISBN, fixing cover image"
+              end
+              FileUtils::Verbose.mv(library.old_cover(book), library.cover(book))
+            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]
+          unless cover == ean + Library::EXT[:cover]
+            FileUtils.mv(cover, ean + Library::EXT[:cover])
+          end
+        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 /!str:Amazon::Search::Response/.match?(text)
+        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.instance_of? 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.instance_of? 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.instance_of? String) && book.isbn.empty?
+        book.isbn = nil # save trouble later
+      end
+      book
+    end
+  end
+end

data/lib/alexandria/logging.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (C) 2007 Cathal Mc Ginley
 # Copyright (C) 2011 Matijs van Zuijlen
 #
@@ -16,23 +18,21 @@
 # write to the Free Software Foundation, Inc., 51 Franklin Street,
 # Fifth Floor, Boston, MA 02110-1301 USA.
 
-require 'logger'
-require 'forwardable'
+require "logger"
+require "forwardable"
 
 module Alexandria
   # A Logger subclass which accepts a source for log messages
   # in order to improve legibility of the logs.
   # The source should usually be +self+, whether that be a Class, Module
-  # or Object. A LoggerWrapper can be used to simplify this procedure.
+  # or Object. A LogWrapper can be used to simplify this procedure.
   class Logger < ::Logger
     def add(severity, message = nil, source = nil, progname = nil, &block)
-      if source.nil?
-        return super(severity, message, progname, &block)
-      end
+      return super(severity, message, progname, &block) if source.nil?
+
       category = self.class.category(source)
-      unless block_given?
-        return super(severity, progname, category)
-      end
+      return super(severity, progname, category) unless block_given?
+
       category = "#{category} #{progname}" if progname
       super(severity, message, category, &block)
     end
@@ -82,9 +82,9 @@ module Alexandria
 
     def <<(msg)
       if msg.respond_to? :backtrace
-        msg.backtrace.each { |line|
+        msg.backtrace.each do |line|
           @logger << "  #{line} \n"
-        }
+        end
       else
         @logger << msg + "\n"
       end
@@ -118,7 +118,7 @@ module Alexandria
   module Logging
     module ClassMethods
       def log
-        @log_wrapper ||= LogWrapper.new(Alexandria.log, self)
+        @log ||= LogWrapper.new(Alexandria.log, self)
       end
     end
 
@@ -127,17 +127,15 @@ module Alexandria
     end
 
     def log
-      @log_wrapper ||= LogWrapper.new(Alexandria.log, self)
+      @log ||= LogWrapper.new(Alexandria.log, self)
     end
   end
 
-  private
-
   # Creates the Logger for Alexandria
   def self.create_logger
-    logger = Alexandria::Logger.new(STDERR)
+    logger = Alexandria::Logger.new($stderr)
 
-    level = ENV['LOGLEVEL'] ? ENV['LOGLEVEL'].intern : nil
+    level = ENV["LOGLEVEL"] ? ENV["LOGLEVEL"].intern : nil
     if [:FATAL, :ERROR, :WARN, :INFO, :DEBUG].include? level
       logger.level = Logger.const_get(level)
     else
@@ -150,8 +148,6 @@ module Alexandria
 
   @@logger = create_logger
 
-  public
-
   # Returns the Logger for Alexandria
   def self.log
     @@logger

data/lib/alexandria/models/book.rb

@@ -1,31 +1,21 @@
-# Copyright (C) 2004-2006 Laurent Sansonetti
-#
-# 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.
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
 #
-# 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.
 
 module Alexandria
   class Book
     attr_accessor :title, :authors, :isbn, :publisher, :publishing_year,
                   :edition, :notes, :loaned, :loaned_since,
-                  :loaned_to, :saved_ident, :redd, :redd_when, :own, :want, :tags, :version, :library
+                  :loaned_to, :saved_ident, :redd, :redd_when, :own, :want,
+                  :tags, :version, :library
 
     attr_reader :rating
 
     DEFAULT_RATING = 0
     MAX_RATING_STARS = 5
-    VALID_RATINGS = (DEFAULT_RATING..MAX_RATING_STARS)
+    VALID_RATINGS = (DEFAULT_RATING..MAX_RATING_STARS).freeze
 
     def initialize(title, authors, isbn, publisher, publishing_year,
                    edition)
@@ -35,7 +25,7 @@ module Alexandria
       @isbn = isbn
       @publisher = publisher
       @edition = edition # actually used for binding! (i.e. paperback or hardback)
-      @notes = ''
+      @notes = ""
       @saved_ident = ident
       @publishing_year = publishing_year
       @redd = false
@@ -54,6 +44,7 @@ module Alexandria
 
     def rating=(rating)
       raise ArgumentError unless VALID_RATINGS.include? rating
+
       @rating = rating
     end
 
@@ -73,8 +64,12 @@ module Alexandria
       own || false
     end
 
-    def ==(obj)
-      obj.is_a?(self.class) && (ident == obj.ident)
+    def ==(other)
+      other.is_a?(self.class) && (ident == other.ident)
+    end
+
+    def inspect
+      "#<Alexandria::Book title: #{@title}>"
     end
   end
 end