alexandria-book-collection-manager 0.7.1 → 0.7.6

data/lib/alexandria/smart_library.rb

@@ -1,46 +1,35 @@
-# Copyright (C) 2004-2006 Laurent Sansonetti
-# Copyright (C) 2011, 2014 Matijs van Zuijlen
-#
-# 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.
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
 #
-# 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 '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
 
-    DIR = File.join(ENV['HOME'], '.alexandria', '.smart_libraries')
-    EXT = '.yaml'.freeze
+    EXT = ".yaml"
 
-    def initialize(name, rules, predicate_operator_rule)
+    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
-      libraries = Libraries.instance
+      @store = store
+      libraries = LibraryCollection.instance
       libraries.add_observer(self)
       self.libraries = libraries.all_regular_libraries
       # carry deleted books over from libraries that are part of the smart library
@@ -48,40 +37,7 @@ module Alexandria
       @cache = {}
     end
 
-    def self.loadall
-      a = []
-      begin
-        # Deserialize smart libraries.
-        Dir.chdir(DIR) do
-          Dir['*' + EXT].each do |filename|
-            # Skip non-regular files.
-            next unless File.stat(filename).file?
-
-            text = IO.read(filename)
-            hash = YAML.load(text)
-            begin
-              smart_library = from_hash(hash)
-              a << smart_library
-            rescue => e
-              puts "Cannot load serialized smart library: #{e}"
-              puts e.backtrace
-            end
-          end
-        end
-
-      rescue Errno::ENOENT
-        # First run and no smart libraries yet? Provide some default
-        # ones.
-        sample_smart_libraries.each do |smart_library|
-          smart_library.save
-          a << smart_library
-        end
-      end
-      a.each(&:refilter)
-      a
-    end
-
-    def self.sample_smart_libraries
+    def self.sample_smart_libraries(store)
       a = []
 
       operands = Rule::Operands::LEFT
@@ -90,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)
+      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)
+      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)
+      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)
+      a << new(_("Owned"), [rule], ALL_RULES, store)
 
       # Want books.
       rule = Rule.new(operands.find { |x| x.book_selector == :want },
@@ -117,15 +73,16 @@ 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)
+      a << new(_("Wishlist"), [rule, rule2], ALL_RULES, store)
 
       a
     end
 
-    def self.from_hash(hash)
+    def self.from_hash(hash, store)
       SmartLibrary.new(hash[:name],
                        hash[:rules].map { |x| Rule.from_hash(x) },
-                       hash[:predicate_operator_rule] == :all ? ALL_RULES : ANY_RULE)
+                       hash[:predicate_operator_rule] == :all ? ALL_RULES : ANY_RULE,
+                       store)
     end
 
     def to_hash
@@ -137,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?(Libraries)
+      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
@@ -182,7 +140,7 @@ module Alexandria
       if book
         @cache[book].yaml(book)
       else
-        File.join(DIR, @name + EXT)
+        File.join(base_dir, @name + EXT)
       end
     end
 
@@ -190,8 +148,8 @@ module Alexandria
       if book
         @cache[book].save(book)
       else
-        FileUtils.mkdir_p(DIR) unless File.exist? DIR
-        File.open(yaml, 'w') { |io| io.puts to_hash.to_yaml }
+        FileUtils.mkdir_p(base_dir) unless File.exist? base_dir
+        File.open(yaml, "w") { |io| io.puts to_hash.to_yaml }
       end
     end
 
@@ -209,19 +167,18 @@ module Alexandria
       each do |book|
         library = @cache[book]
         next unless File.exist?(library.cover(book))
+
         FileUtils.cp(File.join(library.path, book.ident + Library::EXT[:cover]),
                      File.join(somewhere, library.final_cover(book)))
       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 = []
@@ -232,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...
@@ -255,6 +213,7 @@ module Alexandria
 
     def undelete
       raise unless @@deleted_libraries.include?(self)
+
       @@deleted_libraries.delete(self)
     end
 
@@ -267,15 +226,20 @@ module Alexandria
       @libraries.each { |x| x.add_observer(self) }
     end
 
+    def base_dir
+      @store.smart_library_dir
+    end
+
     class Rule
       include GetText
       extend GetText
-      bindtextdomain(Alexandria::TEXTDOMAIN, charset: 'UTF-8')
+      bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
 
       attr_accessor :operand, :operation, :value
 
       def initialize(operand, operation, value)
         raise if operand.nil? || operation.nil? # value can be nil
+
         @operand = operand
         @operation = operation
         @value = value
@@ -299,9 +263,10 @@ module Alexandria
         }
       end
 
-      class Operand < Struct.new(:name, :klass)
-        def <=>(x)
-          name <=> x.name
+      Operand = Struct.new(:name, :klass)
+      class Operand
+        def <=>(other)
+          name <=> other.name
         end
       end
 
@@ -314,124 +279,127 @@ module Alexandria
         end
       end
 
-      class Operator < Struct.new(:sym, :name, :proc)
-        def <=>(x)
-          name <=> x.name
+      Operator = Struct.new(:sym, :name, :proc)
+      class Operator
+        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 => 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 => 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 \
@@ -475,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)
@@ -494,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 => 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