alexandria-book-collection-manager 0.7.2 → 0.7.7

data/lib/alexandria/models/library.rb

@@ -1,31 +1,15 @@
 # frozen_string_literal: true
 
-# Copyright (C) 2004-2006 Laurent Sansonetti
-# Copyright (C) 2014 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.
-
-require 'yaml'
-require 'fileutils'
-require 'rexml/document'
-require 'tempfile'
-require 'etc'
-require 'open-uri'
-require 'observer'
-require 'singleton'
+# See the file README.md for authorship and licensing information.
+
+require "yaml"
+require "fileutils"
+require "rexml/document"
+require "tempfile"
+require "etc"
+require "alexandria/library_store"
 
 module Alexandria
   class Library < Array
@@ -33,18 +17,19 @@ module Alexandria
 
     attr_reader :name
     attr_accessor :ruined_books, :updating, :deleted_books
-    DIR = File.join(ENV['HOME'], '.alexandria')
-    EXT = { book: '.yaml', cover: '.cover' }.freeze
+
+    DEFAULT_DIR = File.join(ENV["HOME"], ".alexandria")
+    EXT = { book: ".yaml", cover: ".cover" }.freeze
 
     include GetText
     extend GetText
-    bindtextdomain(Alexandria::TEXTDOMAIN, charset: 'UTF-8')
+    bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
     BOOK_ADDED, BOOK_UPDATED, BOOK_REMOVED = (0..3).to_a
     include Observable
 
     def path
-      File.join(DIR, @name)
+      File.join(@store.library_dir, @name)
     end
 
     def updating?
@@ -52,201 +37,26 @@ module Alexandria
     end
 
     def self.generate_new_name(existing_libraries,
-                               from_base = _('Untitled'))
+                               from_base = _("Untitled"))
       i = 1
       name = nil
       all_libraries = existing_libraries + @@deleted_libraries
       loop do
         name = i == 1 ? from_base : from_base + " #{i}"
         break unless all_libraries.find { |x| x.name == name }
+
         i += 1
       end
       name
     end
 
-    FIX_BIGNUM_REGEX =
-      /loaned_since:\s*(\!ruby\/object\:Bignum\s*)?(\d+)\n/
-
-    def self.load(name)
-      test = [0, nil]
-      ruined_books = []
-      library = Library.new(name)
-      FileUtils.mkdir_p(library.path) unless File.exist?(library.path)
-      Dir.chdir(library.path) do
-        Dir['*' + 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})#{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
-            begin
-              book.isbn = canonicalise_ean(book.isbn).to_s unless book.isbn.nil?
-              raise "Not a book: #{book.inspect}" unless book.is_a?(Book)
-            rescue InvalidISBNError
-              book.isbn = old_isbn
-            end
-
-            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
-            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|
-          begin
-            FileUtils.mv(medium_cover,
-                         medium_cover.sub(/_medium\.jpg$/,
-                                          EXT[:cover]))
-          rescue
-          end
-        end
-
-        Dir['*' + EXT[:cover]].each do |cover|
-          next if cover[0] == 'g'
-          md = /(.+)\.cover/.match(cover)
-          begin
-            ean = canonicalise_ean(md[1])
-          rescue
-            ean = md[1]
-          end
-          begin
-            FileUtils.mv(cover, ean + EXT[:cover]) unless cover == ean + EXT[:cover]
-          rescue
-          end
-        end
-
-        FileUtils.rm_f(Dir['*_small.jpg'])
-      end
-      library.ruined_books = ruined_books
-
-      library
-    end
-
-    def self.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, whitelist_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
-
-    def self.loadall
-      a = []
-      begin
-        Dir.entries(DIR).each do |file|
-          # Skip hidden files.
-          next if file =~ /^\./
-          # Skip non-directory files.
-          next unless File.stat(File.join(DIR, file)).directory?
-
-          a << load(file)
-        end
-      rescue Errno::ENOENT
-        FileUtils.mkdir_p(DIR)
-      end
-      # Create the default library if there is no library yet.
-
-      a << load(_('My Library')) if a.empty?
-
-      a
-    end
-
     def self.move(source_library, dest_library, *books)
       dest = dest_library.path
       books.each do |book|
         FileUtils.mv(source_library.yaml(book), dest)
-        FileUtils.mv(source_library.cover(book), dest) if File.exist?(source_library.cover(book))
+        if File.exist?(source_library.cover(book))
+          FileUtils.mv(source_library.cover(book), dest)
+        end
 
         source_library.changed
         source_library.old_delete(book)
@@ -261,23 +71,14 @@ module Alexandria
       end
     end
 
-    class NoISBNError < StandardError
-    end
-
-    class InvalidISBNError < StandardError
-      attr_reader :isbn
-      def initialize(isbn = nil)
-        super()
-        @isbn = isbn
-      end
-    end
+    def self.extract_numbers(entry)
+      return [] if entry.nil? || entry.empty?
 
-    def self.extract_numbers(isbn)
-      raise NoISBNError, 'Nil ISBN' if isbn.nil? || isbn.empty?
+      normalized = entry.delete("- ").upcase
+      return [] unless /\A[\dX]*\Z/.match?(normalized)
 
-      isbn.delete('- ').upcase.split('').map do |x|
-        raise InvalidISBNError, isbn unless x =~ /[\dX]/
-        x == 'X' ? 10 : x.to_i
+      normalized.split("").map do |char|
+        char == "X" ? 10 : char.to_i
       end
     end
 
@@ -286,19 +87,17 @@ module Alexandria
         accumulator + numbers[i] * (i + 1)
       end % 11
 
-      sum == 10 ? 'X' : sum
+      sum == 10 ? "X" : sum
     end
 
     def self.valid_isbn?(isbn)
       numbers = extract_numbers(isbn)
       (numbers.length == 10) && isbn_checksum(numbers).zero?
-    rescue InvalidISBNError
-      false
     end
 
     def self.ean_checksum(numbers)
-      -(numbers.values_at(1, 3, 5, 7, 9, 11).reduce(:+) * 3 +
-        numbers.values_at(0, 2, 4, 6, 8, 10).reduce(:+)) % 10
+      -(numbers.values_at(1, 3, 5, 7, 9, 11).sum * 3 +
+        numbers.values_at(0, 2, 4, 6, 8, 10).sum) % 10
     end
 
     def self.valid_ean?(ean)
@@ -307,36 +106,32 @@ module Alexandria
        (ean_checksum(numbers[0..11]) == numbers[12])) ||
         ((numbers.length == 18) &&
          (ean_checksum(numbers[0..11]) == numbers[12]))
-    rescue InvalidISBNError
-      false
     end
 
     def self.upc_checksum(numbers)
-      -(numbers.values_at(0, 2, 4, 6, 8, 10).reduce(:+) * 3 +
-        numbers.values_at(1, 3, 5, 7, 9).reduce(:+)) % 10
+      -(numbers.values_at(0, 2, 4, 6, 8, 10).sum * 3 +
+        numbers.values_at(1, 3, 5, 7, 9).sum) % 10
     end
 
     def self.valid_upc?(upc)
       numbers = extract_numbers(upc)
       ((numbers.length == 17) &&
        (upc_checksum(numbers[0..10]) == numbers[11]))
-    rescue InvalidISBNError
-      false
     end
 
     AMERICAN_UPC_LOOKUP = {
-      '014794' => '08041', '018926' => '0445', '02778' => '0449',
-      '037145' => '0812', '042799' => '0785',  '043144' => '0688',
-      '044903' => '0312', '045863' => '0517', '046594' => '0064',
-      '047132' => '0152', '051487' => '08167', '051488' => '0140',
-      '060771' => '0002', '065373' => '0373', '070992' => '0523',
-      '070993' => '0446', '070999' => '0345', '071001' => '0380',
-      '071009' => '0440', '071125' => '088677', '071136' => '0451',
-      '071149' => '0451', '071152' => '0515', '071162' => '0451',
-      '071268' => '08217', '071831' => '0425', '071842' => '08439',
-      '072742' => '0441', '076714' => '0671', '076783' => '0553',
-      '076814' => '0449', '078021' => '0872', '079808' => '0394',
-      '090129' => '0679', '099455' => '0061', '099769' => '0451'
+      "014794" => "08041", "018926" => "0445", "02778" => "0449",
+      "037145" => "0812", "042799" => "0785",  "043144" => "0688",
+      "044903" => "0312", "045863" => "0517", "046594" => "0064",
+      "047132" => "0152", "051487" => "08167", "051488" => "0140",
+      "060771" => "0002", "065373" => "0373", "070992" => "0523",
+      "070993" => "0446", "070999" => "0345", "071001" => "0380",
+      "071009" => "0440", "071125" => "088677", "071136" => "0451",
+      "071149" => "0451", "071152" => "0515", "071162" => "0451",
+      "071268" => "08217", "071831" => "0425", "071842" => "08439",
+      "072742" => "0441", "076714" => "0671", "076783" => "0553",
+      "076814" => "0449", "078021" => "0872", "079808" => "0394",
+      "090129" => "0679", "099455" => "0061", "099769" => "0451"
     }.freeze
 
     def self.upc_convert(upc)
@@ -345,25 +140,23 @@ module Alexandria
     end
 
     def self.canonicalise_ean(code)
-      code = code.to_s.delete('- ')
+      code = code.to_s.delete("- ")
       if valid_ean?(code)
-        return code
+        code
       elsif valid_isbn?(code)
-        code = '978' + code[0..8]
-        return code + String(ean_checksum(extract_numbers(code)))
+        code = "978" + code[0..8]
+        code + String(ean_checksum(extract_numbers(code)))
       elsif valid_upc?(code)
         isbn10 = canonicalise_isbn
-        code = '978' + isbn10[0..8]
-        return code + String(ean_checksum(extract_numbers(code)))
-        ## raise "fix function Alexandria::Library.canonicalise_ean"
-      else
-        raise InvalidISBNError, code
+        code = "978" + isbn10[0..8]
+        code + String(ean_checksum(extract_numbers(code)))
       end
     end
 
     def self.canonicalise_isbn(isbn)
       numbers = extract_numbers(isbn)
       return isbn if valid_ean?(isbn) && (numbers[0..2] != [9, 7, 8])
+
       canonical = if valid_ean?(isbn)
                     # Looks like an EAN number -- extract the intersting part and
                     # calculate a checksum. It would be nice if we could validate
@@ -377,10 +170,10 @@ module Alexandria
                   elsif valid_isbn?(isbn)
                     # Seems to be a valid ISBN number.
                     numbers[0..-2] + [isbn_checksum(numbers[0..-2])]
-                  else
-                    raise InvalidISBNError, isbn
                   end
 
+      return unless canonical
+
       canonical.map(&:to_s).join
     end
 
@@ -390,19 +183,15 @@ module Alexandria
       # book.saved_ident ||= book.ident
       book.saved_ident = book.ident if book.saved_ident.nil? || book.saved_ident.empty?
       if book.ident != book.saved_ident
-        # log.debug { "Backwards compatibility step: #{book.saved_ident.inspect}, #{book.ident.inspect}" }
         FileUtils.rm(yaml(book.saved_ident))
-      end
-      if File.exist?(cover(book.saved_ident))
-        begin
+        if File.exist?(cover(book.saved_ident))
           FileUtils.mv(cover(book.saved_ident), cover(book.ident))
-        rescue
         end
       end
       book.saved_ident = book.ident
 
-      filename = book.saved_ident.to_s + '.yaml'
-      File.open(filename, 'w') { |io| io.puts book.to_yaml }
+      filename = book.saved_ident.to_s + ".yaml"
+      File.open(filename, "w") { |io| io.puts book.to_yaml }
       filename
     end
 
@@ -415,7 +204,9 @@ module Alexandria
 
       if book.ident != book.saved_ident
         FileUtils.rm(yaml(book.saved_ident))
-        FileUtils.mv(cover(book.saved_ident), cover(book.ident)) if File.exist?(cover(book.saved_ident))
+        if File.exist?(cover(book.saved_ident))
+          FileUtils.mv(cover(book.saved_ident), cover(book.ident))
+        end
 
         # Notify before updating the saved identifier, so the views
         # can still use the old one to update their models.
@@ -428,14 +219,14 @@ module Alexandria
 
       temp_book = book.dup
       temp_book.library = nil
-      File.open(yaml(temp_book), 'w') { |io| io.puts temp_book.to_yaml }
+      File.open(yaml(temp_book), "w") { |io| io.puts temp_book.to_yaml }
 
       # Do not notify twice.
-      if changed?
-        notify_observers(self,
-                         already_there ? BOOK_UPDATED : BOOK_ADDED,
-                         book)
-      end
+      return unless changed?
+
+      notify_observers(self,
+                       already_there ? BOOK_UPDATED : BOOK_ADDED,
+                       book)
     end
 
     def transport
@@ -447,7 +238,7 @@ module Alexandria
       Dir.chdir(path) do
         # Fetch the cover picture.
         cover_file = cover(book)
-        File.open(cover_file, 'w') do |io|
+        File.open(cover_file, "w") do |io|
           uri = URI.parse(cover_uri)
           if uri.scheme.nil?
             # Regular filename.
@@ -488,11 +279,15 @@ module Alexandria
       if book.nil?
         # Delete the whole library.
         raise if @@deleted_libraries.include?(self)
+
         @@deleted_libraries << self
       else
         if @deleted_books.include?(book)
           doubles = @deleted_books.select { |b| b.equal?(book) }
-          raise ArgumentError, "Book #{book.isbn} was already deleted" unless doubles.empty?
+          unless doubles.empty?
+            raise ArgumentError, format(_("Book %<isbn>s was already deleted"),
+                                        isbn: book.isbn)
+          end
         end
         @deleted_books << book
         i = index(book)
@@ -515,9 +310,11 @@ module Alexandria
       if book.nil?
         # Undelete the whole library.
         raise unless @@deleted_libraries.include?(self)
+
         @@deleted_libraries.delete(self)
       else
         raise unless @deleted_books.include?(book)
+
         @deleted_books.delete(book)
         unless include?(book)
           changed
@@ -553,7 +350,7 @@ module Alexandria
               when Integer
                 something
               else
-                raise "#{something} is a #{something.class}"
+                raise NotImplementedError
               end
       File.join(path, ident.to_s + EXT[:cover])
     end
@@ -567,13 +364,13 @@ module Alexandria
               when Integer
                 something
               else
-                raise "#{something} is #{something.class}"
+                raise NotImplementedError
               end
       File.join(basedir, ident.to_s + EXT[:book])
     end
 
     def name=(name)
-      File.rename(path, File.join(DIR, name))
+      File.rename(path, File.join(dir, name))
       @name = name
     end
 
@@ -585,8 +382,8 @@ module Alexandria
       length - n_rated
     end
 
-    def ==(object)
-      object.is_a?(self.class) && object.name == name
+    def ==(other)
+      other.is_a?(self.class) && other.name == name
     end
 
     def copy_covers(somewhere)
@@ -594,96 +391,27 @@ module Alexandria
       FileUtils.mkdir(somewhere)
       each do |book|
         next unless File.exist?(cover(book))
+
         FileUtils.cp(cover(book),
                      File.join(somewhere, final_cover(book)))
       end
     end
 
     def self.jpeg?(file)
-      IO.read(file, 10)[6..9] == 'JFIF'
+      IO.read(file, 10)[6..9] == "JFIF"
     end
 
     def final_cover(book)
       # TODO: what about PNG?
-      book.ident + (Library.jpeg?(cover(book)) ? '.jpg' : '.gif')
+      book.ident + (Library.jpeg?(cover(book)) ? ".jpg" : ".gif")
     end
 
     protected
 
-    def initialize(name)
+    def initialize(name, store = nil)
       @name = name
+      @store = store
       @deleted_books = []
     end
   end
-
-  class Libraries
-    attr_reader :all_libraries, :ruined_books, :deleted_books
-
-    include Observable
-    include Singleton
-
-    def reload
-      @all_libraries.clear
-      @all_libraries.concat(Library.loadall)
-      @all_libraries.concat(SmartLibrary.loadall)
-
-      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
-
-    # def all_dynamic_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