archival_record 2.0.2 → 3.0.1

data/lib/archival_record_core/archival_record.rb

@@ -3,17 +3,18 @@ module ArchivalRecordCore
 
     require "digest/md5"
 
-    unless defined?(MissingArchivalColumnError) == "constant" && MissingArchivalColumnError.class == Class
+    unless defined?(MissingArchivalColumnError) == "constant" && MissingArchivalColumnError.instance_of?(Class)
       MissingArchivalColumnError = Class.new(ActiveRecord::ActiveRecordError)
     end
-    unless defined?(CouldNotArchiveError) == "constant" && CouldNotArchiveError.class == Class
+    unless defined?(CouldNotArchiveError) == "constant" && CouldNotArchiveError.instance_of?(Class)
       CouldNotArchiveError = Class.new(ActiveRecord::ActiveRecordError)
     end
-    unless defined?(CouldNotUnarchiveError) == "constant" && CouldNotUnarchiveError.class == Class
+    unless defined?(CouldNotUnarchiveError) == "constant" && CouldNotUnarchiveError.instance_of?(Class)
       CouldNotUnarchiveError = Class.new(ActiveRecord::ActiveRecordError)
     end
 
     def self.included(base)
+      super
       base.extend ActMethods
     end
 
@@ -24,6 +25,8 @@ module ArchivalRecordCore
 
         include InstanceMethods
 
+        setup_options(options)
+
         setup_validations(options)
 
         setup_scopes
@@ -33,10 +36,17 @@ module ArchivalRecordCore
 
       # Deprecated: Please use `archival_record` instead
       def acts_as_archival(options = {})
-        ActiveSupport::Deprecation.warn("`acts_as_archival` is deprecated.  Please use `archival_record` instead.")
+        ActiveSupport::Deprecation.new("3.0", "ArchivalRecord")
         archival_record(options)
       end
 
+      private def setup_options(options)
+        default_options = { readonly_when_archived: false, archive_dependents: true }
+        options.reverse_merge!(default_options)
+
+        define_method(:archive_dependents?) { options[:archive_dependents] }
+      end
+
       private def setup_validations(options)
         before_validation :raise_if_not_archival
         validate :readonly_when_archived if options[:readonly_when_archived]
@@ -45,9 +55,13 @@ module ArchivalRecordCore
       private def setup_scopes
         scope :archived, -> { where.not(archived_at: nil).where.not(archive_number: nil) }
         scope :unarchived, -> { where(archived_at: nil, archive_number: nil) }
-        scope :archived_from_archive_number, (lambda do |head_archive_number|
-          where(["archived_at IS NOT NULL AND archive_number = ?", head_archive_number])
-        end)
+        scope :archived_from_archive_number,
+              (lambda do |head_archive_number|
+                 table = arel_table
+                 archive_at_check = table[:archived_at].not_eq(nil)
+                 archive_number_check = table[:archive_number].eq(head_archive_number)
+                 where(archive_at_check.and(archive_number_check))
+               end)
       end
 
       private def setup_callbacks
@@ -73,6 +87,12 @@ module ArchivalRecordCore
       private def define_callback_dsl_method(callbackable_type, action)
         # rubocop:disable Security/Eval
         eval <<-END_CALLBACKS, binding, __FILE__, __LINE__ + 1
+          # unless defined?(before_archive)
+          #   def before_archive(*args, &blk)
+          #     set_callback(:archive, :before, *args, &blk)
+          #   end
+          # end
+
           unless defined?(#{callbackable_type}_#{action})
             def #{callbackable_type}_#{action}(*args, &blk)
               set_callback(:#{action}, :#{callbackable_type}, *args, &blk)
@@ -99,7 +119,8 @@ module ArchivalRecordCore
         missing_columns << "archived_at" unless respond_to?(:archived_at)
         return if missing_columns.blank?
 
-        raise MissingArchivalColumnError.new("Add '#{missing_columns.join "', '"}' column(s) to '#{self.class.name}' to make it archival")
+        raise(MissingArchivalColumnError,
+              "Add '#{missing_columns.join "', '"}' column(s) to '#{self.class.name}' to make it archival")
       end
 
       def archived?
@@ -138,24 +159,20 @@ module ArchivalRecordCore
         AssociationOperation::Unarchive.new(self, head_archive_number).execute
       end
 
-      private def execute_archival_action(action)
+      private def execute_archival_action(action, &block)
+        execution_result = false
         self.class.transaction do
-          # rubocop: disable Style/RescueStandardError
-          begin
-            success = run_callbacks(action) { yield }
-            return !!success
-          rescue => e
-            handle_archival_action_exception(e)
-          end
-          # rubocop: enable Style/RescueStandardError
+          execution_result = !!run_callbacks(action, &block)
+        rescue StandardError => e
+          handle_archival_action_exception(e)
         end
-        false
+        execution_result
       end
 
       private def handle_archival_action_exception(exception)
-        ActiveRecord::Base.logger.try(:debug, exception.message)
-        ActiveRecord::Base.logger.try(:debug, exception.backtrace)
-        raise ActiveRecord::Rollback
+        ActiveRecord::Base.logger.try(:error, exception.message)
+        ActiveRecord::Base.logger.try(:error, exception.backtrace)
+        raise(ActiveRecord::Rollback)
       end
 
     end

data/lib/archival_record_core/archival_record_active_record_methods.rb

@@ -2,6 +2,7 @@ module ArchivalRecordCore
   module ArchivalRecordActiveRecordMethods
 
     def self.included(base)
+      super
       base.extend ARClassMethods
       base.send :include, ARInstanceMethods
     end
@@ -26,7 +27,7 @@ module ArchivalRecordCore
 
       def archive_all!
         error_message = "The #{klass} must implement 'act_on_archivals' in order to call `archive_all!`"
-        raise NotImplementedError.new(error_message) unless archival?
+        raise(NotImplementedError, error_message) unless archival?
 
         head_archive_number = Digest::MD5.hexdigest("#{klass}#{Time.now.utc.to_i}")
         each { |record| record.archive!(head_archive_number) }.tap { reset }
@@ -34,7 +35,7 @@ module ArchivalRecordCore
 
       def unarchive_all!
         error_message = "The #{klass} must implement 'act_on_archivals' in order to call `unarchive_all!`"
-        raise NotImplementedError.new(error_message) unless archival?
+        raise(NotImplementedError, error_message) unless archival?
 
         each(&:unarchive!).tap { reset }
       end

data/lib/archival_record_core/association_operation/base.rb

@@ -11,8 +11,10 @@ module ArchivalRecordCore
         end
 
         def execute
+          return unless model.archive_dependents?
+
           each_archivable_association do |association|
-            act_on_association(association) if association_conditions_met? association
+            act_on_association(association) if association_conditions_met?(association)
           end
         end
 
@@ -45,7 +47,7 @@ module ArchivalRecordCore
         end
 
         def act_on_archivals(_scope)
-          raise NotImplementedError.new("The #{self.class} hasn't implemented 'act_on_archivals(scope)'")
+          raise(NotImplementedError, "The #{self.class} hasn't implemented 'act_on_archivals(scope)'")
         end
 
       end

data/test/application_record_test.rb

@@ -11,7 +11,7 @@ if defined?(ApplicationRecord)
     end
 
     test "unarchive unarchives archival records" do
-      archival = ApplicationRecordRow.create!(archived_at: Time.now, archive_number: 1)
+      archival = ApplicationRecordRow.create!(archived_at: Time.now.utc, archive_number: 1)
       archival.unarchive!
       assert_not archival.reload.archived?
     end

data/test/archive_dependents_option_test.rb

@@ -0,0 +1,54 @@
+require_relative "test_helper"
+
+class ArchiveDependentsOptionTest < ActiveSupport::TestCase
+
+  test "archive_dependents option will leave dependent archival records alone when parent is archived" do
+    archival = IgnoreDependentsArchival.create!
+    child = archival.ignorable_dependents.create!
+
+    assert archival.archival?
+    assert child.archival?
+
+    archival.archive!
+
+    assert archival.reload.archived?
+    assert_not child.reload.archived?
+  end
+
+  test "archive_dependents option will leave dependent archival records alone when parent is unarchived" do
+    archival = IgnoreDependentsArchival.create!
+    child = archival.ignorable_dependents.create!
+
+    assert archival.archival?
+    assert child.archival?
+
+    # This is simulating an unlikely scenario where the option has been added after records have been
+    # archived as a set but we want to unarchive after adding the option.
+    archival.archive!
+    child.update!(archived_at: archival.archived_at, archive_number: archival.archive_number)
+
+    archival.unarchive!
+
+    assert_not archival.reload.archived?
+    assert child.reload.archived?
+  end
+
+  test "archive_dependents option will work normally if set to true" do
+    archival = ExplicitActOnDependentsArchival.create!
+    child = archival.nonignorable_dependents.create!
+
+    assert archival.archival?
+    assert child.archival?
+
+    archival.archive!
+
+    assert archival.reload.archived?
+    assert child.reload.archived?
+
+    archival.unarchive!
+
+    assert_not archival.reload.archived?
+    assert_not child.reload.archived?
+  end
+
+end

data/test/basic_test.rb

@@ -9,7 +9,7 @@ class BasicTest < ActiveSupport::TestCase
   end
 
   test "unarchive unarchives archival records" do
-    archival = Archival.create!(archived_at: Time.now, archive_number: 1)
+    archival = Archival.create!(archived_at: Time.now.utc, archive_number: 1)
     archival.unarchive!
     assert_equal false, archival.reload.archived?
   end
@@ -26,23 +26,23 @@ class BasicTest < ActiveSupport::TestCase
   end
 
   test "unarchive returns true on success" do
-    normal = Archival.create!(archived_at: Time.now, archive_number: "1")
+    normal = Archival.create!(archived_at: Time.now.utc, archive_number: "1")
     assert_equal true, normal.unarchive!
   end
 
   test "unarchive returns false on failure" do
-    readonly = Archival.create!(archived_at: Time.now, archive_number: "1")
+    readonly = Archival.create!(archived_at: Time.now.utc, archive_number: "1")
     readonly.readonly!
     assert_equal false, readonly.unarchive!
   end
 
   test "archive sets archived_at to the time of archiving" do
     archival = Archival.create!
-    before = DateTime.now
+    before = DateTime.now.utc
     sleep(0.001)
     archival.archive!
     sleep(0.001)
-    after = DateTime.now
+    after = DateTime.now.utc
     assert before < archival.archived_at.to_datetime
     assert after > archival.archived_at.to_datetime
   end

data/test/bogus_relation_test.rb

@@ -0,0 +1,22 @@
+require_relative "test_helper"
+
+class BogusRelationTest < ActiveSupport::TestCase
+
+  test "does not successfully archive" do
+    archival = BogusRelation.create!
+    stub(ActiveRecord::Base.logger).error(
+      satisfy do |arg|
+        if arg.is_a?(String)
+          arg == "SQLite3::SQLException: no such column: bogus_relations.bogus_relation_id"
+        elsif arg.is_a?(Array)
+          arg.join.match?(%r{gems/activerecord}) # this is gonna be in the stack trace somewhere
+        else
+          raise "unexpected logging"
+        end
+      end
+    )
+    assert_not archival.archive!
+    assert_not archival.reload.archived?
+  end
+
+end

data/test/deep_nesting_test.rb

@@ -18,7 +18,7 @@ class DeepNestingTest < ActiveSupport::TestCase
 
   test "unarchiving deeply nested items doesn't blow up" do
     archival_attributes = {
-      archived_at: Time.now,
+      archived_at: Time.now.utc,
       archive_number: "test"
     }
     archival = Archival.create!(archival_attributes)

data/test/fixtures/bogus_relation.rb

@@ -0,0 +1,6 @@
+class BogusRelation < ApplicationRecord
+
+  archival_record
+  has_many :bogus_relations, dependent: :destroy
+
+end

data/test/fixtures/explicit_act_on_dependents_archival.rb

@@ -0,0 +1,9 @@
+# archive_number                - string
+# archived_at                   - datetime
+class ExplicitActOnDependentsArchival < ActiveRecord::Base
+
+  archival_record archive_dependents: true
+
+  has_many :nonignorable_dependents, dependent: :destroy
+
+end

data/test/fixtures/ignorable_dependent.rb

@@ -0,0 +1,10 @@
+# ignore_dependents_archival_id - integer
+# archive_number                - string
+# archived_at                   - datetime
+class IgnorableDependent < ActiveRecord::Base
+
+  archival_record
+
+  belongs_to :ignore_dependents_archival
+
+end

data/test/fixtures/ignore_dependents_archival.rb

@@ -0,0 +1,9 @@
+# archive_number - string
+# archived_at    - datetime
+class IgnoreDependentsArchival < ActiveRecord::Base
+
+  archival_record archive_dependents: false
+
+  has_many :ignorable_dependents, dependent: :destroy
+
+end

data/test/fixtures/nonignorable_dependent.rb

@@ -0,0 +1,10 @@
+# explicit_act_on_dependents_archival_id - integer
+# archive_number                         - string
+# archived_at                            - datetime
+class NonignorableDependent < ActiveRecord::Base
+
+  archival_record
+
+  belongs_to :explicit_act_on_dependents_archival
+
+end

data/test/polymorphic_test.rb

@@ -23,7 +23,7 @@ class PolymorphicTest < ActiveSupport::TestCase
   test "unarchive item with polymorphic association" do
     archive_attributes = {
       archive_number: "test",
-      archived_at: Time.now
+      archived_at: Time.now.utc
     }
     archival = Archival.create!(archive_attributes)
     poly = archival.polys.create!(archive_attributes)
@@ -36,7 +36,7 @@ class PolymorphicTest < ActiveSupport::TestCase
   test "does not unarchive polymorphic association of different item with same id" do
     archive_attributes = {
       archive_number: "test",
-      archived_at: Time.now
+      archived_at: Time.now.utc
     }
 
     archival = Archival.create!(archive_attributes)

data/test/relations_test.rb

@@ -34,7 +34,7 @@ class RelationsTest < ActiveSupport::TestCase
     assert parents.first.archivals.last.archived?
   end
 
-  test "unarchive_all! unarchives all records in an AR Assocation" do
+  test "unarchive_all! unarchives all records in an AR association" do
     3.times { Archival.create! }
 
     archivals = Archival.all

data/test/schema.rb

@@ -93,4 +93,31 @@ ActiveRecord::Schema.define(version: 1) do
     t.column :archive_number, :string
     t.column :archived_at, :datetime
   end
+
+  create_table :ignore_dependents_archivals, force: true do |t|
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
+  end
+
+  create_table :ignorable_dependents, force: true do |t|
+    t.column :ignore_dependents_archival_id, :integer
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
+  end
+
+  create_table :explicit_act_on_dependents_archivals, force: true do |t|
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
+  end
+
+  create_table :nonignorable_dependents, force: true do |t|
+    t.column :explicit_act_on_dependents_archival_id, :integer
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
+  end
+
+  create_table :bogus_relations, force: true do |t|
+    t.column :archive_number, :string
+    t.column :archived_at, :datetime
+  end
 end

data/test/scope_test.rb

@@ -50,16 +50,10 @@ class ScopeTest < ActiveSupport::TestCase
   end
 
   test "table_name is set to 'legacy'" do
-    archived_sql =
-      if ActiveRecord.version >= Gem::Version.new("5.2.0")
-        "SELECT \"legacy\".* FROM \"legacy\" " \
-        'WHERE "legacy"."archived_at" IS NOT NULL AND "legacy"."archive_number" IS NOT NULL'
-      else
-        "SELECT \"legacy\".* FROM \"legacy\" " \
-        'WHERE ("legacy"."archived_at" IS NOT NULL) AND ("legacy"."archive_number" IS NOT NULL)'
-      end
-    unarchived_sql = "SELECT \"legacy\".* FROM \"legacy\" " \
-        'WHERE "legacy"."archived_at" IS NULL AND "legacy"."archive_number" IS NULL'
+    archived_sql = 'SELECT "legacy".* FROM "legacy" ' \
+                   'WHERE "legacy"."archived_at" IS NOT NULL AND "legacy"."archive_number" IS NOT NULL'
+    unarchived_sql = 'SELECT "legacy".* FROM "legacy" ' \
+                     'WHERE "legacy"."archived_at" IS NULL AND "legacy"."archive_number" IS NULL'
     assert_equal archived_sql, ArchivalTableName.archived.to_sql
     assert_equal unarchived_sql, ArchivalTableName.unarchived.to_sql
   end

data/test/test_helper.rb

@@ -1,4 +1,4 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + "/../lib")
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib")
 
 require "bundler/setup"
 require "minitest/autorun"
@@ -20,7 +20,7 @@ end
 
 def setup_logging
   require "logger"
-  logfile = File.dirname(__FILE__) + "/debug.log"
+  logfile = "#{File.dirname(__FILE__)}/debug.log"
   ActiveRecord::Base.logger = Logger.new(logfile)
 end
 
@@ -40,37 +40,38 @@ def sqlite_config
   }
 end
 
+def schema_file
+  "#{File.dirname(__FILE__)}/schema.rb"
+end
+
 def create_test_tables
-  schema_file = File.dirname(__FILE__) + "/schema.rb"
   puts "** Loading schema for SQLite"
   ActiveRecord::Base.establish_connection(sqlite_config)
   load(schema_file) if File.exist?(schema_file)
 end
 
-BASE_FIXTURE_CLASSES = %I[
+FIXTURE_CLASSES = %I[
   another_polys_holder
+  application_record
+  application_record_row
   archival
-  archival_kid
   archival_grandkid
+  archival_kid
   archival_table_name
+  bogus_relation
+  callback_archival
+  deprecated_warning_archival
+  explicit_act_on_dependents_archival
   exploder
+  ignorable_dependent
+  ignore_dependents_archival
   independent_archival
-  missing_archived_at
   missing_archive_number
+  missing_archived_at
+  nonignorable_dependent
   plain
   poly
   readonly_when_archived
-  deprecated_warning_archival
-].freeze
-
-RAILS_4_FIXTURE_CLASSES = %I[
-  callback_archival_4
-].freeze
-
-RAILS_5_FIXTURE_CLASSES = %I[
-  application_record
-  application_record_row
-  callback_archival_5
 ].freeze
 
 def require_test_classes
@@ -78,14 +79,7 @@ def require_test_classes
     inflect.irregular "poly", "polys"
   end
 
-  fixtures = if ActiveRecord::VERSION::MAJOR >= 4
-               RAILS_5_FIXTURE_CLASSES
-             else
-               RAILS_4_FIXTURE_CLASSES
-             end
-
-  fixtures += BASE_FIXTURE_CLASSES
-  fixtures.each { |test_class_file| require_relative "fixtures/#{test_class_file}" }
+  FIXTURE_CLASSES.each { |test_class_file| require_relative "fixtures/#{test_class_file}" }
 end
 
 prepare_for_tests

data/test/transaction_test.rb

@@ -11,7 +11,8 @@ class TransactionTest < ActiveSupport::TestCase
     end
     archival.archive!
 
-    assert_not archival.archived?, "If this failed, you might be trying to test on a system that doesn't support nested transactions"
+    failure_reason = "If this failed, you might be trying to test on a system that doesn't support nested transactions"
+    assert_not archival.archived?, failure_reason
     assert_not exploder.reload.archived?
   end