alexandria-book-collection-manager 0.7.5 → 0.7.6

data/lib/alexandria/ui/provider_preferences_base_dialog.rb

@@ -6,6 +6,7 @@
 
 class Gtk::Entry
   attr_writer :mandatory
+
   def mandatory?
     @mandatory
   end
@@ -13,18 +14,21 @@ end
 
 module Alexandria
   module UI
-    class ProviderPreferencesBaseDialog < SimpleDelegator
+    class ProviderPreferencesBaseDialog
+      attr_reader :dialog
+
       def initialize(title:, parent:, flags:, buttons:)
-        dialog = Gtk::Dialog.new(title: title, parent: parent, flags: flags,
+        @dialog = Gtk::Dialog.new(title: title, parent: parent, flags: flags,
                                  buttons: buttons)
-        super(dialog)
 
-        self.resizable = false
-        child.border_width = 12
+        @dialog.resizable = false
+        @dialog.child.border_width = 12
 
         @controls = []
       end
 
+      private
+
       def fill_table(table, provider)
         i = table.n_rows
         table.resize(table.n_rows + provider.prefs.length,

data/lib/alexandria/ui/provider_preferences_dialog.rb

@@ -20,15 +20,15 @@ module Alexandria
 
         table = Gtk::Table.new(0, 0)
         fill_table(table, provider)
-        child.pack_start(table)
+        dialog.child.pack_start(table)
 
-        signal_connect("destroy") { sync_variables }
+        dialog.signal_connect("destroy") { sync_variables }
       end
 
       def acquire
-        show_all
-        run
-        destroy
+        dialog.show_all
+        dialog.run
+        dialog.destroy
       end
     end
   end

data/lib/alexandria/ui/really_delete_dialog.rb

@@ -40,7 +40,7 @@ module Alexandria
                [Gtk::Stock::DELETE, Gtk::ResponseType::OK]],
               description)
 
-        self.default_response = Gtk::ResponseType::CANCEL
+        dialog.default_response = Gtk::ResponseType::CANCEL
       end
 
       def ok?

data/lib/alexandria/ui/sidepane_manager.rb

@@ -8,10 +8,11 @@ require "alexandria/ui/error_dialog"
 
 module Alexandria
   module UI
-    class SidePaneManager
+    class SidepaneManager
       include Logging
       include GetText
       attr_accessor :library_listview
+
       def initialize(library_listview, parent)
         @library_listview = library_listview
         @parent = parent
@@ -32,12 +33,11 @@ module Alexandria
       # otherwise returns nil
       def contains_illegal_character(new_text)
         new_text.unpack("U*") # attempt to unpack as UTF-8 characters
-        match = %r{(^\.|/)}.match(new_text)
         # forbid / character (since Library names become dir names)
         # also no initial . since that hides the Library (hidden file)
         #      forbidding an initial dot also disallows "." and ".."
         #      which are of course pre-existing directories.
-        match
+        %r{(^\.|/)}.match(new_text)
       rescue StandardError => ex
         log.warn { "New library name not valid UTF-8: #{ex.message}" }
         true
@@ -46,42 +46,40 @@ module Alexandria
 
       def on_edited_library(cell, path_string, new_text)
         log.debug { "edited library name #{new_text}" }
-        ## new_text = new_text.reverse # for testing;
-        # a great way to generate broken UTF-8
-        if cell.text != new_text
-          if (match = contains_illegal_character(new_text))
-            if match.instance_of? MatchData
-              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
-            else
-              ErrorDialog.new(@main_app, _("Invalid library name"),
-                              _("The name provided contains " \
-                                "invalid characters.")).display
-            end
-
-          elsif new_text.strip.empty?
-            log.debug { "Empty text" }
-            ErrorDialog.new(@main_app, _("The library name " \
-                                         "can not be empty")).display
-          elsif library_already_exists new_text
-            log.debug { "Already exists" }
-            ErrorDialog.new(@main_app,
-                            _("The library can not be renamed"),
-                            _("There is already a library named " \
-                              "'%s'.  Please choose a different " \
-                              "name.") % new_text.strip).display
+        return if cell.text == new_text
+
+        if (match = contains_illegal_character(new_text))
+          if match.instance_of? MatchData
+            chars = match[1].gsub(/&/, "&amp;")
+            ErrorDialog.new(@main_app, _("Invalid library name '%s'") % new_text,
+                            _("The name provided contains the " \
+                              "disallowed character <b>%s</b>") % chars).display
           else
-            log.debug { "Attempting to apply #{path_string}, #{new_text}" }
-            path = Gtk::TreePath.new(path_string)
-            iter = @library_listview.model.get_iter(path)
-            library_name = new_text.strip
-            log.info { "library name is #{library_name}" }
-            iter[1] = @parent.selected_library.name = library_name
-            @parent.setup_move_actions
-            @parent.refresh_libraries
+            ErrorDialog.new(@main_app, _("Invalid library name"),
+                            _("The name provided contains " \
+                              "invalid characters.")).display
           end
+
+        elsif new_text.strip.empty?
+          log.debug { "Empty text" }
+          ErrorDialog.new(@main_app, _("The library name " \
+                                       "can not be empty")).display
+        elsif library_already_exists new_text
+          log.debug { "Already exists" }
+          ErrorDialog.new(@main_app,
+                          _("The library can not be renamed"),
+                          _("There is already a library named " \
+                            "'%s'.  Please choose a different " \
+                            "name.") % new_text.strip).display
+        else
+          log.debug { "Attempting to apply #{path_string}, #{new_text}" }
+          path = Gtk::TreePath.new(path_string)
+          iter = @library_listview.model.get_iter(path)
+          library_name = new_text.strip
+          log.info { "library name is #{library_name}" }
+          iter[1] = @parent.selected_library.name = library_name
+          @parent.setup_move_actions
+          @parent.refresh_libraries
         end
       end
 

data/lib/alexandria/ui/skip_entry_dialog.rb

@@ -10,6 +10,7 @@ module Alexandria
   module UI
     class SkipEntryDialog < AlertDialog
       include GetText
+      include Logging
       GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
       def initialize(parent, message)
@@ -18,8 +19,8 @@ module Alexandria
               [[Gtk::Stock::CANCEL, Gtk::ResponseType::CANCEL],
                [_("_Continue"), Gtk::ResponseType::OK]],
               message)
-        puts "Opened SkipEntryDialog #{inspect}" if $DEBUG
-        self.default_response = Gtk::ResponseType::CANCEL
+        log.debug { "Opened SkipEntryDialog #{inspect}" }
+        dialog.default_response = Gtk::ResponseType::CANCEL
       end
 
       def continue?

data/lib/alexandria/ui/smart_library_properties_dialog.rb

@@ -1,21 +1,8 @@
 # frozen_string_literal: true
 
-# Copyright (C) 2004-2006 Laurent Sansonetti
+# 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.
 
 module Alexandria
   module UI
@@ -26,35 +13,47 @@ module Alexandria
       def initialize(parent, smart_library)
         super(parent)
 
-        add_buttons([Gtk::Stock::CANCEL, :cancel],
-                    [Gtk::Stock::SAVE, :ok])
+        @smart_library = smart_library
+
+        dialog.add_buttons([Gtk::Stock::CANCEL, :cancel],
+                           [Gtk::Stock::SAVE, :ok])
 
-        self.title = _("Properties for '%s'") % smart_library.name
+        dialog.title = _("Properties for '%s'") % @smart_library.name
         # FIXME: Should accept just :cancel
-        self.default_response = Gtk::ResponseType::CANCEL
+        dialog.default_response = Gtk::ResponseType::CANCEL
+        @smart_library.rules.each { |x| insert_new_rule(x) }
+        update_rules_header_box(@smart_library.predicate_operator_rule)
       end
 
       def acquire
-        show_all
-        smart_library.rules.each { |x| insert_new_rule(x) }
-        update_rules_header_box(smart_library.predicate_operator_rule)
-
-        while (response = run) != Gtk::ResponseType::CANCEL
-          if response == Gtk::ResponseType::HELP
-            Alexandria::UI.display_help(self, "edit-smart-library")
-          elsif response == Gtk::ResponseType::OK
-            if user_confirms_possible_weirdnesses_before_saving?
-              smart_library.rules = smart_library_rules
-              smart_library.predicate_operator_rule =
-                predicate_operator_rule
-              smart_library.save
-              yield(smart_library)
-              break
-            end
+        dialog.show_all
+
+        while (response = dialog.run) != Gtk::ResponseType::CANCEL
+          case response
+          when Gtk::ResponseType::HELP
+            handle_help_response
+          when Gtk::ResponseType::OK
+            break if handle_ok_response
           end
         end
 
-        destroy
+        dialog.destroy
+      end
+
+      private
+
+      def handle_ok_response
+        user_confirms_possible_weirdnesses_before_saving? or return
+
+        @smart_library.rules = smart_library_rules
+        @smart_library.predicate_operator_rule =
+          predicate_operator_rule
+        @smart_library.save
+        true
+      end
+
+      def handle_help_response
+        Alexandria::UI.display_help(self, "edit-smart-library")
       end
     end
   end

data/lib/alexandria/ui/smart_library_properties_dialog_base.rb

@@ -1,49 +1,36 @@
 # frozen_string_literal: true
 
-# Copyright (C) 2004-2006 Laurent Sansonetti
-# 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/smart_library_rule_box"
 
 module Alexandria
   module UI
-    class SmartLibraryPropertiesDialogBase < SimpleDelegator
+    class SmartLibraryPropertiesDialogBase
       include Logging
       include GetText
       GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
-      attr_reader :predicate_operator_rule
+      attr_reader :predicate_operator_rule, :dialog
 
       def initialize(parent)
         @dialog = Gtk::Dialog.new(title: "",
                                   parent: parent,
                                   flags: :modal,
                                   buttons: [[Gtk::Stock::HELP, :help]])
-        super(@dialog)
 
-        self.window_position = :center
-        self.resizable = true
-        self.border_width = 4
-        child.border_width = 12
+        @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
 
-        child << main_box
+        @dialog.child << main_box
 
         @smart_library_rules = []
 
@@ -65,13 +52,34 @@ module Alexandria
         setup_calendar_widgets
       end
 
-      protected
+      def handle_date_icon_press(widget, primary, _icon)
+        display_calendar_popup(widget) if primary.nick == "primary"
+      end
 
-      def smart_library_rules
-        fill_smart_library_rules_values
-        @smart_library_rules
+      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|
@@ -135,140 +143,53 @@ module Alexandria
         @rules_header_box.show_all
       end
 
-      def insert_new_rule(rule = nil)
-        rule_box = Gtk::Box.new :horizontal
-        rule_box.spacing = 8
-
-        left_operand_combo = Gtk::ComboBoxText.new
-        operator_combo = Gtk::ComboBoxText.new
-
-        value_entry = Gtk::Entry.new
-
-        date_entry = Gtk::Entry.new
-        date_entry.primary_icon_name = Gtk::Stock::EDIT
-        date_entry.primary_icon_activatable = true
-        date_entry.signal_connect("icon-press") do |entry, primary, _icon|
-          display_calendar_popup(entry) if primary.nick == "primary"
-        end
-
-        # Really hide the time part of the date entry, as the constructor
-        # does not seem to do it...
-        # ##date_entry.children[2..3].each { |x| date_entry.remove(x) }
-        # ##date_entry.spacing = 8
-        entry_label = Gtk::Label.new("")
-
-        add_button = Gtk::Button.new(label: "")
-        add_button.remove(add_button.children.first)
-        add_button << Gtk::Image.new(stock: Gtk::Stock::ADD,
-                                     size: Gtk::IconSize::BUTTON)
-
-        add_button.signal_connect("clicked") { insert_new_rule }
-
-        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|
-          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
-
-        operands = SmartLibrary::Rule::Operands::LEFT
-        operands.each do |operand|
-          left_operand_combo.append_text(operand.name)
-        end
-        operator_combo.signal_connect("changed") do
-          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
-
-          idx = @rules_box.children.index(rule_box)
-          new_rule = @smart_library_rules[idx]
-          if new_rule.nil?
-            new_rule = SmartLibrary::Rule.new(operand,
-                                              operation.first,
-                                              nil)
-            @smart_library_rules << new_rule
-          end
-          new_rule.operand = operand
-          new_rule.operation = operation.first
-          new_rule.value = nil
-        end
-        left_operand_combo.signal_connect("changed") do
-          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
-
-        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)
-
+      def make_rule_box(rule = nil)
+        box_controller = SmartLibraryRuleBox.new self
+        rule_box = box_controller.rule_box
         rule_box.show_all
-        value_entry.visible = date_entry.visible = entry_label.visible = false
-
         @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?
-            left_operand_combo.active = operand_idx
-            operator_combo.active = operation_idx
+            box_controller.left_operand_combo.active = operand_idx
+            box_controller.operator_combo.active = operation_idx
             unless rule.value.nil?
               case rule.value
               when String
-                value_entry.text = rule.value
+                box_controller.value_entry.text = rule.value
               when Time
-                date_entry.text = format_date(rule.value)
+                box_controller.date_entry.text = format_date(rule.value)
               end
             end
           end
         else
-          left_operand_combo.active = 0
+          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
@@ -296,7 +217,7 @@ module Alexandria
               value = Time.now
             end
           end
-          @smart_library_rules[i].value = value
+          smart_library_rules[i].value = value
         end
       end