alexandria-book-collection-manager 0.7.10 → 0.7.11

data/lib/alexandria/ui/really_delete_dialog.rb

@@ -10,6 +10,7 @@ module Alexandria
   module UI
     class ReallyDeleteDialog < AlertDialog
       include GetText
+
       GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
       def initialize(parent, library, books = nil)

data/lib/alexandria/ui/sidepane_manager.rb

@@ -11,6 +11,7 @@ module Alexandria
     class SidepaneManager
       include Logging
       include GetText
+
       attr_accessor :library_listview
 
       def initialize(library_listview, parent)
@@ -50,7 +51,7 @@ module Alexandria
 
         if (match = contains_illegal_character(new_text))
           if match.instance_of? MatchData
-            chars = match[1].gsub(/&/, "&")
+            chars = match[1].gsub("&", "&")
             ErrorDialog.new(@main_app, _("Invalid library name '%s'") % new_text,
                             _("The name provided contains the " \
                               "disallowed character <b>%s</b>") % chars).display
@@ -128,71 +129,71 @@ module Alexandria
 
         @library_listview
           .signal_connect("drag-motion") do |_widget, drag_context, x, y, time, _data|
-          log.debug { "drag-motion" }
-
-          path, column, =
-            @library_listview.get_path_at_pos(x, y)
-
-          if path
-            # Refuse drags from/to smart libraries.
-            if @parent.selected_library.is_a?(SmartLibrary)
-              path = nil
-            else
-              iter = @library_listview.model.get_iter(path)
-              if iter[3] # separator?
+            log.debug { "drag-motion" }
+
+            path, column, =
+              @library_listview.get_path_at_pos(x, y)
+
+            if path
+              # Refuse drags from/to smart libraries.
+              if @parent.selected_library.is_a?(SmartLibrary)
                 path = nil
               else
-                library = @libraries.all_libraries.find do |lib|
-                  lib.name == iter[1]
+                iter = @library_listview.model.get_iter(path)
+                if iter[3] # separator?
+                  path = nil
+                else
+                  library = @libraries.all_libraries.find do |lib|
+                    lib.name == iter[1]
+                  end
+                  path = nil if library.is_a?(SmartLibrary)
                 end
-                path = nil if library.is_a?(SmartLibrary)
               end
             end
-          end
 
-          @library_listview.set_drag_dest_row(path, :into_or_after)
+            @library_listview.set_drag_dest_row(path, :into_or_after)
 
-          Gdk.drag_status(drag_context,
-                          path ? drag_context.suggested_action : 0,
-                          time)
+            Gdk.drag_status(drag_context,
+                            path ? drag_context.suggested_action : 0,
+                            time)
         end
 
         @library_listview
           .signal_connect("drag-drop") do |widget, drag_context, _x, _y, time, _data|
-          log.debug { "drag-drop" }
+            log.debug { "drag-drop" }
 
-          widget.drag_get_data(drag_context,
-                               drag_context.targets.first,
-                               time)
-          true
+            widget.drag_get_data(drag_context,
+                                 drag_context.targets.first,
+                                 time)
+            true
         end
 
         @library_listview
           .signal_connect("drag-data-received") do |_, drag_context, x, y, data, _, _|
-          log.debug { "drag-data-received" }
-
-          success = false
-          # FIXME: Ruby-GNOME2 should make comparison work without needing to
-          # call #name.
-          if data.data_type.name == Gdk::Selection::TYPE_STRING.name
-            success, path =
-              @library_listview.get_dest_row_at_pos(x, y)
-
-            if success
-              iter = @library_listview.model.get_iter(path)
-              library = @libraries.all_libraries.find do |lib|
-                lib.name == iter[1]
+            log.debug { "drag-data-received" }
+
+            success = false
+            # FIXME: Ruby-GNOME2 should make comparison work without needing to
+            # call #name.
+            if data.data_type.name == Gdk::Selection::TYPE_STRING.name
+              success, path =
+                @library_listview.get_dest_row_at_pos(x, y)
+
+              if success
+                iter = @library_listview.model.get_iter(path)
+                library = @libraries.all_libraries.find do |lib|
+                  lib.name == iter[1]
+                end
+                @parent.move_selected_books_to_library(library)
+                success = true
               end
-              @parent.move_selected_books_to_library(library)
-              success = true
             end
-          end
-          begin
-            drag_context.finish(success: success, delete: false)
-          rescue StandardError => ex
-            log.error { "drag_context.finish failed: #{ex}" }
-            raise
-          end
+            begin
+              drag_context.finish(success: success, delete: false)
+            rescue StandardError => ex
+              log.error { "drag_context.finish failed: #{ex}" }
+              raise
+            end
         end
       end
     end

data/lib/alexandria/ui/skip_entry_dialog.rb

@@ -11,6 +11,7 @@ module Alexandria
     class SkipEntryDialog < AlertDialog
       include GetText
       include Logging
+
       GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
       def initialize(parent, message)

data/lib/alexandria/ui/smart_library_properties_dialog.rb

@@ -8,6 +8,7 @@ module Alexandria
   module UI
     class SmartLibraryPropertiesDialog < SmartLibraryPropertiesDialogBase
       include GetText
+
       GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
       def initialize(parent, smart_library)

data/lib/alexandria/ui/smart_library_properties_dialog_base.rb

@@ -13,6 +13,7 @@ module Alexandria
       include Logging
       include CalendarPopup
       include GetText
+
       GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
       attr_reader :predicate_operator_rule, :dialog
@@ -77,7 +78,7 @@ module Alexandria
         new_rule.value = nil
       end
 
-      protected
+      private
 
       attr_reader :smart_library_rules
 

data/lib/alexandria/ui/{sound.rb → sound_effects_player.rb}

@@ -28,7 +28,10 @@ module Alexandria
   module UI
     ## Uses Ruby/GStreamer to play Ogg/Vorbis sound effects
     class SoundEffectsPlayer
+      include Logging
+
       def initialize
+        log.info { "Setting up SoundEffectsPlayer" }
         @sounds_dir = Alexandria::Config::SOUNDS_DIR
         @ogg_vorbis_pipeline = Gst::Pipeline.new
         set_up_pipeline

data/lib/alexandria/ui/ui_manager.rb

@@ -11,6 +11,7 @@ require "alexandria/library_sort_order"
 
 module Alexandria
   module UI
+    # rubocop:disable Metrics/ClassLength
     class UIManager < BuilderBase
       attr_accessor :main_app, :actiongroup, :appbar, :prefs, :listview, :iconview,
                     :listview_model, :iconview_model, :filtered_model
@@ -18,6 +19,7 @@ module Alexandria
 
       include Logging
       include GetText
+
       GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
       def initialize(parent)
@@ -237,58 +239,36 @@ module Alexandria
         end
       end
 
+      LIST_STORE_COLUMNS = [
+        GdkPixbuf::Pixbuf,    # COVER_LIST
+        GdkPixbuf::Pixbuf,    # COVER_ICON
+        String,         # TITLE
+        String,         # TITLE_REDUCED
+        String,         # AUTHORS
+        String,         # ISBN
+        String,         # PUBLISHER
+        String,         # PUBLISH_DATE
+        String,         # EDITION
+        Integer,        # RATING
+        String,         # IDENT
+        String,         # NOTES
+        TrueClass,      # REDD
+        TrueClass,      # OWN
+        TrueClass,      # WANT
+        String,         # TAGS
+        String          # LOANED TO
+      ].freeze
+
       def setup_active_model
         log.debug { "setting up active model" }
         # The active model.
 
-        list = [
-          GdkPixbuf::Pixbuf,    # COVER_LIST
-          GdkPixbuf::Pixbuf,    # COVER_ICON
-          String,         # TITLE
-          String,         # TITLE_REDUCED
-          String,         # AUTHORS
-          String,         # ISBN
-          String,         # PUBLISHER
-          String,         # PUBLISH_DATE
-          String,         # EDITION
-          Integer,        # RATING
-          String,         # IDENT
-          String,         # NOTES
-          TrueClass,      # REDD
-          TrueClass,      # OWN
-          TrueClass,      # WANT
-          String,         # TAGS
-          String          # LOANED TO
-        ]
-
-        @model = Gtk::ListStore.new(*list)
+        @model = Gtk::ListStore.new(*LIST_STORE_COLUMNS)
 
         # Filter books according to the search toolbar widgets.
         @filtered_model = Gtk::TreeModelFilter.new(@model)
         @filtered_model.set_visible_func do |_model, iter|
-          # log.debug { "visible_func" }
-          @filter_books_mode ||= 0
-          filter = @filter_entry.text
-          if filter.empty?
-            true
-          else
-            data = case @filter_books_mode
-                   when 0
-                     (iter[Columns::TITLE] || "") +
-                       (iter[Columns::AUTHORS] || "") +
-                       (iter[Columns::ISBN] || "") +
-                       (iter[Columns::PUBLISHER] || "") +
-                       (iter[Columns::NOTES] || "") +
-                       (iter[Columns::TAGS] || "")
-                   when 2 then iter[Columns::TITLE]
-                   when 3 then iter[Columns::AUTHORS]
-                   when 4 then iter[Columns::ISBN]
-                   when 5 then iter[Columns::PUBLISHER]
-                   when 6 then iter[Columns::NOTES]
-                   when 7 then iter[Columns::TAGS]
-                   end
-            !data.nil? && data.downcase.include?(filter.downcase)
-          end
+          filter_iter(iter, @filter_entry.text)
         end
 
         # Give filter entry the initial keyboard focus.
@@ -296,6 +276,30 @@ module Alexandria
         log.debug { "done setting up active model" }
       end
 
+      def filter_iter(iter, filter)
+        if filter.empty?
+          true
+        else
+          @filter_books_mode ||= 0
+          data = case @filter_books_mode
+                 when 0
+                   (iter[Columns::TITLE] || "") +
+                     (iter[Columns::AUTHORS] || "") +
+                     (iter[Columns::ISBN] || "") +
+                     (iter[Columns::PUBLISHER] || "") +
+                     (iter[Columns::NOTES] || "") +
+                     (iter[Columns::TAGS] || "")
+                 when 2 then iter[Columns::TITLE]
+                 when 3 then iter[Columns::AUTHORS]
+                 when 4 then iter[Columns::ISBN]
+                 when 5 then iter[Columns::PUBLISHER]
+                 when 6 then iter[Columns::NOTES]
+                 when 7 then iter[Columns::TAGS]
+                 end
+          !data.nil? && data.downcase.include?(filter.downcase)
+        end
+      end
+
       def on_library_button_press_event(widget, event)
         log.debug { "library_button_press_event" }
 
@@ -449,55 +453,56 @@ module Alexandria
 
         # Focus is the wrong idiom here.
         unless @clicking_on_sidepane || (@main_app.focus == @library_listview)
-          # unless @main_app.focus == @library_listview
+          sensizite_action_group_items(books, library)
+          sensitize_provider_actions(books)
+        end
+        @clicking_on_sidepane = false
+      end
 
-          log.debug { "Currently focused widget: #{@main_app.focus.inspect}" }
-          log.debug { "#{@library_listview} : #{@library_popup} : #{@listview}" }
-          log.debug do
-            "@library_listview: #{@library_listview.has_focus?} " \
-              "or @library_popup:#{@library_popup.has_focus?}"
-          end
-          log.debug { "@library_listview does *NOT* have focus" }
-          log.debug { "Books are empty: #{books.empty?}" }
-          @actiongroup["Properties"].sensitive = \
-            @actiongroup["OnlineInformation"].sensitive = \
-              books.length == 1
-          @actiongroup["SelectAll"].sensitive = \
-            books.length < library.length
-
-          @actiongroup["Delete"].sensitive = \
-            @actiongroup["DeselectAll"].sensitive = \
-              @actiongroup["Move"].sensitive =
-                @actiongroup["SetRating"].sensitive = !books.empty?
-
-          log.debug do
-            "on_books_selection_changed Delete: #{@actiongroup['Delete'].sensitive?}"
-          end
+      def sensizite_action_group_items(books, library)
+        log.debug { "Currently focused widget: #{@main_app.focus.inspect}" }
+        log.debug { "#{@library_listview} : #{@library_popup} : #{@listview}" }
+        log.debug do
+          "@library_listview: #{@library_listview.has_focus?} " \
+            "or @library_popup:#{@library_popup.has_focus?}"
+        end
+        log.debug { "@library_listview does *NOT* have focus" }
+        log.debug { "Books are empty: #{books.empty?}" }
 
+        @actiongroup["Properties"].sensitive = @actiongroup["OnlineInformation"].sensitive =
+          books.length == 1
+        @actiongroup["SelectAll"].sensitive = books.length < library.length
+        @actiongroup["DeselectAll"].sensitive = @actiongroup["SetRating"].sensitive =
+          !books.empty?
+
+        can_delete_or_move =
           if library.is_a?(SmartLibrary)
-            @actiongroup["Delete"].sensitive =
-              @actiongroup["Move"].sensitive = false
+            false
+          else
+            !books.empty?
           end
+        @actiongroup["Delete"].sensitive = @actiongroup["Move"].sensitive =
+          can_delete_or_move
+      end
 
-          # Sensitize providers URL
-          if books.length == 1
-            b = books.first
-            # FIXME: Clean up endless negation in this logic
-            no_urls = true
-            BookProviders.list.each do |provider|
-              has_no_url = true
-              begin
-                has_no_url = (b.isbn.nil? || b.isbn.strip.empty? || provider.url(b).nil?)
-              rescue StandardError => ex
-                log.warn { "Error determining URL from #{provider.name}; #{ex.message}" }
-              end
-              @actiongroup[provider.action_name].sensitive = !has_no_url
-              no_urls = false unless has_no_url
-            end
-            @actiongroup["OnlineInformation"].sensitive = false if no_urls
+      # Sensitize providers URL
+      def sensitize_provider_actions(books)
+        return if books.length != 1
+
+        b = books.first
+        # FIXME: Clean up endless negation in this logic
+        no_urls = true
+        BookProviders.list.each do |provider|
+          has_no_url = true
+          begin
+            has_no_url = b.isbn.nil? || b.isbn.strip.empty? || provider.url(b).nil?
+          rescue StandardError => ex
+            log.warn { "Error determining URL from #{provider.name}; #{ex.message}" }
           end
+          @actiongroup[provider.action_name].sensitive = !has_no_url
+          no_urls = false unless has_no_url
         end
-        @clicking_on_sidepane = false
+        @actiongroup["OnlineInformation"].sensitive = false if no_urls
       end
 
       def on_switch_page(_notebook, _page, page_num)
@@ -624,7 +629,7 @@ module Alexandria
           if response_type == Gtk::ResponseType::OK
             # progress indicator...
             @progressbar.fraction = 0
-            @appbar.children.first.visible = true # show the progress bar
+            show_progress_bar
 
             total_book_count = @libraries.ruined_books.size
             fraction_per_book = 1.0 / total_book_count
@@ -634,38 +639,8 @@ module Alexandria
             GLib::Idle.add do
               ruined_book = @libraries.ruined_books.pop
               if ruined_book
-                book, isbn, library = ruined_book
-                begin
-                  book_rslt = Alexandria::BookProviders.isbn_search(isbn.to_s)
-                  book = book_rslt[0]
-                  cover_uri = book_rslt[1]
-
-                  # TODO: if the book was saved okay, make sure the old
-                  # empty yaml file doesn't stick around esp if doing
-                  # isbn-10 --> isbn-13 conversion...
-                  if isbn.size == 10
-                    filename = library.yaml(isbn)
-                    log.debug { "removing old file #{filename}" }
-                    begin
-                      File.delete(filename)
-                    rescue StandardError => ex
-                      log.error { "Could not delete empty file #{filename}" }
-                    end
-                  end
-
-                  log.debug do
-                    "Trying to add #{book.title}, #{cover_uri} " \
-                      "in library ''#{library.name}'"
-                  end
-                  library.save_cover(book, cover_uri) unless cover_uri.nil?
-                  library << book
-                  library.save(book)
-                  set_status_label(format(_("Added '%s' to library '%s'"),
-                                          book.title, library.name))
-                rescue StandardError => ex
-                  log.error { "Couldn't add book #{isbn}: #{ex}" }
-                  log.error { ex.backtrace.join("\n") }
-                end
+                _book, isbn, library = ruined_book
+                repair_ruined_book(isbn, library)
 
                 prog_percentage += fraction_per_book
                 @progressbar.fraction = prog_percentage
@@ -680,8 +655,7 @@ module Alexandria
                 # @listview.columns_autosize
 
                 @progressbar.fraction = 1
-                ## Hide the progress bar.
-                @appbar.children.first.visible = false
+                hide_progress_bar
                 ## Refresh the status bar.
                 set_status_label("")
                 # on_books_selection_changed
@@ -692,6 +666,75 @@ module Alexandria
         end
       end
 
+      def repair_ruined_book(isbn, library)
+        book_rslt = Alexandria::BookProviders.isbn_search(isbn.to_s)
+        book = book_rslt[0]
+        cover_uri = book_rslt[1]
+
+        # TODO: if the book was saved okay, make sure the old
+        # empty yaml file doesn't stick around esp if doing
+        # isbn-10 --> isbn-13 conversion...
+        if isbn.size == 10
+          filename = library.yaml(isbn)
+          log.debug { "removing old file #{filename}" }
+          begin
+            File.delete(filename)
+          rescue StandardError => ex
+            log.error { "Could not delete empty file #{filename}" }
+          end
+        end
+
+        log.debug do
+          "Trying to add #{book.title}, #{cover_uri} " \
+            "in library ''#{library.name}'"
+        end
+        library.save_cover(book, cover_uri) unless cover_uri.nil?
+        library << book
+        library.save(book)
+        set_status_label(format(_("Added '%s' to library '%s'"),
+                                book.title, library.name))
+      rescue StandardError => ex
+        log.error { "Couldn't add book #{isbn}: #{ex}" }
+        log.error { ex.backtrace.join("\n") }
+      end
+
+      def progress_bar
+        @progress_bar ||= @appbar.children.first
+      end
+
+      def show_progress_bar
+        progress_bar.visible = true
+      end
+
+      def hide_progress_bar
+        progress_bar.visible = false
+      end
+
+      def start_progress_bar_pulsing(dialog)
+        GLib::Idle.add do
+          show_progress_bar
+          @progress_pulsing = GLib::Timeout.add(100) do
+            if dialog.destroyed?
+              @progress_pulsing = nil
+              hide_progress_bar
+              false
+            else
+              progress_bar.pulse
+              true
+            end
+          end
+          false
+        end
+      end
+
+      def stop_progress_bar_pulsing
+        GLib::Idle.add do
+          hide_progress_bar
+          GLib::Source.remove(@progress_pulsing) if @progress_pulsing
+          false
+        end
+      end
+
       def cache_scaled_icon(icon, width, height)
         log.debug { "cache_scaled_icon #{icon}, #{width}, #{height}" }
         @cache ||= {}
@@ -703,11 +746,9 @@ module Alexandria
       REDUCE_TITLE_REGEX = Regexp.new("^(.{#{ICON_TITLE_MAXLEN}}).*$")
 
       def fill_iter_with_book(iter, book)
-        log.debug { "fill iter #{iter} with book #{book}" }
         iter[Columns::IDENT] = book.ident.to_s
         iter[Columns::TITLE] = book.title
-        title = book.title.sub(REDUCE_TITLE_REGEX, '\1...')
-        iter[Columns::TITLE_REDUCED] = title
+        iter[Columns::TITLE_REDUCED] = reduced_title(book.title)
         iter[Columns::AUTHORS] = book.authors.join(", ")
         iter[Columns::ISBN] = book.isbn.to_s
         iter[Columns::PUBLISHER] = book.publisher
@@ -715,30 +756,37 @@ module Alexandria
         iter[Columns::EDITION] = book.edition
         iter[Columns::NOTES] = (book.notes || "")
         iter[Columns::LOANED_TO] = (book.loaned_to || "")
-        rating = (book.rating || Book::DEFAULT_RATING)
+
+        rating = book.rating || Book::DEFAULT_RATING
         # ascending order is the default
         iter[Columns::RATING] = Book::MAX_RATING_STARS - rating
+
         iter[Columns::OWN] = book.own?
         iter[Columns::REDD] = book.redd?
         iter[Columns::WANT] = book.want?
-        iter[Columns::TAGS] = if book.tags
-                                book.tags.join(",")
-                              else
-                                ""
-                              end
+        iter[Columns::TAGS] = book.tags&.join(",") || ""
 
         icon = Icons.cover(selected_library, book)
-        log.debug { "Setting icon #{icon} for book #{book.title}" }
-        iter[Columns::COVER_LIST] = cache_scaled_icon(icon, 20, 25)
+        iter[Columns::COVER_LIST] = cover_list_icon(icon)
+        iter[Columns::COVER_ICON] = cover_icon(icon, rating)
+      end
+
+      def reduced_title(title)
+        title.sub(REDUCE_TITLE_REGEX, '\1...')
+      end
+
+      def cover_list_icon(icon)
+        cache_scaled_icon(icon, 20, 25)
+      end
 
+      def cover_icon(icon, rating)
         if icon.height > ICON_HEIGHT
           new_width = icon.width / (icon.height / ICON_HEIGHT.to_f)
           new_height = [ICON_HEIGHT, icon.height].min
           icon = cache_scaled_icon(icon, new_width, new_height)
         end
         icon = Icons.tag_icon(icon, Icons::FAVORITE_TAG) if rating == Book::MAX_RATING_STARS
-        iter[Columns::COVER_ICON] = icon
-        log.debug { "Full iter: " + (0..15).map { |num| iter[num].inspect }.join(", ") }
+        icon
       end
 
       def append_book(book, _tail = nil)
@@ -807,8 +855,10 @@ module Alexandria
         @iconview.freeze
         @listview.freeze
         @model.clear
+
         @progressbar.fraction = 0
-        @appbar.children.first.visible = true # show the progress bar
+        show_progress_bar
+
         set_status_label(_("Loading '%s'...") % library.name)
         total = library.length
         log.debug { "library #{library.name} length #{library.length}" }
@@ -833,9 +883,10 @@ module Alexandria
             @listview.unfreeze # NEW / bdewey
             @filtered_model.refilter
             @listview.columns_autosize
+
             @progressbar.fraction = 1
-            # Hide the progress bar.
-            @appbar.children.first.visible = false
+            hide_progress_bar
+
             # Refresh the status bar.
             on_books_selection_changed
             @library_listview.set_sensitive(true)
@@ -850,7 +901,7 @@ module Alexandria
         log.debug { "selected_library" }
         if (iter = @library_listview.selection.selected)
           target_name = iter[1]
-          @libraries.all_libraries.find { |it| it.name == target_name }
+          @libraries.all_libraries.find { _1.name == target_name }
         else
           @libraries.all_libraries.first
         end
@@ -1033,9 +1084,8 @@ module Alexandria
 
           @actiongroup.remove_action(action)
         end
-        actions = []
-        @libraries.all_regular_libraries.each do |library|
-          actions << [
+        actions = @libraries.all_regular_libraries.map do |library|
+          [
             library.action_name, nil,
             _("In '_%s'") % library.name,
             nil, nil, proc { move_selected_books_to_library(library) }
@@ -1192,5 +1242,6 @@ module Alexandria
         @filtered_model.convert_path_to_child_path(filter_path) if filter_path
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/alexandria/ui.rb

@@ -30,6 +30,7 @@ require "alexandria/ui/main_app"
 module Alexandria
   module UI
     include Logging
+
     def self.init_icons
       log.info { "Initializing Icons" }
       Icons.init

data/lib/alexandria/version.rb

@@ -5,7 +5,7 @@
 # See the file README.md for authorship and licensing information.
 
 module Alexandria
-  VERSION = "0.7.10"
+  VERSION = "0.7.11"
   DATA_VERSION = "0.6.3"
   DISPLAY_VERSION = VERSION
 end