alexandria-book-collection-manager 0.7.3 → 0.7.8

data/lib/alexandria/net.rb

@@ -24,7 +24,7 @@ module Alexandria
   class WWWAgent
     def initialize
       user_agent = "Ruby #{RUBY_VERSION} #{Alexandria::TITLE}/#{Alexandria::VERSION}"
-      @extra_request_headers = { 'User-Agent' => user_agent }
+      @extra_request_headers = { "User-Agent" => user_agent }
     end
 
     def self.transport
@@ -38,18 +38,17 @@ module Alexandria
       @extra_request_headers.each_pair do |header_name, value|
         req.add_field(header_name, value)
       end
-      res = WWWAgent.transport.start(uri.host, uri.port) { |http|
+      WWWAgent.transport.start(uri.host, uri.port) do |http|
         http.request(req)
-      }
-      res
+      end
     end
 
     def language=(lang)
-      @extra_request_headers['Accept-Language'] = lang.to_s
+      @extra_request_headers["Accept-Language"] = lang.to_s
     end
 
     def user_agent=(agent_string)
-      @extra_request_headers['User-Agent'] = agent_string
+      @extra_request_headers["User-Agent"] = agent_string
     end
   end
 end

data/lib/alexandria/preferences.rb

@@ -4,21 +4,21 @@
 #
 # See the file README.md for authorship and licensing information.
 
-require 'singleton'
-require 'set'
-require 'alexandria/default_preferences'
+require "singleton"
+require "set"
+require "alexandria/default_preferences"
 
 module Alexandria
   class Preferences
     include Singleton
     include Logging
 
-    APP_DIR = '/apps/alexandria'
-    HTTP_PROXY_DIR = '/system/http_proxy'
-    HTTP_PROXY_MODE = '/system/proxy/mode'
-    URL_HANDLERS_DIR = '/desktop/gnome/url-handlers'
+    APP_DIR = "/apps/alexandria"
+    HTTP_PROXY_DIR = "/system/http_proxy"
+    HTTP_PROXY_MODE = "/system/proxy/mode"
+    URL_HANDLERS_DIR = "/desktop/gnome/url-handlers"
 
-    GCONFTOOL = 'gconftool-2'
+    GCONFTOOL = "gconftool-2"
 
     def initialize
       @alexandria_settings = {}
@@ -46,38 +46,35 @@ module Alexandria
     end
 
     def save!
-      log.debug { 'preferences save!' }
+      log.debug { "preferences save!" }
       @changed_settings.each do |variable_name|
-        log.debug { "saving preference #{variable_name} / #{@alexandria_settings[variable_name].class}" }
+        log.debug do
+          klass = @alexandria_settings[variable_name].class
+          "saving preference #{variable_name} / #{klass}"
+        end
         generic_save_setting(variable_name, @alexandria_settings[variable_name])
       end
       @changed_settings.clear
     end
 
-    def method_missing(id, *args)
-      method = id.id2name
-      if (match = /(.*)=$/.match(method))
-        if args.length != 1
-          raise "Set method #{method} should be called with " \
-            "only one argument (was called with #{args.length})"
-        end
-        variable_name = match[1]
-        new_value = args.first
-        generic_setter(variable_name, new_value)
-      else
-        unless args.empty?
-          raise "Get method #{method} should be called " \
-            "without argument (was called with #{args.length})"
-        end
-        generic_getter(method)
-      end
-    end
-
     def remove_preference(variable_name)
       @alexandria_settings.delete(variable_name)
       @changed_settings << variable_name
     end
 
+    DEFAULT_VALUES.each_key do |var|
+      define_method(var) { generic_getter var }
+      define_method("#{var}=") { |val| generic_setter var, val }
+    end
+
+    def get_variable(variable_name)
+      generic_getter(variable_name.to_s)
+    end
+
+    def set_variable(variable_name, value)
+      generic_setter(variable_name.to_s, value)
+    end
+
     private
 
     ##
@@ -107,7 +104,7 @@ module Alexandria
     end
 
     def generic_save_setting(variable_name, new_value)
-      var_path = APP_DIR + '/' + variable_name
+      var_path = APP_DIR + "/" + variable_name
       if new_value.is_a?(Array)
         # when setting array, first remove nil elements (fixing #9007)
         new_value.compact!
@@ -125,7 +122,9 @@ module Alexandria
       end
     rescue StandardError => ex
       log.debug { new_value.inspect }
-      log.error { "Could not set GConf setting #{variable_name} to value: #{new_value.inspect}" }
+      log.error do
+        "Could not set GConf setting #{variable_name} to value: #{new_value.inspect}"
+      end
       log << ex.message
       log << ex
     end
@@ -135,14 +134,15 @@ module Alexandria
     ##
 
     def get_gconf_type(value)
-      if value.is_a?(String)
-        'string'
-      elsif value.is_a?(Integer)
-        'int'
-      elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
-        'bool'
+      case value
+      when String
+        "string"
+      when Integer
+        "int"
+      when TrueClass, FalseClass
+        "bool"
       else
-        'string'
+        "string"
       end
     end
 
@@ -150,7 +150,7 @@ module Alexandria
       # NOTE we must check between list and pair...
 
       list_type = get_gconf_type(new_list.first)
-      if list_type == 'int' && new_list.size == 2
+      if list_type == "int" && new_list.size == 2
         # treat this as a pair of int
         a = new_list[0]
         b = new_list[1]
@@ -163,29 +163,29 @@ module Alexandria
     end
 
     def make_list_string(list)
-      list.map! { |x| x.gsub(/\"/, '\\"') } if get_gconf_type(list.first) == 'string'
-      contents = list.join(',')
-      '[' + contents + ']'
+      list.map! { |x| x.gsub(/"/, '\\"') } if get_gconf_type(list.first) == "string"
+      contents = list.join(",")
+      "[" + contents + "]"
     end
 
     def exec_gconf_set(var_path, new_value)
-      if /cols_width/ =~ var_path
-        puts new_value
+      if /cols_width/.match?(var_path)
+        log.debug { new_value }
 
         # new_value = {}
       end
       type = get_gconf_type(new_value)
       value_str = new_value
       if new_value.is_a? String
-        new_value.gsub!(/\"/, '\\"')
+        new_value = new_value.gsub(/"/, '\\"')
         value_str = "\"#{new_value}\""
       end
-      puts value_str if /cols_width/ =~ var_path
+      log.debug { value_str } if /cols_width/.match?(var_path)
       `gconftool-2 --type #{type} --set #{var_path} #{value_str}`
     end
 
     def exec_gconf_unset(variable_name)
-      `#{GCONFTOOL} --unset #{APP_DIR + '/' + variable_name}`
+      `#{GCONFTOOL} --unset #{APP_DIR + "/" + variable_name}`
     end
 
     ##
@@ -205,14 +205,14 @@ module Alexandria
     def load_http_proxy_settings
       http_proxy_vars = `#{GCONFTOOL} --recursive-list #{HTTP_PROXY_DIR}`
       http_proxy = gconftool_values_to_hash(http_proxy_vars)
-      if http_proxy['use_http_proxy']
+      if http_proxy["use_http_proxy"]
         proxy_mode = `#{GCONFTOOL} --get #{HTTP_PROXY_MODE}`.chomp
-        if proxy_mode == 'manual'
+        if proxy_mode == "manual"
           @use_http_proxy = true
-          @proxy_host = http_proxy['host']
-          @proxy_port = http_proxy['port']
-          @proxy_user = http_proxy['authentication_user']
-          @proxy_password = http_proxy['authentication_n_password']
+          @proxy_host = http_proxy["host"]
+          @proxy_port = http_proxy["port"]
+          @proxy_user = http_proxy["authentication_user"]
+          @proxy_password = http_proxy["authentication_n_password"]
         end
       end
       @http_proxy_loaded = true
@@ -226,7 +226,9 @@ module Alexandria
       hash = {}
       vals = all_vals.split(/$/)
       vals.each do |val|
-        hash[Regexp.last_match[1]] = discriminate(Regexp.last_match[2]) if /([a-z_]+) = (.*)/ =~ val
+        if /([a-z_]+) = (.*)/ =~ val
+          hash[Regexp.last_match[1]] = discriminate(Regexp.last_match[2])
+        end
       end
       hash
     end
@@ -235,20 +237,21 @@ module Alexandria
     # gconftool. This is not fool-proof, but it *does* work for the
     # range of values used by Alexandria.
     def discriminate(value)
-      if value == 'true'        # bool
+      case value
+      when "true" # bool
         true
-      elsif value == 'false'    # bool
+      when "false"    # bool
         false
-      elsif value =~ /^[0-9]+$/   # int
+      when /^[0-9]+$/ # int
         value.to_i
-      elsif value =~ /^\[(.*)\]$/ # list (assume of type String)
-        Regexp.last_match[1].split(',')
-      elsif value =~ /^\((.*)\)$/ # pair (assume of type int)
+      when /^\[(.*)\]$/ # list (assume of type String)
+        Regexp.last_match[1].split(",")
+      when /^\((.*)\)$/ # pair (assume of type int)
         begin
-          pair = Regexp.last_match[1].split(',')
-          return [discriminate(pair.first), discriminate(pair.last)]
+          pair = Regexp.last_match[1].split(",")
+          [discriminate(pair.first), discriminate(pair.last)]
         rescue StandardError
-          return [0, 0]
+          [0, 0]
         end
       else
         value # string

data/lib/alexandria/scanners.rb

@@ -40,8 +40,8 @@ module Alexandria
       registry.find { |scanner| scanner.name == name }
     end
 
-    def self.each_scanner
-      registry.each { |scanner| yield scanner }
+    def self.each_scanner(&block)
+      registry.each(&block)
     end
 
     private_class_method :registry

data/lib/alexandria/scanners/{cuecat.rb → cue_cat.rb}

@@ -18,27 +18,27 @@
 # write to the Free Software Foundation, Inc., 51 Franklin Street,
 # Fifth Floor, Boston, MA 02110-1301 USA.
 
-require 'alexandria/scanners'
+require "alexandria/scanners"
 
 module Alexandria
   module Scanners
     class CueCat
-      include Alexandria::Logging
+      include Logging
 
       def name
-        'CueCat'
+        "CueCat"
       end
 
       def display_name
-        'CueCat'
+        "CueCat"
       end
 
       # Checks if data looks like cuecat input
       def match?(data)
         data = data.chomp
-        return false if data[-1] != '.'
+        return false if data[-1] != "."
 
-        fields = data.split('.')
+        fields = data.split(".")
         return false if fields.size != 4
         return false if fields[2].size != 4
 
@@ -50,13 +50,13 @@ module Alexandria
       # domain perl implementation.
       def decode(data)
         data = data.chomp
-        fields = data.split('.')
+        fields = data.split(".")
         fields.shift # First part is gibberish
         fields.shift # Second part is cuecat serial number
         type, code = fields.map { |field| decode_field(field) }
 
-        if type == 'IB5'
-          type = 'IBN'
+        if type == "IB5"
+          type = "IBN"
           code = code[0, 13]
         end
 
@@ -64,33 +64,33 @@ module Alexandria
           if Library.valid_upc? code
             isbn13 = Library.canonicalise_ean(code)
             code = isbn13
-            type = 'IBN'
+            type = "IBN"
           end
         rescue StandardError
           log.debug { "Cannot translate UPC (#{type}) code #{code} to ISBN" }
         end
 
-        return code if type == 'IBN'
+        return code if type == "IBN"
 
-        raise "Don't know how to handle type #{type} (barcode: #{code})"
+        raise format(_("Don't know how to handle type %<type>s (barcode: %<code>s)"),
+                     type: type, code: code)
       end
 
       private
 
       def decode_field(encoded)
-        seq = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-'
+        seq = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-"
 
         chars   = encoded.split(//)
         values  = chars.map { |c| seq.index(c) }
 
         padding = pad(values)
         result  = calc(values)
-        result  = result[0, result.length - padding]
-        result
+        result[0, result.length - padding]
       end
 
       def calc(values)
-        result = ''
+        result = ""
         until values.empty?
           num = ((values[0] << 6 | values[1]) << 6 | values[2]) << 6 | values[3]
           result += ((num >> 16) ^ 67).chr
@@ -106,7 +106,7 @@ module Alexandria
         length = array.length % 4
 
         if length.nonzero?
-          raise 'Error parsing CueCat input' if length == 1
+          raise _("Error parsing CueCat input") if length == 1
 
           length = 4 - length
           length.times { array.push(0) }

data/lib/alexandria/scanners/keyboard.rb

@@ -18,7 +18,7 @@
 # write to the Free Software Foundation, Inc., 51 Franklin Street,
 # Fifth Floor, Boston, MA 02110-1301 USA.
 
-require 'alexandria/scanners'
+require "alexandria/scanners"
 
 module Alexandria
   module Scanners
@@ -27,28 +27,28 @@ module Alexandria
     # like this.)
     class KeyboardWedge
       def name
-        'KeyboardWedge'
+        "KeyboardWedge"
       end
 
       def display_name
-        'Keyboard Wedge'
+        "Keyboard Wedge"
       end
 
       # Checks if data looks like a completed scan
       def match?(data)
-        data.gsub!(/\s/, '')
+        data.gsub!(/\s/, "")
         (data =~ /[0-9]{12,18}/) || (data =~ /[0-9]{9}[0-9Xx]/)
       end
 
       # Gets the essential 13-digits from an ISBN barcode (EAN-13)
       def decode(data)
-        data.gsub!(/\s/, '')
+        data.gsub!(/\s/, "")
         if data.length == 10
-          return data
+          data
         elsif data.length >= 13
-          return data[0, 13]
+          data[0, 13]
         else
-          raise "Unknown scan data #{data}"
+          raise format(_("Unknown scan data %s<data>"), data: data)
         end
       end
     end

data/lib/alexandria/smart_library.rb

@@ -5,27 +5,27 @@
 # See the file README.md for authorship and licensing information.
 
 # require 'date'
-require 'time'
+require "time"
 
 module Alexandria
   class SmartLibrary < Array
     include Logging
     include GetText
     extend GetText
-    bindtextdomain(Alexandria::TEXTDOMAIN, charset: 'UTF-8')
+    bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
     ALL_RULES = 1
     ANY_RULE = 2
-    attr_reader :name
+    attr_reader :name, :n_rated
     attr_accessor :rules, :predicate_operator_rule, :deleted_books
 
-    EXT = '.yaml'
+    EXT = ".yaml"
 
     def initialize(name, rules, predicate_operator_rule, store = nil)
       super()
       raise if name.nil? || rules.nil? || predicate_operator_rule.nil?
 
-      @name = name.dup.force_encoding('UTF-8')
+      @name = name.dup.force_encoding("UTF-8")
       @rules = rules
       @predicate_operator_rule = predicate_operator_rule
       @store = store
@@ -46,25 +46,25 @@ module Alexandria
       rule = Rule.new(operands.find { |x| x.book_selector == :rating },
                       Rule::Operators::IS,
                       Book::MAX_RATING_STARS.to_s)
-      a << new(_('Favorite'), [rule], ALL_RULES, store)
+      a << new(_("Favorite"), [rule], ALL_RULES, store)
 
       # Loaned books.
       rule = Rule.new(operands.find { |x| x.book_selector == :loaned },
                       Rule::Operators::IS_TRUE,
                       nil)
-      a << new(_('Loaned'), [rule], ALL_RULES, store)
+      a << new(_("Loaned"), [rule], ALL_RULES, store)
 
       # Redd books.
       rule = Rule.new(operands.find { |x| x.book_selector == :redd },
                       Rule::Operators::IS_TRUE,
                       nil)
-      a << new(_('Read'), [rule], ALL_RULES, store)
+      a << new(_("Read"), [rule], ALL_RULES, store)
 
       # Own books.
       rule = Rule.new(operands.find { |x| x.book_selector == :own },
                       Rule::Operators::IS_TRUE,
                       nil)
-      a << new(_('Owned'), [rule], ALL_RULES, store)
+      a << new(_("Owned"), [rule], ALL_RULES, store)
 
       # Want books.
       rule = Rule.new(operands.find { |x| x.book_selector == :want },
@@ -73,7 +73,7 @@ module Alexandria
       rule2 = Rule.new(operands.find { |x| x.book_selector == :own },
                        Rule::Operators::IS_NOT_TRUE,
                        nil)
-      a << new(_('Wishlist'), [rule, rule2], ALL_RULES, store)
+      a << new(_("Wishlist"), [rule, rule2], ALL_RULES, store)
 
       a
     end
@@ -94,22 +94,23 @@ module Alexandria
     end
 
     def name=(new_name)
-      if @name != new_name
-        old_yaml = yaml
-        @name = new_name
-        FileUtils.mv(old_yaml, yaml)
-        save
-      end
+      return unless @name != new_name
+
+      old_yaml = yaml
+      @name = new_name
+      FileUtils.mv(old_yaml, yaml)
+      save
     end
 
     def update(*params)
-      if params.first.is_a?(LibraryCollection)
+      case params.first
+      when LibraryCollection
         libraries, _, library = params
         unless library.is_a?(self.class)
           self.libraries = libraries.all_libraries
           refilter
         end
-      elsif params.first.is_a?(Library)
+      when Library
         refilter
       end
     end
@@ -148,7 +149,7 @@ module Alexandria
         @cache[book].save(book)
       else
         FileUtils.mkdir_p(base_dir) unless File.exist? base_dir
-        File.open(yaml, 'w') { |io| io.puts to_hash.to_yaml }
+        File.open(yaml, "w") { |io| io.puts to_hash.to_yaml }
       end
     end
 
@@ -172,14 +173,12 @@ module Alexandria
       end
     end
 
-    attr_reader :n_rated
-
     def n_unrated
       length - n_rated
     end
 
-    def ==(object)
-      object.is_a?(self.class) && object.name == name
+    def ==(other)
+      other.is_a?(self.class) && other.name == name
     end
 
     @@deleted_libraries = []
@@ -190,15 +189,16 @@ module Alexandria
 
     def self.really_delete_deleted_libraries
       @@deleted_libraries.each do |library|
-        puts "Deleting smart library file (#{yaml})" if $DEBUG
+        log.debug { "Deleting smart library file (#{yaml})" }
         FileUtils.rm_rf(library.yaml)
       end
     end
 
     def delete
       if @@deleted_libraries.include?(self)
-        puts 'Already deleted a SmartLibrary with this name'
-        puts '(this might mess up undeletes...)'
+        log.info do
+          "Already deleted a SmartLibrary with this name (this might mess up undeletes)"
+        end
         FileUtils.rm_rf(yaml)
         # so we just delete the old smart library, and
         # 'pending' delete the new one of the same name...
@@ -233,7 +233,7 @@ module Alexandria
     class Rule
       include GetText
       extend GetText
-      bindtextdomain(Alexandria::TEXTDOMAIN, charset: 'UTF-8')
+      bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
       attr_accessor :operand, :operation, :value
 
@@ -265,8 +265,8 @@ module Alexandria
 
       Operand = Struct.new(:name, :klass)
       class Operand
-        def <=>(x)
-          name <=> x.name
+        def <=>(other)
+          name <=> other.name
         end
       end
 
@@ -281,123 +281,125 @@ module Alexandria
 
       Operator = Struct.new(:sym, :name, :proc)
       class Operator
-        def <=>(x)
-          name <=> x.name
+        def <=>(other)
+          name <=> other.name
         end
       end
 
       module Operands
         include GetText
         extend GetText
-        bindtextdomain(Alexandria::TEXTDOMAIN, charset: 'UTF-8')
+        bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
         LEFT = [
-          LeftOperand.new(:title, _('Title'), String),
-          LeftOperand.new(:isbn, _('ISBN'), String),
-          LeftOperand.new(:authors, _('Authors'), String),
-          LeftOperand.new(:publisher, _('Publisher'), String),
-          LeftOperand.new(:publishing_year, _('Publish Year'), Integer),
-          LeftOperand.new(:edition, _('Binding'), String),
-          LeftOperand.new(:rating, _('Rating'), Integer),
-          LeftOperand.new(:notes, _('Notes'), String),
-          LeftOperand.new(:tags, _('Tags'), Array),
-          LeftOperand.new(:loaned, _('Loaning State'), TrueClass),
-          LeftOperand.new(:loaned_since, _('Loaning Date'), Time),
-          LeftOperand.new(:loaned_to, _('Loaning Person'), String),
-          LeftOperand.new(:redd, _('Read'), TrueClass),
-          LeftOperand.new(:redd_when, _('Date Read'), Time),
-          LeftOperand.new(:own, _('Own'), TrueClass),
-          LeftOperand.new(:want, _('Want'), TrueClass),
+          LeftOperand.new(:title, _("Title"), String),
+          LeftOperand.new(:isbn, _("ISBN"), String),
+          LeftOperand.new(:authors, _("Authors"), String),
+          LeftOperand.new(:publisher, _("Publisher"), String),
+          LeftOperand.new(:publishing_year, _("Publish Year"), Integer),
+          LeftOperand.new(:edition, _("Binding"), String),
+          LeftOperand.new(:rating, _("Rating"), Integer),
+          LeftOperand.new(:notes, _("Notes"), String),
+          LeftOperand.new(:tags, _("Tags"), Array),
+          LeftOperand.new(:loaned, _("Loaning State"), TrueClass),
+          LeftOperand.new(:loaned_since, _("Loaning Date"), Time),
+          LeftOperand.new(:loaned_to, _("Loaning Person"), String),
+          LeftOperand.new(:redd, _("Read"), TrueClass),
+          LeftOperand.new(:redd_when, _("Date Read"), Time),
+          LeftOperand.new(:own, _("Own"), TrueClass),
+          LeftOperand.new(:want, _("Want"), TrueClass),
         ].sort
 
         STRING = Operand.new(nil, String)
         STRING_ARRAY = Operand.new(nil, String)
         INTEGER = Operand.new(nil, Integer)
         TIME = Operand.new(nil, Time)
-        DAYS = Operand.new(_('days'), Integer)
+        DAYS = Operand.new(_("days"), Integer)
       end
 
       module Operators
         include Logging
         include GetText
         extend GetText
-        bindtextdomain(Alexandria::TEXTDOMAIN, charset: 'UTF-8')
+        bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
         IS_TRUE = Operator.new(:is_true,
-                               _('is set'),
+                               _("is set"),
                                proc { |x| x })
         IS_NOT_TRUE = Operator.new(:is_not_true,
-                                   _('is not set'),
+                                   _("is not set"),
                                    proc { |x| !x })
         IS = Operator.new(:is,
-                          _('is'),
+                          _("is"),
                           proc { |x, y| x == y })
         IS_NOT = Operator.new(:is_not,
-                              _('is not'),
+                              _("is not"),
                               proc { |x, y| x != y })
         CONTAINS = Operator.new(:contains,
-                                _('contains'),
+                                _("contains"),
                                 proc { |x, y| x.include?(y) })
         DOES_NOT_CONTAIN = Operator.new(:does_not_contain,
-                                        _('does not contain'),
+                                        _("does not contain"),
                                         proc { |x, y| !x.include?(y) })
         STARTS_WITH = Operator.new(:starts_with,
-                                   _('starts with'),
+                                   _("starts with"),
                                    proc { |x, y| /^#{y}/.match(x) })
         ENDS_WITH = Operator.new(:ends_with,
-                                 _('ends with'),
+                                 _("ends with"),
                                  proc { |x, y| /#{y}$/.match(x) })
         IS_GREATER_THAN = Operator.new(:is_greater_than,
-                                       _('is greater than'),
+                                       _("is greater than"),
                                        proc { |x, y| x > y })
         IS_LESS_THAN = Operator.new(:is_less_than,
-                                    _('is less than'),
+                                    _("is less than"),
                                     proc { |x, y| x < y })
         IS_AFTER = Operator.new(:is_after,
-                                _('is after'),
+                                _("is after"),
                                 proc { |x, y| x.to_i > y.to_i && !x.nil? })
         IS_BEFORE = Operator.new(:is_before,
-                                 _('is before'),
+                                 _("is before"),
                                  proc { |x, y| x.to_i < y.to_i && !x.nil? })
-        IS_IN_LAST = Operator.new(:is_in_last_days,
-                                  _('is in last'),
-                                  proc { |x, y|
-                                    begin
-                                      if x.nil? || x.empty?
-                                        false
-                                      else
-                                        log.debug { "Given Date: #{x.inspect} #{x.class}" }
-                                        given_date = Time.parse(x)
-                                        days = y.to_i * (24 * 60 * 60)
-
-                                        Time.now - given_date <= days
-                                      end
-                                    rescue StandardError => ex
-                                      trace = ex.backtrace.join("\n >")
-                                      log.warn { "Date matching failed #{ex} #{trace}" }
-                                      false
-                                    end
-                                  })
-        IS_NOT_IN_LAST = Operator.new(:is_not_in_last_days,
-                                      _('is not in last'),
-                                      proc { |x, y|
-                                        begin
-                                          if x.nil? || x.empty?
-                                            false
-                                          else
-                                            log.debug { "Given Date: #{x.inspect} #{x.class}" }
-                                            given_date = Time.parse(x)
-                                            days = y.to_i * (24 * 60 * 60)
-
-                                            Time.now - given_date > days
-                                          end
-                                        rescue StandardError => ex
-                                          trace = ex.backtrace.join("\n >")
-                                          log.warn { "Date matching failed #{ex} #{trace}" }
-                                          false
-                                        end
-                                        # Time.now - x > 3600*24*y
-                                      })
+        IS_IN_LAST =
+          Operator.new(:is_in_last_days,
+                       _("is in last"),
+                       proc { |x, y|
+                         begin
+                           if x.nil? || x.empty?
+                             false
+                           else
+                             log.debug { "Given Date: #{x.inspect} #{x.class}" }
+                             given_date = Time.parse(x)
+                             days = y.to_i * (24 * 60 * 60)
+
+                             Time.now - given_date <= days
+                           end
+                         rescue StandardError => ex
+                           trace = ex.backtrace.join("\n >")
+                           log.warn { "Date matching failed #{ex} #{trace}" }
+                           false
+                         end
+                       })
+        IS_NOT_IN_LAST =
+          Operator.new(:is_not_in_last_days,
+                       _("is not in last"),
+                       proc { |x, y|
+                         begin
+                           if x.nil? || x.empty?
+                             false
+                           else
+                             log.debug { "Given Date: #{x.inspect} #{x.class}" }
+                             given_date = Time.parse(x)
+                             days = y.to_i * (24 * 60 * 60)
+
+                             Time.now - given_date > days
+                           end
+                         rescue StandardError => ex
+                           trace = ex.backtrace.join("\n >")
+                           log.warn { "Date matching failed #{ex} #{trace}" }
+                           false
+                         end
+                         # Time.now - x > 3600*24*y
+                       })
 
         ALL = constants.map \
           { |x| module_eval(x.to_s) }.select \
@@ -441,15 +443,15 @@ module Alexandria
 
       def self.operations_for_operand(operand)
         case operand.klass.name
-        when 'String'
+        when "String"
           STRING_OPERATORS.map { |x| [x, Operands::STRING] }
-        when 'Array'
+        when "Array"
           STRING_ARRAY_OPERATORS.map { |x| [x, Operands::STRING] }
-        when 'Integer'
+        when "Integer"
           INTEGER_OPERATORS.map { |x| [x, Operands::INTEGER] }
-        when 'TrueClass'
+        when "TrueClass"
           BOOLEAN_OPERATORS.map { |x| [x, nil] }
-        when 'Time'
+        when "Time"
           TIME_OPERATORS.map do |x|
             if (x == Operators::IS_IN_LAST) ||
                 (x == Operators::IS_NOT_IN_LAST)
@@ -460,17 +462,13 @@ module Alexandria
             end
           end
         else
-          raise "invalid operand klass #{operand.klass}"
+          raise format(_("invalid operand klass %<klass>s"), klass: operand.klass)
         end
       end
 
       def filter_proc
         proc do |book|
-          begin
-            left_value = book.send(@operand.book_selector)
-          rescue StandardError => e
-            puts e.message
-          end
+          left_value = book.send(@operand.book_selector)
           right_value = @value
           if right_value.is_a?(String)
             left_value = left_value.to_s.downcase