base.rb in active_archive-4.0.0

- old
+ new

@@ -7,18 +7,18 @@
 
       base.instance_eval { define_model_callbacks(:unarchive) }
     end
 
     def archived?
-      archivable? ? !!archived_at : destroyed?
+      archivable? ? !archived_at.nil? : destroyed?
     end
 
     def archivable?
       respond_to?(:archived_at)
     end
 
-    def destroy(force=nil)
+    def destroy(force = nil)
       with_transaction_returning_status do
         if unarchivable? || should_force_destroy?(force)
           permanently_delete_records_after { super() }
         else
           destroy_with_active_archive(force)
@@ -31,13 +31,13 @@
 
     def to_archival
       I18n.t("active_archive.archival.#{archived? ? :archived : :unarchived}")
     end
 
-    def unarchive(options=nil)
+    def unarchive(opts = nil)
       with_transaction_returning_status do
-        (should_unarchive_parent_first?(options) ? unarchival.reverse : unarchival).each { |r| r.call(options) }
+        (should_unarchive_parent_first?(opts) ? unarchival.reverse : unarchival).each { |record| record.call(opts) }
         self
       end
     end
 
     alias_method(:unarchive!, :unarchive)
@@ -51,44 +51,38 @@
     end
 
     private
 
     def attempt_notifying_observers(callback)
-      notify_observers(callback)
-    rescue NoMethodError
-      # RETURN
+      notify_observers(callback) if respond_to?(:notify_observers)
     end
 
-    def destroy_with_active_archive(force=nil)
+    def destroy_with_active_archive(force = nil)
       run_callbacks(:destroy) do
-        (archived? || new_record?) ? save : set_archived_at(Time.now, force)
-        true
+        archived? || new_record? ? save : set_archived_at(Time.now, force)
+        return(true)
       end
 
       archived? ? self : false
     end
 
-    def get_archived_record
+    def retrieve_archived_record
       self.class.unscoped.find(id)
     end
 
-    def get_dependent_records
+    def retrieve_dependent_records
       dependent_records = {}
 
       self.class.reflections.each do |key, reflection|
         next unless reflection.options[:dependent] == :destroy
-        next unless records = send(key)
 
-        if records.respond_to? :size
-          next unless records.size > 0
-        else
-          records = [] << records
-        end
+        records = send(key)
+        next unless records
+        records.respond_to?(:empty?) ? (next if records.empty?) : (records = [] << records)
 
         dependent_record = records.first
-        next if dependent_record.nil?
-        dependent_records[dependent_record.class] = records.map(&:id)
+        dependent_record.nil? ? next : dependent_records[dependent_record.class] = records.map(&:id)
       end
 
       dependent_records
     end
 
@@ -102,66 +96,73 @@
         end
       end
     end
 
     def permanently_delete_records_after(&block)
-      dependent_records = get_dependent_records
-      dependent_results = yield
+      dependent_records = retrieve_dependent_records
+      dependent_results = yield(block)
       permanently_delete_records(dependent_records) if dependent_results
-      return(dependent_results)
+      dependent_results
     end
 
     def unarchival
       [
-        ->(validate) { unarchive_destroyed_dependent_records(validate) },
-        ->(validate) do
+        -> (validate) { unarchive_destroyed_dependent_records(validate) },
+        lambda do |validate|
           run_callbacks(:unarchive) do
             set_archived_at(nil, validate)
             return(true)
           end
         end
       ]
     end
 
-    def unarchive_destroyed_dependent_records(force = nil)
-      self.class.reflections.select do |name, reflection|
-        "destroy" == reflection.options[:dependent].to_s && reflection.klass.archivable?
-      end.each do |name, reflection|
-        cardinality = reflection.macro.to_s.gsub("has_", "").to_sym
-        case cardinality
-        when :many
-          records = (archived_at ? set_record_window(send(name), name, reflection) : send(name))
-        when :one, :belongs_to
-          self.class.unscoped { records = [] << send(name) }
-        end
+    def dependent_records_for_unarchival(name, reflection)
+      record = send(name)
 
-        [records].flatten.compact.each { |d| d.unarchive(force) }
-        send(name, :reload)
+      case reflection.macro.to_s.gsub('has_', '').to_sym
+      when :many
+        records = archived_at ? set_record_window(record, name, reflection) : record
+      when :one, :belongs_to
+        self.class.unscoped { records = [] << record }
       end
+
+      [records].flatten.compact
     end
 
-    def set_archived_at(value, force=nil)
+    def unarchive_destroyed_dependent_records(force = nil)
+      self.class.reflections
+          .select { |_, reflection| 'destroy' == reflection.options[:dependent].to_s && reflection.klass.archivable? }
+          .each do |name, reflection|
+            dependent_records_for_unarchival(name, reflection).each { |record| record.unarchive(force) }
+          end
+    end
+
+    def set_archived_at(value, force = nil)
       return self unless archivable?
-      record = get_archived_record
+      record = retrieve_archived_record
       record.archived_at = value
 
       begin
         should_ignore_validations?(force) ? record.save(validate: false) : record.save!
-        @attributes = record.instance_variable_get("@attributes")
-      rescue => e
+        @attributes = record.instance_variable_get('@attributes')
+      rescue => error
         record.destroy
-        raise(e)
+        raise(error)
       end
     end
 
-    def set_record_window(request, name, reflection)
+    def set_record_window(_, name, reflection)
+      quoted_table_name = reflection.quoted_table_name
+      window = ActiveArchive::Settings.config.dependent_record_window
+
       send(name).unscope(where: :archived_at)
                 .where([
-                        "#{reflection.quoted_table_name}.archived_at > ? AND #{reflection.quoted_table_name}.archived_at < ?",
-                        archived_at - ActiveArchive.configuration.dependent_record_window,
-                        archived_at + ActiveArchive.configuration.dependent_record_window
-                      ])
+                         "#{quoted_table_name}.archived_at > ? AND #{quoted_table_name}.archived_at < ?",
+                         archived_at - window,
+                         archived_at + window
+                       ])
     end
 
     def should_force_destroy?(force)
       force.is_a?(Hash) ? force[:force] : (:force == force)
     end
@@ -174,5 +175,7 @@
       order.is_a?(Hash) && (true == order[:reverse])
     end
 
   end
 end
+
+ActiveRecord::Base.include(ActiveArchive::Base)