alexandria-book-collection-manager 0.7.4 → 0.7.5

data/lib/alexandria/import_library.rb

@@ -80,80 +80,80 @@ module Alexandria
       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
+        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"
+        collection = xml.root.elements[1]
+        raise unless collection.name == "collection"
 
-          type = collection.attribute("type").value.to_i
-          raise unless (type == 2) || (type == 5)
+        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"]
+        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
-            # 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
+          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
+          # 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
-            book.notes = neaten(elements["comments"].text) if elements["comments"]
-            content << [book, cover]
-            on_iterate_cb&.call(n + 1, total)
           end
+          # publishing_year
+          book_elements[4] = book_elements[4].to_i unless book_elements[4].nil?
+          puts book_elements.inspect
+          cover = (neaten(elements["cover"].text) if elements["cover"])
+          puts 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
+          book.notes = neaten(elements["comments"].text) if elements["comments"]
+          content << [book, cover]
+          on_iterate_cb&.call(n + 1, total)
+        end
 
-          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)
+        library = Library.load(name)
+        content.each do |book, cover|
+          unless cover.nil?
+            library.save_cover(book,
+                               File.join(Dir.pwd, "images",
+                                         cover))
           end
-          return [library, []]
-        rescue StandardError => ex
-          puts ex.message
-          return nil
+          library << book
+          library.save(book)
         end
+        return [library, []]
+      rescue StandardError => ex
+        puts ex.message
+        return nil
       end
     end
 

data/lib/alexandria/library_collection.rb

@@ -24,7 +24,8 @@ module Alexandria
       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
+        # make deleted books from each library accessible so we don't crash on
+        # smart libraries
         deleted += library.deleted_books
       end
       @ruined_books = ruined

data/lib/alexandria/library_store.rb

@@ -45,7 +45,7 @@ module Alexandria
       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|
+        Dir["*" + Library::EXT[:book]].sort.each do |filename|
           test[1] = filename if (test[0]).zero?
 
           unless File.size? test[1]
@@ -69,25 +69,34 @@ module Alexandria
             ean = Library.canonicalise_ean(book.isbn)
             book.isbn = ean if ean
 
-            book.publishing_year = book.publishing_year.to_i unless book.publishing_year.nil?
+            unless book.publishing_year.nil?
+              book.publishing_year = book.publishing_year.to_i
+            end
 
             # 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
+            unless book.version == Alexandria::DATA_VERSION
+              raise "#{test[1]} version is not okay"
+            end
 
             # Or if publishing year has changed
-            raise "#{test[1]} pub year is not okay" unless book.publishing_year == old_pub_year
+            unless book.publishing_year == old_pub_year
+              raise "#{test[1]} pub year is not okay"
+            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"
+            # 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" }
+                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
             end
@@ -122,7 +131,9 @@ module Alexandria
 
           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]
+          unless cover == ean + Library::EXT[:cover]
+            FileUtils.mv(cover, ean + Library::EXT[:cover])
+          end
         end
 
         FileUtils.rm_f(Dir["*_small.jpg"])

data/lib/alexandria/models/book.rb

@@ -8,7 +8,8 @@ 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
 

data/lib/alexandria/models/library.rb

@@ -53,7 +53,9 @@ module Alexandria
       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)
@@ -181,7 +183,9 @@ module Alexandria
       book.saved_ident = book.ident if book.saved_ident.nil? || book.saved_ident.empty?
       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
       end
       book.saved_ident = book.ident
 
@@ -199,7 +203,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.

data/lib/alexandria/preferences.rb

@@ -48,7 +48,10 @@ module Alexandria
     def save!
       log.debug { "preferences save!" }
       @changed_settings.each do |variable_name|
-        log.debug { "saving preference #{variable_name} / #{@alexandria_settings[variable_name].class}" }
+        log.debug do
+          klass = @alexandria_settings[variable_name].class
+          "saving preference #{variable_name} / #{klass}"
+        end
         generic_save_setting(variable_name, @alexandria_settings[variable_name])
       end
       @changed_settings.clear
@@ -125,7 +128,9 @@ module Alexandria
       end
     rescue StandardError => ex
       log.debug { new_value.inspect }
-      log.error { "Could not set GConf setting #{variable_name} to value: #{new_value.inspect}" }
+      log.error do
+        "Could not set GConf setting #{variable_name} to value: #{new_value.inspect}"
+      end
       log << ex.message
       log << ex
     end
@@ -177,7 +182,7 @@ module Alexandria
       type = get_gconf_type(new_value)
       value_str = new_value
       if new_value.is_a? String
-        new_value.gsub!(/\"/, '\\"')
+        new_value = new_value.gsub(/\"/, '\\"')
         value_str = "\"#{new_value}\""
       end
       puts value_str if /cols_width/.match?(var_path)
@@ -226,7 +231,9 @@ module Alexandria
       hash = {}
       vals = all_vals.split(/$/)
       vals.each do |val|
-        hash[Regexp.last_match[1]] = discriminate(Regexp.last_match[2]) if /([a-z_]+) = (.*)/ =~ val
+        if /([a-z_]+) = (.*)/ =~ val
+          hash[Regexp.last_match[1]] = discriminate(Regexp.last_match[2])
+        end
       end
       hash
     end
@@ -246,9 +253,9 @@ module Alexandria
       elsif value =~ /^\((.*)\)$/ # pair (assume of type int)
         begin
           pair = Regexp.last_match[1].split(",")
-          return [discriminate(pair.first), discriminate(pair.last)]
+          [discriminate(pair.first), discriminate(pair.last)]
         rescue StandardError
-          return [0, 0]
+          [0, 0]
         end
       else
         value # string

data/lib/alexandria/scanners/keyboard.rb

@@ -44,9 +44,9 @@ module Alexandria
       def decode(data)
         data.gsub!(/\s/, "")
         if data.length == 10
-          return data
+          data
         elsif data.length >= 13
-          return data[0, 13]
+          data[0, 13]
         else
           raise "Unknown scan data #{data}"
         end

data/lib/alexandria/smart_library.rb

@@ -359,45 +359,47 @@ module Alexandria
         IS_BEFORE = Operator.new(:is_before,
                                  _("is before"),
                                  proc { |x, y| x.to_i < y.to_i && !x.nil? })
-        IS_IN_LAST = Operator.new(:is_in_last_days,
-                                  _("is in last"),
-                                  proc { |x, y|
-                                    begin
-                                      if x.nil? || x.empty?
-                                        false
-                                      else
-                                        log.debug { "Given Date: #{x.inspect} #{x.class}" }
-                                        given_date = Time.parse(x)
-                                        days = y.to_i * (24 * 60 * 60)
-
-                                        Time.now - given_date <= days
-                                      end
-                                    rescue StandardError => ex
-                                      trace = ex.backtrace.join("\n >")
-                                      log.warn { "Date matching failed #{ex} #{trace}" }
-                                      false
-                                    end
-                                  })
-        IS_NOT_IN_LAST = Operator.new(:is_not_in_last_days,
-                                      _("is not in last"),
-                                      proc { |x, y|
-                                        begin
-                                          if x.nil? || x.empty?
-                                            false
-                                          else
-                                            log.debug { "Given Date: #{x.inspect} #{x.class}" }
-                                            given_date = Time.parse(x)
-                                            days = y.to_i * (24 * 60 * 60)
-
-                                            Time.now - given_date > days
-                                          end
-                                        rescue StandardError => ex
-                                          trace = ex.backtrace.join("\n >")
-                                          log.warn { "Date matching failed #{ex} #{trace}" }
-                                          false
-                                        end
-                                        # Time.now - x > 3600*24*y
-                                      })
+        IS_IN_LAST =
+          Operator.new(:is_in_last_days,
+                       _("is in last"),
+                       proc { |x, y|
+                         begin
+                           if x.nil? || x.empty?
+                             false
+                           else
+                             log.debug { "Given Date: #{x.inspect} #{x.class}" }
+                             given_date = Time.parse(x)
+                             days = y.to_i * (24 * 60 * 60)
+
+                             Time.now - given_date <= days
+                           end
+                         rescue StandardError => ex
+                           trace = ex.backtrace.join("\n >")
+                           log.warn { "Date matching failed #{ex} #{trace}" }
+                           false
+                         end
+                       })
+        IS_NOT_IN_LAST =
+          Operator.new(:is_not_in_last_days,
+                       _("is not in last"),
+                       proc { |x, y|
+                         begin
+                           if x.nil? || x.empty?
+                             false
+                           else
+                             log.debug { "Given Date: #{x.inspect} #{x.class}" }
+                             given_date = Time.parse(x)
+                             days = y.to_i * (24 * 60 * 60)
+
+                             Time.now - given_date > days
+                           end
+                         rescue StandardError => ex
+                           trace = ex.backtrace.join("\n >")
+                           log.warn { "Date matching failed #{ex} #{trace}" }
+                           false
+                         end
+                         # Time.now - x > 3600*24*y
+                       })
 
         ALL = constants.map \
           { |x| module_eval(x.to_s) }.select \

data/lib/alexandria/ui/acquire_dialog.rb

@@ -329,67 +329,63 @@ module Alexandria
 
       def lookup_book(isbn)
         Thread.new do
-          begin
-            start_search
-            results = Alexandria::BookProviders.isbn_search(isbn)
-            book = results[0]
-            cover_uri = results[1]
-            @book_results[isbn] = results
-            set_cover_image_async(isbn, cover_uri)
-
-            @barcodes_treeview.model.freeze_notify do
-              @barcodes_treeview.model.each do |model, path, iter|
-                if iter[0] == isbn
-                  iter[2] = book.title
-                  model.row_changed(path, iter)
-                end
+          start_search
+          results = Alexandria::BookProviders.isbn_search(isbn)
+          book = results[0]
+          cover_uri = results[1]
+          @book_results[isbn] = results
+          set_cover_image_async(isbn, cover_uri)
+
+          @barcodes_treeview.model.freeze_notify do
+            @barcodes_treeview.model.each do |model, path, iter|
+              if iter[0] == isbn
+                iter[2] = book.title
+                model.row_changed(path, iter)
               end
             end
-
-            @add_button.sensitive = true
-          rescue StandardError => ex
-            log.error { "Book Search failed: #{ex.message}" }
-            log << ex if log.error?
-          ensure
-            stop_search
           end
+
+          @add_button.sensitive = true
+        rescue StandardError => ex
+          log.error { "Book Search failed: #{ex.message}" }
+          log << ex if log.error?
+        ensure
+          stop_search
         end
       end
 
       def set_cover_image_async(isbn, cover_uri)
         Thread.new do
-          begin
-            pixbuf = nil
-            if cover_uri
-              image_data = nil
-              if URI.parse(cover_uri).scheme.nil?
-                File.open(cover_uri, "r") do |io|
-                  image_data = io.read
-                end
-              else
-                image_data = URI.parse(cover_uri).read
+          pixbuf = nil
+          if cover_uri
+            image_data = nil
+            if URI.parse(cover_uri).scheme.nil?
+              File.open(cover_uri, "r") do |io|
+                image_data = io.read
               end
-              loader = GdkPixbuf::PixbufLoader.new
-              loader.last_write(image_data)
-              pixbuf = loader.pixbuf
             else
-              pixbuf = Icons::BOOK
+              image_data = URI.parse(cover_uri).read
             end
+            loader = GdkPixbuf::PixbufLoader.new
+            loader.last_write(image_data)
+            pixbuf = loader.pixbuf
+          else
+            pixbuf = Icons::BOOK
+          end
 
-            @barcodes_treeview.model.freeze_notify do
-              @barcodes_treeview.model.each do |model, path, iter|
-                if iter[0] == isbn
-                  iter[1] = pixbuf
-                  model.row_changed(path, iter)
-                end
+          @barcodes_treeview.model.freeze_notify do
+            @barcodes_treeview.model.each do |model, path, iter|
+              if iter[0] == isbn
+                iter[1] = pixbuf
+                model.row_changed(path, iter)
               end
             end
-          rescue StandardError => ex
-            log.error do
-              "Failed to load cover image icon: #{ex.message}"
-            end
-            log << ex if log.error?
           end
+        rescue StandardError => ex
+          log.error do
+            "Failed to load cover image icon: #{ex.message}"
+          end
+          log << ex if log.error?
         end
       end
 
@@ -422,7 +418,8 @@ module Alexandria
           @scan_area.grab_focus
         end
         @scan_area.signal_connect("focus-in-event") do |_widget, _event|
-          @barcode_label.label = _(format("%s _Barcode Scanner Ready", _(@scanner.display_name)))
+          @barcode_label.label =
+            _(format("%s _Barcode Scanner Ready", _(@scanner.display_name)))
           @scanner_buffer = ""
           begin
             @animation.set_active
@@ -494,7 +491,9 @@ module Alexandria
                   @interval = 0
 
                 else
-                  log.debug { "Buffer has changed while waiting, reading more characters..." }
+                  log.debug do
+                    "Buffer has changed while waiting, reading more characters..."
+                  end
                 end
               end