alexandria-book-collection-manager 0.7.2 → 0.7.7

data/lib/alexandria/ui/smart_library_properties_dialog_base.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
+#
+# See the file README.md for authorship and licensing information.
+
+require "alexandria/ui/calendar_popup"
+require "alexandria/ui/smart_library_rule_box"
+
+module Alexandria
+  module UI
+    class SmartLibraryPropertiesDialogBase
+      include Logging
+      include CalendarPopup
+      include GetText
+      GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
+
+      attr_reader :predicate_operator_rule, :dialog
+
+      def initialize(parent)
+        @dialog = Gtk::Dialog.new(title: "",
+                                  parent: parent,
+                                  flags: :modal,
+                                  buttons: [[Gtk::Stock::HELP, :help]])
+
+        @dialog.window_position = :center
+        @dialog.resizable = true
+        @dialog.border_width = 4
+        @dialog.child.border_width = 12
+
+        main_box = Gtk::Box.new :vertical
+        main_box.border_width = 4
+        main_box.spacing = 8
+
+        @dialog.child << main_box
+
+        @smart_library_rules = []
+
+        @rules_header_box = Gtk::Box.new :horizontal
+        @rules_header_box.spacing = 2
+
+        @rules_box = Gtk::Box.new :vertical
+        @rules_box.spacing = 8
+        @rules_box.border_width = 8
+
+        scrollview = Gtk::ScrolledWindow.new
+        scrollview.hscrollbar_policy = :never
+        scrollview.vscrollbar_policy = :automatic
+        scrollview.set_size_request(-1, 125)
+        scrollview.add_with_viewport(@rules_box)
+
+        main_box.pack_start(@rules_header_box, expand: false, fill: false)
+        main_box << scrollview
+      end
+
+      def handle_date_icon_press(widget, primary, _icon)
+        display_calendar_popup(widget) if primary.nick == "primary"
+      end
+
+      def handle_add_rule_clicked
+        insert_new_rule
+      end
+
+      def handle_remove_rule_clicked(box_controller)
+        remove_rule_box(box_controller.rule_box)
+      end
+
+      # TODO: Move logic to SmartLibraryRuleBox
+      def apply_smart_rule_for_rule_box(rule_box, operand, operation)
+        idx = @rules_box.children.index(rule_box)
+        smart_library_rules[idx] ||= SmartLibrary::Rule.new(operand,
+                                                            operation.first,
+                                                            nil)
+        new_rule = smart_library_rules[idx]
+        new_rule.operand = operand
+        new_rule.operation = operation.first
+        new_rule.value = nil
+      end
+
+      protected
+
+      attr_reader :smart_library_rules
+
+      def has_weirdnesses?
+        fill_smart_library_rules_values
+        smart_library_rules.each do |rule|
+          return true if rule.value == ""
+        end
+        false
+      end
+
+      def user_confirms_possible_weirdnesses_before_saving?
+        return true unless has_weirdnesses?
+
+        dialog = AlertDialog.new(
+          @dialog,
+          _("Empty or conflictive condition"),
+          Gtk::Stock::DIALOG_QUESTION,
+          [[Gtk::Stock::CANCEL, Gtk::ResponseType::CANCEL],
+           [_("_Save However"), Gtk::ResponseType::YES]],
+          _("This smart library contains one or more conditions " \
+            "which are empty or conflict with each other. This is " \
+            "likely to result in never matching a book. Are you " \
+            "sure you want to save this library?"))
+        dialog.default_response = Gtk::ResponseType::CANCEL
+        dialog.show_all
+        confirmed = dialog.run == Gtk::ResponseType::YES
+        dialog.destroy
+        confirmed
+      end
+
+      def update_rules_header_box(predicate_operator_rule = SmartLibrary::ALL_RULES)
+        @rules_header_box.children.each { |x| @rules_header_box.remove(x) }
+
+        if @rules_box.children.length > 1
+          label1 = Gtk::Label.new
+          label1.set_alignment(0.0, 0.5)
+          label1.text = _("Match")
+
+          cb = Gtk::ComboBoxText.new
+          [_("all"), _("any")].each { |x| cb.append_text(x) }
+          cb.signal_connect("changed") do
+            @predicate_operator_rule =
+              cb.active.zero? ? SmartLibrary::ALL_RULES : SmartLibrary::ANY_RULE
+          end
+          cb.active =
+            predicate_operator_rule == SmartLibrary::ALL_RULES ? 0 : 1
+
+          label2 = Gtk::Label.new
+          label2.set_alignment(0.0, 0.5)
+          label2.text = _("of the following rules:")
+
+          @rules_header_box.pack_start(label1, expand: false, fill: false)
+          @rules_header_box.pack_start(cb, expand: false, fill: false)
+          @rules_header_box.pack_start(label2, expand: false, fill: false)
+        else
+          label = Gtk::Label.new
+          label.set_alignment(0.0, 0.5)
+          label.text = _("Match the following rule:")
+          @rules_header_box << label
+          @predicate_operator_rule = SmartLibrary::ALL_RULES
+        end
+
+        @rules_header_box.show_all
+      end
+
+      def make_rule_box(rule = nil)
+        box_controller = SmartLibraryRuleBox.new self
+        rule_box = box_controller.rule_box
+        rule_box.show_all
+        @rules_box.pack_start(rule_box, expand: false, fill: true)
+
+        if rule
+          operands = SmartLibrary::Rule::Operands::LEFT
+          operand_idx = operands.index(rule.operand)
+          operations =
+            SmartLibrary::Rule.operations_for_operand(rule.operand)
+          operation_idx = operations.map(&:first).index(rule.operation)
+
+          if !operand_idx.nil? && !operation_idx.nil?
+            box_controller.left_operand_combo.active = operand_idx
+            box_controller.operator_combo.active = operation_idx
+            unless rule.value.nil?
+              case rule.value
+              when String
+                box_controller.value_entry.text = rule.value
+              when Time
+                box_controller.date_entry.text = format_date(rule.value)
+              end
+            end
+          end
+        else
+          box_controller.left_operand_combo.active = 0
+        end
+      end
+
+      def insert_new_rule(rule = nil)
+        make_rule_box(rule)
+        @rules_box.check_resize # force a layout
+        update_rules_header_box
+        sensitize_remove_rule_buttons
+      end
+
+      def remove_rule_box(rule_box)
+        idx = @rules_box.children.index(rule_box)
+        raise if idx.nil?
+
+        smart_library_rules.delete_at(idx)
+        @rules_box.remove(rule_box)
+        sensitize_remove_rule_buttons
+        update_rules_header_box
+      end
+
+      def sensitize_remove_rule_buttons
+        boxes = @rules_box.children
+        state = boxes.length > 1
+        boxes.each do |box|
+          button = box.children[-1]
+          button.sensitive = state if button.is_a?(Gtk::Button)
+        end
+      end
+
+      def fill_smart_library_rules_values
+        @rules_box.children.each_with_index do |box, i|
+          entry, date = box.children[2..3]
+          value = nil
+          if entry.visible?
+            value = entry.text.strip
+          elsif date.visible?
+            begin
+              value = parse_date(date.text)
+            rescue StandardError => ex
+              trace = ex.backtrace.join("\n > ")
+              log.warn { "Possibly invalid date entered #{ex.message}" }
+              log.warn { "Date widget returned #{date.text} / #{trace}" }
+              # user entered some non-date...
+              # default to current time, for the moment
+              value = Time.now
+            end
+          end
+          smart_library_rules[i].value = value
+        end
+      end
+
+      def parse_date(datestring)
+        # '%m/%d/%Y' for USA and Canada ; or '%Y-%m-%d' for most of Asia
+        # http://en.wikipedia.org/wiki/Calendar_date#Middle_endian_forms.2C_starting_with_the_month
+        date_format = "%d/%m/%Y"
+        begin
+          d = Date.strptime(datestring, date_format)
+          Time.gm(d.year, d.month, d.day)
+        rescue StandardError
+          nil
+        end
+      end
+
+      def format_date(datetime)
+        datetime.strftime("%d/%m/%Y")
+      end
+    end
+  end
+end

data/lib/alexandria/ui/smart_library_rule_box.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
+#
+# See the file README.md for authorship and licensing information.
+
+module Alexandria
+  module UI
+    class SmartLibraryRuleBox
+      attr_accessor :rule_box,
+                    :left_operand_combo, :operator_combo,
+                    :value_entry, :date_entry, :entry_label,
+                    :add_button, :remove_button
+
+      def initialize(parent)
+        @parent = parent
+
+        self.rule_box = Gtk::Box.new :horizontal
+        rule_box.spacing = 8
+
+        self.left_operand_combo = Gtk::ComboBoxText.new
+        self.operator_combo = Gtk::ComboBoxText.new
+
+        self.value_entry = Gtk::Entry.new
+
+        self.date_entry = Gtk::Entry.new.tap do |entry|
+          entry.primary_icon_name = Gtk::Stock::EDIT
+
+          entry.primary_icon_activatable = true
+          entry.signal_connect("icon-press") do |widget, primary, icon|
+            @parent.handle_date_icon_press(widget, primary, icon)
+          end
+        end
+
+        self.entry_label = Gtk::Label.new("")
+
+        self.add_button = Gtk::Button.new(label: "").tap do |widget|
+          widget.remove(widget.children.first)
+          widget << Gtk::Image.new(stock: Gtk::Stock::ADD,
+                                   size: Gtk::IconSize::BUTTON)
+
+          widget.signal_connect("clicked") { @parent.handle_add_rule_clicked }
+        end
+
+        self.remove_button = Gtk::Button.new(label: "")
+        remove_button.remove(remove_button.children.first)
+        remove_button << Gtk::Image.new(stock: Gtk::Stock::REMOVE,
+                                        size: Gtk::IconSize::BUTTON)
+
+        remove_button.signal_connect("clicked") do |_button|
+          @parent.handle_remove_rule_clicked(self)
+        end
+
+        operands.each do |operand|
+          left_operand_combo.append_text(operand.name)
+        end
+
+        operator_combo.signal_connect("changed") do
+          handle_operator_changed
+        end
+
+        left_operand_combo.signal_connect("changed") do
+          handle_left_operand_changed
+        end
+
+        rule_box.pack_start(left_operand_combo, expand: false, fill: false)
+        rule_box.pack_start(operator_combo, expand: false, fill: false)
+        rule_box.pack_start(value_entry)
+        rule_box.pack_start(date_entry)
+        rule_box.pack_start(entry_label, expand: false, fill: false)
+        rule_box.pack_end(remove_button, expand: false, fill: false)
+        rule_box.pack_end(add_button, expand: false, fill: false)
+
+        value_entry.visible = date_entry.visible = entry_label.visible = false
+      end
+
+      def operands
+        SmartLibrary::Rule::Operands::LEFT
+      end
+
+      def handle_operator_changed
+        operand = operands[left_operand_combo.active]
+        operations = SmartLibrary::Rule.operations_for_operand(operand)
+        operation = operations[operator_combo.active]
+
+        value_entry.visible = date_entry.visible = entry_label.visible = false
+        right_operand = operation.last
+        unless right_operand.nil?
+          entry = case right_operand.klass.name
+                  when "Time"
+                    date_entry
+                  else
+                    value_entry
+                  end
+          entry.visible = true
+          unless right_operand.name.nil?
+            entry_label.text = right_operand.name
+            entry_label.visible = true
+          end
+        end
+
+        @parent.apply_smart_rule_for_rule_box(rule_box, operand, operation)
+      end
+
+      def handle_left_operand_changed
+        operand = operands[left_operand_combo.active]
+        operator_combo.freeze_notify do
+          operator_combo.remove_all
+          operations = SmartLibrary::Rule.operations_for_operand(operand)
+          operations.each do |operation|
+            operator = operation.first
+            operator_combo.append_text(operator.name)
+          end
+          operator_combo.active = 0
+        end
+      end
+    end
+  end
+end

data/lib/alexandria/ui/sound.rb

@@ -22,7 +22,7 @@
 # Boston, MA 02110-1301 USA.
 #++
 
-require 'gst'
+require "gst"
 
 module Alexandria
   module UI
@@ -39,20 +39,20 @@ module Alexandria
       def play(effect)
         file = File.join(@sounds_dir, "#{effect}.ogg")
         if @playing
-          puts "Already playing #{effect}." if $DEBUG
+          log.debug { "Already playing #{effect}." }
         else
-          puts "Not playing. Starting #{effect}." if $DEBUG
+          log.debug { "Not playing. Starting #{effect}." }
           @filesrc.location = file
           start_playback
         end
       end
 
       def set_up_pipeline
-        @filesrc = Gst::ElementFactory.make('filesrc')
-        demuxer = Gst::ElementFactory.make('oggdemux')
-        decoder = Gst::ElementFactory.make('vorbisdec')
-        converter = Gst::ElementFactory.make('audioconvert') # #??
-        audiosink = Gst::ElementFactory.make('autoaudiosink')
+        @filesrc = Gst::ElementFactory.make("filesrc")
+        demuxer = Gst::ElementFactory.make("oggdemux")
+        decoder = Gst::ElementFactory.make("vorbisdec")
+        converter = Gst::ElementFactory.make("audioconvert") # #??
+        audiosink = Gst::ElementFactory.make("autoaudiosink")
 
         @ogg_vorbis_pipeline.add(@filesrc, demuxer, decoder,
                                  converter, audiosink)
@@ -61,7 +61,7 @@ module Alexandria
         # this next must be a dynamic link, as demuxers potentially
         # have multiple src pads (for audio/video muxed streams)
 
-        demuxer.signal_connect('pad-added') do |_parser, ogg_src_pad|
+        demuxer.signal_connect("pad-added") do |_parser, ogg_src_pad|
           vorbis_sink_pad = decoder.sinkpads.first
           ogg_src_pad.link(vorbis_sink_pad)
         end
@@ -76,10 +76,8 @@ module Alexandria
           when Gst::MessageType::EOS
             stop_playback
           when Gst::MessageType::ERROR
-            if $DEBUG
-              puts 'ERROR loop.quit'
-              p message.parse
-            end
+            log.debug { "ERROR loop.quit" }
+            log.debug { message.parse.inspect }
             stop_playback
           end
           true

data/lib/alexandria/ui/ui_manager.rb

@@ -1,38 +1,27 @@
 # frozen_string_literal: true
 
-# Copyright (C) 2004-2006 Laurent Sansonetti
-# Copyright (C) 2008 Joseph Method
-# Copyright (C) 2011, 2016 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 'alexandria/ui/columns'
+require "alexandria/ui/callbacks"
+require "alexandria/ui/columns"
+require "alexandria/ui/conflict_while_copying_dialog"
+require "alexandria/library_sort_order"
 
 module Alexandria
   module UI
     class UIManager < BuilderBase
-      attr_accessor :main_app, :actiongroup, :appbar, :prefs, :listview, :iconview, :listview_model,
-                    :iconview_model, :filtered_model
+      attr_accessor :main_app, :actiongroup, :appbar, :prefs, :listview, :iconview,
+                    :listview_model, :iconview_model, :filtered_model
       attr_reader :model
+
       include Logging
       include GetText
-      GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: 'UTF-8')
+      GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
       def initialize(parent)
-        super('main_app__builder.glade', widget_names)
+        super("main_app__builder.glade", widget_names)
         @parent = parent
 
         @library_separator_iter = nil
@@ -60,7 +49,7 @@ module Alexandria
         log.debug { "UI Manager initialized: #{@iconview.model.inspect}" }
         @clicking_on_sidepane = true
 
-        @library_listview.signal_connect('cursor-changed') do
+        @library_listview.signal_connect("cursor-changed") do
           @clicking_on_sidepane = true
         end
       end
@@ -76,24 +65,23 @@ module Alexandria
       end
 
       def create_uimanager
-        log.debug { 'Adding actiongroup to uimanager' }
+        log.debug { "Adding actiongroup to uimanager" }
         @uimanager = Gtk::UIManager.new
         @uimanager.insert_action_group(@actiongroup, 0)
       end
 
       def setup_dependents
-        @listview_model = Gtk::TreeModelSort.new(model: @filtered_model)
-        @iconview_model = Gtk::TreeModelSort.new(model: @filtered_model)
+        @listview_model = Gtk::TreeModelSort.new(@filtered_model)
+        @iconview_model = Gtk::TreeModelSort.new(@filtered_model)
         @listview_manager = ListViewManager.new @listview, self
         @iconview_manager = IconViewManager.new @iconview, self
-        @sidepane_manager = SidePaneManager.new @library_listview, self
+        @sidepane_manager = SidepaneManager.new @library_listview, self
         @library_listview = @sidepane_manager.library_listview
         @listview_manager.setup_listview_columns_visibility
         @listview_manager.setup_listview_columns_width
       end
 
       def setup_callbacks
-        require 'alexandria/ui/callbacks'
         self.class.send(:include, Callbacks)
         connect_signals
       end
@@ -103,10 +91,10 @@ module Alexandria
       end
 
       def setup_toolbar
-        log.debug { 'setup_toolbar' }
+        log.debug { "setup_toolbar" }
         setup_book_providers
         add_main_toolbar_items
-        @toolbar = @uimanager.get_widget('/MainToolbar')
+        @toolbar = @uimanager.get_widget("/MainToolbar")
         @toolbar.show_arrow = true
         @toolbar.insert(Gtk::SeparatorToolItem.new, -1)
         setup_toolbar_combobox
@@ -114,18 +102,18 @@ module Alexandria
         @toolbar.insert(Gtk::SeparatorToolItem.new, -1)
         setup_toolbar_viewas
         @toolbar.show_all
-        @actiongroup['Undo'].sensitive = @actiongroup['Redo'].sensitive = false
+        @actiongroup["Undo"].sensitive = @actiongroup["Redo"].sensitive = false
         UndoManager.instance.add_observer(self)
         @vbox1.add(@toolbar, position: 1, expand: false, fill: false)
       end
 
       def add_main_toolbar_items
         mid = @uimanager.new_merge_id
-        @uimanager.add_ui(mid, 'ui/', 'MainToolbar', 'MainToolbar',
+        @uimanager.add_ui(mid, "ui/", "MainToolbar", "MainToolbar",
                           :toolbar, false)
-        @uimanager.add_ui(mid, 'ui/MainToolbar/', 'New', 'New',
+        @uimanager.add_ui(mid, "ui/MainToolbar/", "New", "New",
                           :toolitem, false)
-        @uimanager.add_ui(mid, 'ui/MainToolbar/', 'AddBook', 'AddBook',
+        @uimanager.add_ui(mid, "ui/MainToolbar/", "AddBook", "AddBook",
                           :toolitem, false)
         # @uimanager.add_ui(mid, "ui/MainToolbar/", "sep", "sep",
         #                  :separator, false)
@@ -135,11 +123,11 @@ module Alexandria
 
       def setup_toolbar_filter_entry
         @filter_entry = Gtk::Entry.new
-        @filter_entry.signal_connect('changed', &method(:on_toolbar_filter_entry_changed))
+        @filter_entry.signal_connect("changed", &method(:on_toolbar_filter_entry_changed))
         @toolitem = Gtk::ToolItem.new
         @toolitem.expand = true
         @toolitem.border_width = 5
-        @filter_entry.set_tooltip_text _('Type here the search criterion')
+        @filter_entry.set_tooltip_text _("Type here the search criterion")
         @toolitem << @filter_entry
         @toolbar.insert(@toolitem, -1)
       end
@@ -148,20 +136,20 @@ module Alexandria
         cb = Gtk::ComboBoxText.new
         cb.set_row_separator_func do |model, iter|
           # TODO: Replace with iter[0] if possible
-          model.get_value(iter, 0) == '-'
+          model.get_value(iter, 0) == "-"
         end
-        [_('Match everything'),
-         '-',
-         _('Title contains'),
-         _('Authors contain'),
-         _('ISBN contains'),
-         _('Publisher contains'),
-         _('Notes contain'),
-         _('Tags contain')].each do |item|
+        [_("Match everything"),
+         "-",
+         _("Title contains"),
+         _("Authors contain"),
+         _("ISBN contains"),
+         _("Publisher contains"),
+         _("Notes contain"),
+         _("Tags contain")].each do |item|
           cb.append_text(item)
         end
         cb.active = 0
-        cb.signal_connect('changed', &method(:on_criterion_combobox_changed))
+        cb.signal_connect("changed", &method(:on_criterion_combobox_changed))
 
         # Put the combo box in a event box because it is not currently
         # possible assign a tooltip to a combo box.
@@ -171,16 +159,16 @@ module Alexandria
         @toolitem.border_width = 5
         @toolitem << eb
         @toolbar.insert(@toolitem, -1)
-        eb.set_tooltip_text _('Change the search type')
+        eb.set_tooltip_text _("Change the search type")
       end
 
       def setup_toolbar_viewas
         @toolbar_view_as = Gtk::ComboBoxText.new
-        @toolbar_view_as.append_text(_('View as Icons'))
-        @toolbar_view_as.append_text(_('View as List'))
+        @toolbar_view_as.append_text(_("View as Icons"))
+        @toolbar_view_as.append_text(_("View as List"))
         @toolbar_view_as.active = 0
         @toolbar_view_as_signal_hid = \
-          @toolbar_view_as.signal_connect('changed', &method(:on_toolbar_view_as_changed))
+          @toolbar_view_as.signal_connect("changed", &method(:on_toolbar_view_as_changed))
 
         # Put the combo box in a event box because it is not currently
         # possible assign a tooltip to a combo box.
@@ -190,59 +178,60 @@ module Alexandria
         @toolitem.border_width = 5
         @toolitem << eb
         @toolbar.insert(@toolitem, -1)
-        eb.set_tooltip_text _('Choose how to show books')
+        eb.set_tooltip_text _("Choose how to show books")
       end
 
       def setup_book_providers
-        log.debug { 'setup_book_providers' }
+        log.debug { "setup_book_providers" }
         mid = @uimanager.new_merge_id
-        BookProviders.each do |provider|
+        ui_paths = ["ui/MainMenubar/ViewMenu/OnlineInformation/",
+                    "ui/BookPopup/OnlineInformation/",
+                    "ui/NoBookPopup/OnlineInformation/"]
+        BookProviders.list.each do |provider|
           name = provider.action_name
-          ['ui/MainMenubar/ViewMenu/OnlineInformation/',
-           'ui/BookPopup/OnlineInformation/',
-           'ui/NoBookPopup/OnlineInformation/'].each do |path|
-             log.debug { "Adding #{name} to #{path}" }
-             @uimanager.add_ui(mid, path, name, name,
-                               :menuitem, false)
-           end
+          ui_paths.each do |path|
+            log.debug { "Adding #{name} to #{path}" }
+            @uimanager.add_ui(mid, path, name, name,
+                              :menuitem, false)
+          end
         end
       end
 
       def add_menus_and_popups_from_xml
-        log.debug { 'add_menus_and_popups_from_xml' }
-        ['menus.xml', 'popups.xml'].each do |ui_file|
+        log.debug { "add_menus_and_popups_from_xml" }
+        ["menus.xml", "popups.xml"].each do |ui_file|
           @uimanager.add_ui(File.join(Alexandria::Config::DATA_DIR,
-                                      'ui', ui_file))
+                                      "ui", ui_file))
         end
       end
 
       def setup_accel_group
-        log.debug { 'setup_accel_group' }
+        log.debug { "setup_accel_group" }
         @main_app.add_accel_group(@uimanager.accel_group)
       end
 
       def setup_menus
-        @menubar = @uimanager.get_widget('/MainMenubar')
+        @menubar = @uimanager.get_widget("/MainMenubar")
         @vbox1.add(@menubar, position: 0, expand: false, fill: false)
       end
 
       def setup_popups
-        log.debug { 'setup_popups' }
-        @library_popup = @uimanager.get_widget('/LibraryPopup')
-        @smart_library_popup = @uimanager.get_widget('/SmartLibraryPopup')
-        @nolibrary_popup = @uimanager.get_widget('/NoLibraryPopup')
-        @book_popup = @uimanager.get_widget('/BookPopup')
-        @nobook_popup = @uimanager.get_widget('/NoBookPopup')
+        log.debug { "setup_popups" }
+        @library_popup = @uimanager.get_widget("/LibraryPopup")
+        @smart_library_popup = @uimanager.get_widget("/SmartLibraryPopup")
+        @nolibrary_popup = @uimanager.get_widget("/NoLibraryPopup")
+        @book_popup = @uimanager.get_widget("/BookPopup")
+        @nobook_popup = @uimanager.get_widget("/NoBookPopup")
       end
 
       def setup_window_events
-        log.debug { 'setup_window_events' }
-        @main_app.signal_connect('window-state-event', &method(:on_window_state_event))
-        @main_app.signal_connect('destroy', &method(:on_window_destroy))
+        log.debug { "setup_window_events" }
+        @main_app.signal_connect("window-state-event", &method(:on_window_state_event))
+        @main_app.signal_connect("destroy", &method(:on_window_destroy))
       end
 
       def setup_active_model
-        log.debug { 'setting up active model' }
+        log.debug { "setting up active model" }
         # The active model.
 
         list = [
@@ -277,13 +266,13 @@ module Alexandria
             true
           else
             data = case @filter_books_mode
-                   when 0 then
-                     (iter[Columns::TITLE] || '') +
-                       (iter[Columns::AUTHORS] || '') +
-                       (iter[Columns::ISBN] || '') +
-                       (iter[Columns::PUBLISHER] || '') +
-                       (iter[Columns::NOTES] || '') +
-                       (iter[Columns::TAGS] || '')
+                   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]
@@ -297,19 +286,20 @@ module Alexandria
 
         # Give filter entry the initial keyboard focus.
         @filter_entry.grab_focus
-        log.debug { 'done setting up active model' }
+        log.debug { "done setting up active model" }
       end
 
       def on_library_button_press_event(widget, event)
-        log.debug { 'library_button_press_event' }
+        log.debug { "library_button_press_event" }
 
         # right click
         if event_is_right_click event
-          log.debug { 'library right click!' }
+          log.debug { "library right click!" }
           library_already_selected = true
           if (path = widget.get_path_at_pos(event.x, event.y))
             @clicking_on_sidepane = true
-            obj, path = widget.is_a?(Gtk::TreeView) ? [widget.selection, path.first] : [widget, path]
+            obj, path =
+              widget.is_a?(Gtk::TreeView) ? [widget.selection, path.first] : [widget, path]
             widget.has_focus = true
 
             unless obj.path_is_selected?(path)
@@ -350,34 +340,20 @@ module Alexandria
           # seem to suffice).
           #
           # Then we wait a while and only *then* pop up the menu.
+          sensitize_library selected_library if library_already_selected
 
-          if library_already_selected
-            sensitize_library selected_library
-
-            GLib::Idle.add do
-              menu.popup(nil, nil, event.button, event.time)
-              # @clicking_on_sidepane = false
-              false
-            end
-          else
-            GLib::Idle.add do
-              menu.popup(nil, nil, event.button, event.time)
-              # @clicking_on_sidepane = false
-
-              false
-            end
+          GLib::Idle.add do
+            menu.popup(nil, nil, event.button, event.time)
+            false
           end
 
-        else
           # not a right click
-          if (path = widget.get_path_at_pos(event.x, event.y))
-            @clicking_on_sidepane = true
-            obj, path = widget.is_a?(Gtk::TreeView) ? [widget.selection, path.first] : [widget, path]
-            obj.select_path(path)
-            sensitize_library selected_library
-
-          end
-
+        elsif (path = widget.get_path_at_pos(event.x, event.y))
+          @clicking_on_sidepane = true
+          obj, path =
+            widget.is_a?(Gtk::TreeView) ? [widget.selection, path.first] : [widget, path]
+          obj.select_path(path)
+          sensitize_library selected_library
         end
       end
 
@@ -396,25 +372,26 @@ module Alexandria
       end
 
       def on_books_button_press_event(widget, event)
-        log.debug { 'books_button_press_event' }
-        if event_is_right_click event
-          widget.grab_focus
+        log.debug { "books_button_press_event" }
+        event_is_right_click event or return
 
-          if (path = widget.get_path_at_pos(event.x.to_i, event.y.to_i))
-            obj, path = widget.is_a?(Gtk::TreeView) ? [widget.selection, path.first] : [widget, path]
+        widget.grab_focus
 
-            unless obj.path_is_selected?(path)
-              log.debug { "Select #{path}" }
-              widget.unselect_all
-              obj.select_path(path)
-            end
-          else
+        if (path = widget.get_path_at_pos(event.x.to_i, event.y.to_i))
+          obj, path =
+            widget.is_a?(Gtk::TreeView) ? [widget.selection, path.first] : [widget, path]
+
+          unless obj.path_is_selected?(path)
+            log.debug { "Select #{path}" }
             widget.unselect_all
+            obj.select_path(path)
           end
-
-          menu = selected_books.empty? ? @nobook_popup : @book_popup
-          menu.popup(nil, nil, event.button, event.time)
+        else
+          widget.unselect_all
         end
+
+        menu = selected_books.empty? ? @nobook_popup : @book_popup
+        menu.popup(nil, nil, event.button, event.time)
       end
 
       def get_library_selection_text(library)
@@ -434,9 +411,9 @@ module Alexandria
                       library.length), library.name, library.length)
           else
             format(n_("Library '%s' selected, %d book, " \
-               '%d unrated',
+               "%d unrated",
                       "Library '%s' selected, %d books, " \
-                      '%d unrated',
+                      "%d unrated",
                       library.length), library.name, library.length, n_unrated)
           end
         end
@@ -449,7 +426,7 @@ module Alexandria
         when 1
           _("'%s' selected") % books.first.title
         else
-          n_('%d book selected', '%d books selected',
+          n_("%d book selected", "%d books selected",
              books.length) % books.length
         end
       end
@@ -469,28 +446,30 @@ module Alexandria
 
           log.debug { "Currently focused widget: #{@main_app.focus.inspect}" }
           log.debug { "#{@library_listview} : #{@library_popup} : #{@listview}" }
-          log.debug {
+          log.debug do
             "@library_listview: #{@library_listview.has_focus?} " \
             "or @library_popup:#{@library_popup.has_focus?}"
-          }
-          log.debug { '@library_listview does *NOT* have focus' }
+          end
+          log.debug { "@library_listview does *NOT* have focus" }
           log.debug { "Books are empty: #{books.empty?}" }
-          @actiongroup['Properties'].sensitive = \
-            @actiongroup['OnlineInformation'].sensitive = \
+          @actiongroup["Properties"].sensitive = \
+            @actiongroup["OnlineInformation"].sensitive = \
               books.length == 1
-          @actiongroup['SelectAll'].sensitive = \
+          @actiongroup["SelectAll"].sensitive = \
             books.length < library.length
 
-          @actiongroup['Delete'].sensitive = \
-            @actiongroup['DeselectAll'].sensitive = \
-              @actiongroup['Move'].sensitive =
-                @actiongroup['SetRating'].sensitive = !books.empty?
+          @actiongroup["Delete"].sensitive = \
+            @actiongroup["DeselectAll"].sensitive = \
+              @actiongroup["Move"].sensitive =
+                @actiongroup["SetRating"].sensitive = !books.empty?
 
-          log.debug { "on_books_selection_changed Delete: #{@actiongroup['Delete'].sensitive?}" }
+          log.debug do
+            "on_books_selection_changed Delete: #{@actiongroup['Delete'].sensitive?}"
+          end
 
           if library.is_a?(SmartLibrary)
-            @actiongroup['Delete'].sensitive =
-              @actiongroup['Move'].sensitive = false
+            @actiongroup["Delete"].sensitive =
+              @actiongroup["Move"].sensitive = false
           end
 
           # Sensitize providers URL
@@ -498,37 +477,37 @@ module Alexandria
             b = books.first
             # FIXME: Clean up endless negation in this logic
             no_urls = true
-            BookProviders.each do |provider|
+            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 => ex
+              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
+            @actiongroup["OnlineInformation"].sensitive = false if no_urls
           end
         end
         @clicking_on_sidepane = false
       end
 
       def on_switch_page(_notebook, _page, page_num)
-        log.debug { 'on_switch_page' }
-        @actiongroup['ArrangeIcons'].sensitive = page_num.zero?
+        log.debug { "on_switch_page" }
+        @actiongroup["ArrangeIcons"].sensitive = page_num.zero?
         on_books_selection_changed
       end
 
       def on_focus(widget, _event_focus)
         if @clicking_on_sidepane || (widget == @library_listview)
-          log.debug { 'on_focus: @library_listview' }
+          log.debug { "on_focus: @library_listview" }
           GLib::Idle.add do
             %w(OnlineInformation SelectAll DeselectAll).each do |action|
               @actiongroup[action].sensitive = false
             end
-            @actiongroup['Properties'].sensitive = selected_library.is_a?(SmartLibrary)
-            @actiongroup['Delete'].sensitive = determine_delete_option
+            @actiongroup["Properties"].sensitive = selected_library.is_a?(SmartLibrary)
+            @actiongroup["Delete"].sensitive = determine_delete_option
             false
           end
         else
@@ -537,50 +516,33 @@ module Alexandria
       end
 
       def determine_delete_option
-        sensitive = (@libraries.all_regular_libraries.length > 1 || selected_library.is_a?(SmartLibrary))
-        sensitive
+        @libraries.all_regular_libraries.length > 1 || selected_library.is_a?(SmartLibrary)
       end
 
       def on_close_sidepane
-        log.debug { 'on_close_sidepane' }
-        @actiongroup['Sidepane'].active = false
+        log.debug { "on_close_sidepane" }
+        @actiongroup["Sidepane"].active = false
       end
 
+      # TODO: Figure out why this frequently selects the wrong book!
       def select_a_book(book)
-        select_this_book = proc do |bk, view|
-          @filtered_model.refilter
-          iter = iter_from_book bk
-          next unless iter
-          path = iter.path
-          next unless view.model
-          path = view_path_to_model_path(view, path)
-          log.debug { "Path for #{bk.ident} is #{path}" }
-          selection = view.respond_to?(:selection) ? @listview.selection : @iconview
-          selection.unselect_all
-          selection.select_path(path)
-        end
-        begin
-          log.debug { 'select_a_book: listview' }
-          select_this_book.call(book, @listview)
-          log.debug { 'select_a_book: listview' }
-          select_this_book.call(book, @iconview)
-        rescue => ex
-          trace = ex.backtrace.join("\n> ")
-          log.warn { "Failed to automatically select book: #{ex.message} #{trace}" }
-        end
-        # TODO: Figure out why this frequently selects the wrong book!
+        log.debug { "select_a_book: listview" }
+        select_book_in_view(book, @listview)
+        log.debug { "select_a_book: iconview" }
+        select_book_in_view(book, @iconview)
       end
 
       def update(*ary)
         log.debug { "on_update #{ary}" }
         caller = ary.first
-        if caller.is_a?(UndoManager)
-          @actiongroup['Undo'].sensitive = caller.can_undo?
-          @actiongroup['Redo'].sensitive = caller.can_redo?
-        elsif caller.is_a?(Library)
+        case caller
+        when UndoManager
+          @actiongroup["Undo"].sensitive = caller.can_undo?
+          @actiongroup["Redo"].sensitive = caller.can_redo?
+        when Library
           handle_update_caller_library ary unless caller.updating?
         else
-          raise 'unrecognized update event'
+          raise _("unrecognized update event")
         end
       end
 
@@ -606,18 +568,16 @@ module Alexandria
         end
       end
 
-      # private
-
       def open_web_browser(url)
         if url.nil?
-          log.warn('Attempt to open browser with nil url')
+          log.warn("Attempt to open browser with nil url")
           return
         end
         Gtk.show_uri url
       end
 
       def detach_old_libraries
-        log.debug { 'Un-observing old libraries' }
+        log.debug { "Un-observing old libraries" }
         @libraries.all_regular_libraries.each do |library|
           if library.is_a?(Library)
             library.delete_observer(self)
@@ -627,13 +587,13 @@ module Alexandria
       end
 
       def load_libraries
-        log.info { 'Loading Libraries...' }
+        log.info { _("Loading libraries...") }
         @completion_models = CompletionModels.instance
         if @libraries
           detach_old_libraries
           @libraries.reload
         else
-          @libraries = Libraries.instance
+          @libraries = LibraryCollection.instance
           @libraries.reload
           handle_ruined_books unless @libraries.ruined_books.empty?
         end
@@ -645,19 +605,19 @@ module Alexandria
 
       def handle_ruined_books
         new_message = _(
-          'The data files for the following books are malformed or empty. Do you wish to' \
+          "The data files for the following books are malformed or empty. Do you wish to" \
           " attempt to download new information for them from the online book providers?\n")
 
-        @libraries.ruined_books.each { |bi|
+        @libraries.ruined_books.each do |bi|
           new_message += "\n#{bi[1] || bi[1].inspect}"
-        }
+        end
         recovery_dialog = Gtk::MessageDialog.new(@main_app, Gtk::Dialog::MODAL,
                                                  Gtk::MessageDialog::WARNING,
                                                  Gtk::MessageDialog::BUTTONS_OK_CANCEL,
                                                  new_message).show
-        recovery_dialog.signal_connect('response') do |_dialog, response_type|
+        recovery_dialog.signal_connect("response") do |_dialog, response_type|
           recovery_dialog.destroy
-          if response_type == :ok
+          if response_type == Gtk::ResponseType::OK
             # progress indicator...
             @progressbar.fraction = 0
             @appbar.children.first.visible = true # show the progress bar
@@ -684,17 +644,21 @@ module Alexandria
                     log.debug { "removing old file #{filename}" }
                     begin
                       File.delete(filename)
-                    rescue => ex
+                    rescue StandardError => ex
                       log.error { "Could not delete empty file #{filename}" }
                     end
                   end
 
-                  log.debug { "Trying to add #{book.title}, #{cover_uri} in library ''#{library.name}'" }
+                  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 => ex
+                  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
@@ -715,7 +679,7 @@ module Alexandria
                 ## Hide the progress bar.
                 @appbar.children.first.visible = false
                 ## Refresh the status bar.
-                set_status_label('')
+                set_status_label("")
                 # on_books_selection_changed
                 false
               end
@@ -740,22 +704,23 @@ module Alexandria
         iter[Columns::TITLE] = book.title
         title = book.title.sub(REDUCE_TITLE_REGEX, '\1...')
         iter[Columns::TITLE_REDUCED] = title
-        iter[Columns::AUTHORS] = book.authors.join(', ')
+        iter[Columns::AUTHORS] = book.authors.join(", ")
         iter[Columns::ISBN] = book.isbn.to_s
         iter[Columns::PUBLISHER] = book.publisher
         iter[Columns::PUBLISH_DATE] = book.publishing_year.to_s
         iter[Columns::EDITION] = book.edition
-        iter[Columns::NOTES] = (book.notes || '')
-        iter[Columns::LOANED_TO] = (book.loaned_to || '')
+        iter[Columns::NOTES] = (book.notes || "")
+        iter[Columns::LOANED_TO] = (book.loaned_to || "")
         rating = (book.rating || Book::DEFAULT_RATING)
-        iter[Columns::RATING] = Book::MAX_RATING_STARS - rating # ascending order is the default
+        # 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(',')
+                                book.tags.join(",")
                               else
-                                ''
+                                ""
                               end
 
         icon = Icons.cover(selected_library, book)
@@ -767,9 +732,9 @@ module Alexandria
           new_height = [ICON_HEIGHT, icon.height].min
           icon = cache_scaled_icon(icon, new_width, new_height)
         end
-        icon = icon.tag(Icons::FAVORITE_TAG) if rating == Book::MAX_RATING_STARS
+        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(', ') }
+        log.debug { "Full iter: " + (0..15).map { |num| iter[num].inspect }.join(", ") }
       end
 
       def append_book(book, _tail = nil)
@@ -779,7 +744,7 @@ module Alexandria
         if iter
           fill_iter_with_book(iter, book)
         else
-          log.debug { '@model.append' }
+          log.debug { "@model.append" }
           iter = @model.append
           fill_iter_with_book(iter, book)
           log.debug { "no iter for book #{book}" }
@@ -816,13 +781,13 @@ module Alexandria
           @library_listview.set_cursor(iter.path,
                                        @library_listview.get_column(0),
                                        true)
-          @actiongroup['Sidepane'].active = true
+          @actiongroup["Sidepane"].active = true
         end
         iter
       end
 
       def append_library_separator
-        log.debug { 'append_library_separator' }
+        log.debug { "append_library_separator" }
         iter = @library_listview.model.append
         iter[0] = nil
         iter[1] = nil
@@ -832,12 +797,12 @@ module Alexandria
       end
 
       def refresh_books
-        log.debug { 'refresh_books' }
+        log.debug { "refresh_books" }
         @library_listview.set_sensitive(false)
         library = selected_library
-        @model.clear
         @iconview.freeze
-        @listview.freeze # NEW / bdewey
+        @listview.freeze
+        @model.clear
         @progressbar.fraction = 0
         @appbar.children.first.visible = true # show the progress bar
         set_status_label(_("Loading '%s'...") % library.name)
@@ -851,7 +816,7 @@ module Alexandria
           if book
             begin
               append_book(book)
-            rescue => ex
+            rescue StandardError => ex
               trace = ex.backtrace.join("\n > ")
               log.error { "append_books failed #{ex.message} #{trace}" }
             end
@@ -878,9 +843,10 @@ module Alexandria
       end
 
       def selected_library
-        log.debug { 'selected_library' }
+        log.debug { "selected_library" }
         if (iter = @library_listview.selection.selected)
-          @libraries.all_libraries.find { |x| x.name == iter[1] }
+          target_name = iter[1]
+          @libraries.all_libraries.find { |it| it.name == target_name }
         else
           @libraries.all_libraries.first
         end
@@ -907,9 +873,10 @@ module Alexandria
       def iter_from_ident(ident)
         log.debug { ident.to_s }
         iter = @model.iter_first
-        ok = true
+        ok = true if iter
         while ok
           return iter if iter[Columns::IDENT] == ident
+
           ok = iter.next!
         end
         nil
@@ -948,11 +915,11 @@ module Alexandria
       end
 
       def refresh_libraries
-        log.debug { 'refresh_libraries' }
+        log.debug { "refresh_libraries" }
         library = selected_library
 
         # Change the application's title.
-        @main_app.title = library.name + ' - ' + TITLE
+        @main_app.title = library.name + " - " + TITLE
 
         # Disable the selected library in the move libraries actions.
         @libraries.all_regular_libraries.each do |i_library|
@@ -966,11 +933,11 @@ module Alexandria
         smart = library.is_a?(SmartLibrary)
         log.debug { "sensitize_library: smartlibrary = #{smart}" }
         GLib::Idle.add do
-          @actiongroup['AddBook'].sensitive = !smart
-          @actiongroup['AddBookManual'].sensitive = !smart
-          @actiongroup['Properties'].sensitive = smart
+          @actiongroup["AddBook"].sensitive = !smart
+          @actiongroup["AddBookManual"].sensitive = !smart
+          @actiongroup["Properties"].sensitive = smart
           can_delete = smart || (@libraries.all_regular_libraries.length > 1)
-          @actiongroup['Delete'].sensitive = can_delete
+          @actiongroup["Delete"].sensitive = can_delete
           log.debug { "sensitize_library delete: #{@actiongroup['Delete'].sensitive?}" }
           false
         end
@@ -979,14 +946,14 @@ module Alexandria
       def get_view_actiongroup
         case @prefs.view_as
         when 0
-          @actiongroup['AsIcons']
+          @actiongroup["AsIcons"]
         when 1
-          @actiongroup['AsList']
+          @actiongroup["AsList"]
         end
       end
 
       def restore_preferences
-        log.debug { 'Restoring preferences...' }
+        log.debug { "Restoring preferences" }
         if @prefs.maximized
           @main_app.maximize
         else
@@ -995,9 +962,9 @@ module Alexandria
           @maximized = false
         end
         @paned.position = @prefs.sidepane_position
-        @actiongroup['Sidepane'].active = @prefs.sidepane_visible
-        @actiongroup['Toolbar'].active = @prefs.toolbar_visible
-        @actiongroup['Statusbar'].active = @prefs.statusbar_visible
+        @actiongroup["Sidepane"].active = @prefs.sidepane_visible
+        @actiongroup["Toolbar"].active = @prefs.toolbar_visible
+        @actiongroup["Statusbar"].active = @prefs.statusbar_visible
         @appbar.visible = @prefs.statusbar_visible
         action = get_view_actiongroup
         action.activate
@@ -1021,29 +988,29 @@ module Alexandria
       end
 
       def save_preferences
-        log.debug { 'save_preferences' }
+        log.debug { "save_preferences" }
         @prefs.position = @main_app.position
         @prefs.size = @main_app.allocation.to_a[2..3]
         @prefs.maximized = @maximized
         @prefs.sidepane_position = @paned.position
-        @prefs.sidepane_visible = @actiongroup['Sidepane'].active?
-        @prefs.toolbar_visible = @actiongroup['Toolbar'].active?
-        @prefs.statusbar_visible = @actiongroup['Statusbar'].active?
+        @prefs.sidepane_visible = @actiongroup["Sidepane"].active?
+        @prefs.toolbar_visible = @actiongroup["Toolbar"].active?
+        @prefs.statusbar_visible = @actiongroup["Statusbar"].active?
         @prefs.view_as = @notebook.page
         @prefs.selected_library = selected_library.name
         cols_width = {}
         @listview.columns.each do |c|
           cols_width[c.title] = c.width
         end
-        @prefs.cols_width = '{' + cols_width.to_a.map do |t, v|
+        @prefs.cols_width = "{" + cols_width.to_a.map do |t, v|
           '"' + t + '": ' + v.to_s
-        end.join(', ') + '}'
+        end.join(", ") + "}"
         log.debug { "cols_width: #{@prefs.cols_width} " }
         @prefs.save!
       end
 
       def undoable_move(source, dest, books)
-        log.debug { 'undoable_move' }
+        log.debug { "undoable_move" }
         Library.move(source, dest, *books)
         UndoManager.instance.push { undoable_move(dest, source, books) }
       end
@@ -1060,7 +1027,8 @@ module Alexandria
 
       def setup_move_actions
         @actiongroup.actions.each do |action|
-          next unless /^MoveIn/ =~ action.name
+          next unless action.name.start_with?("MoveIn")
+
           @actiongroup.remove_action(action)
         end
         actions = []
@@ -1074,10 +1042,11 @@ module Alexandria
         @actiongroup.add_actions(actions)
         @uimanager.remove_ui(@move_mid) if @move_mid
         @move_mid = @uimanager.new_merge_id
+        ui_paths = ["ui/MainMenubar/EditMenu/Move/",
+                    "ui/BookPopup/Move/"]
         @libraries.all_regular_libraries.each do |library|
           name = library.action_name
-          ['ui/MainMenubar/EditMenu/Move/',
-           'ui/BookPopup/Move/'].each do |path|
+          ui_paths.each do |path|
             @uimanager.add_ui(@move_mid, path, name, name,
                               :menuitem, false)
           end
@@ -1096,22 +1065,22 @@ module Alexandria
       # Gets the sort order of the current library, for use by export
       def library_sort_order
         # added by Cathal Mc Ginley, 23 Oct 2007
-        log.debug {
+        log.debug do
           "library_sort_order #{@notebook.page}: " \
           "#{@iconview.model.inspect} #{@listview.model.inspect}"
-        }
+        end
         result, sort_column, sort_order = current_view.model.sort_column_id
         if result
-          column_ids_to_attributes = { 2 => :title,
-                                       4 => :authors,
-                                       5 => :isbn,
-                                       6 => :publisher,
-                                       7 => :publishing_year,
-                                       8 => :edition, # binding
+          column_ids_to_attributes = { 2  => :title,
+                                       4  => :authors,
+                                       5  => :isbn,
+                                       6  => :publisher,
+                                       7  => :publishing_year,
+                                       8  => :edition, # binding
                                        12 => :redd,
                                        13 => :own,
                                        14 => :want,
-                                       9 => :rating }
+                                       9  => :rating }
 
           sort_attribute = column_ids_to_attributes.fetch sort_column
           ascending = (sort_order == :ascending)
@@ -1161,10 +1130,10 @@ module Alexandria
       end
 
       def remove_library_separator
-        if !@library_separator_iter.nil? && @libraries.all_smart_libraries.empty?
-          @library_listview.model.remove(@library_separator_iter)
-          @library_separator_iter = nil
-        end
+        return if @library_separator_iter.nil? || @libraries.all_smart_libraries.any?
+
+        @library_listview.model.remove(@library_separator_iter)
+        @library_separator_iter = nil
       end
 
       def undoable_undelete(library, books = nil)
@@ -1185,13 +1154,14 @@ module Alexandria
 
       def setup_window_icons
         @main_app.icon = Icons::ALEXANDRIA_SMALL
-        Gtk::Window.set_default_icon_name('alexandria')
-        @main_app.icon_name = 'alexandria'
+        Gtk::Window.set_default_icon_name("alexandria")
+        @main_app.icon_name = "alexandria"
       end
 
       ICONS_SORTS = [
         Columns::TITLE, Columns::AUTHORS, Columns::ISBN,
-        Columns::PUBLISHER, Columns::EDITION, Columns::RATING, Columns::REDD, Columns::OWN, Columns::WANT
+        Columns::PUBLISHER, Columns::EDITION, Columns::RATING,
+        Columns::REDD, Columns::OWN, Columns::WANT
       ].freeze
 
       def setup_books_iconview_sorting
@@ -1203,6 +1173,21 @@ module Alexandria
 
       private
 
+      def select_book_in_view(book, view)
+        @filtered_model.refilter
+        iter = iter_from_book book
+        return unless iter
+
+        path = iter.path
+        return unless view.model
+
+        path = view_path_to_model_path(view, path)
+        log.debug { "Path for #{book.ident} is #{path}" }
+        selection = view.respond_to?(:selection) ? view.selection : view
+        selection.unselect_all
+        selection.select_path(path)
+      end
+
       def view_path_to_model_path(view, path)
         path = view.model.convert_path_to_child_path(path)
         @filtered_model.convert_path_to_child_path(path) if path