acts_as_archival 1.1.1 → 2.0.0

data/lib/expected_behavior/acts_as_archival.rb

@@ -1,113 +1,127 @@
 module ExpectedBehavior
   module ActsAsArchival
-    require 'digest/md5'
 
-    MissingArchivalColumnError = Class.new(ActiveRecord::ActiveRecordError) unless defined?(MissingArchivalColumnError) == 'constant' && MissingArchivalColumnError.class == Class
-    CouldNotArchiveError = Class.new(ActiveRecord::ActiveRecordError) unless defined?(CouldNotArchiveError) == 'constant' && CouldNotArchiveError.class == Class
-    CouldNotUnarchiveError = Class.new(ActiveRecord::ActiveRecordError) unless defined?(CouldNotUnarchiveError) == 'constant' && CouldNotUnarchiveError.class == Class
+    require "digest/md5"
+
+    unless defined?(MissingArchivalColumnError) == "constant" && MissingArchivalColumnError.class == Class
+      MissingArchivalColumnError = Class.new(ActiveRecord::ActiveRecordError)
+    end
+    unless defined?(CouldNotArchiveError) == "constant" && CouldNotArchiveError.class == Class
+      CouldNotArchiveError = Class.new(ActiveRecord::ActiveRecordError)
+    end
+    unless defined?(CouldNotUnarchiveError) == "constant" && CouldNotUnarchiveError.class == Class
+      CouldNotUnarchiveError = Class.new(ActiveRecord::ActiveRecordError)
+    end
 
     def self.included(base)
       base.extend ActMethods
     end
 
     module ActMethods
-      def acts_as_archival(options = { })
-        unless included_modules.include? InstanceMethods
-          include InstanceMethods
-
-          before_validation :raise_if_not_archival
-          validate :readonly_when_archived if options[:readonly_when_archived]
-
-          scope :archived, lambda { where.not(:archived_at => nil, :archive_number => nil) }
-          scope :unarchived, lambda { where(:archived_at => nil, :archive_number => nil) }
-          scope :archived_from_archive_number, lambda { |head_archive_number| where(['archived_at IS NOT NULL AND archive_number = ?', head_archive_number]) }
-
-          callbacks = ['archive','unarchive']
-          if ActiveSupport::VERSION::STRING >= '5'
-            define_callbacks(*[callbacks].flatten)
-          elsif ActiveSupport::VERSION::STRING >= '4'
-            define_callbacks(*[callbacks, {:terminator => -> (_, result) { result == false }}].flatten)
-          end
-          callbacks.each do |callback|
-            eval <<-end_callbacks
-              unless defined?(before_#{callback})
-                def before_#{callback}(*args, &blk)
-                  set_callback(:#{callback}, :before, *args, &blk)
-                end
-              end
-              unless defined?(after_#{callback})
-                def after_#{callback}(*args, &blk)
-                  set_callback(:#{callback}, :after, *args, &blk)
-                end
-              end
-            end_callbacks
+
+      def acts_as_archival(options = {})
+        return if included_modules.include?(InstanceMethods)
+
+        include InstanceMethods
+
+        setup_validations(options)
+
+        setup_scopes
+
+        setup_callbacks
+      end
+
+      private def setup_validations(options)
+        before_validation :raise_if_not_archival
+        validate :readonly_when_archived if options[:readonly_when_archived]
+      end
+
+      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)
+      end
+
+      private def setup_callbacks
+        callbackable_actions = %w[archive unarchive]
+
+        setup_activerecord_callbacks(callbackable_actions)
+
+        define_callback_dsl_methods(callbackable_actions)
+      end
+
+      private def setup_activerecord_callbacks(callbackable_actions)
+        define_callbacks(*[callbackable_actions].flatten)
+      end
+
+      private def define_callback_dsl_methods(callbackable_actions)
+        callbackable_actions.each do |action|
+          %w[before after].each do |callbackable_type|
+            define_callback_dsl_method(callbackable_type, action)
           end
         end
       end
 
+      private def define_callback_dsl_method(callbackable_type, action)
+        # rubocop:disable Security/Eval
+        eval <<-end_callbacks
+          unless defined?(#{callbackable_type}_#{action})
+            def #{callbackable_type}_#{action}(*args, &blk)
+              set_callback(:#{action}, :#{callbackable_type}, *args, &blk)
+            end
+          end
+        end_callbacks
+        # rubocop:enable Security/Eval
+      end
+
     end
 
     module InstanceMethods
 
       def readonly_when_archived
-        if self.archived? && self.changed? && !self.archived_at_changed? && !self.archive_number_changed?
-          self.errors.add(:base, "Cannot modify an archived record.")
-        end
+        readonly_attributes_changed = archived? && changed? && !archived_at_changed? && !archive_number_changed?
+        return unless readonly_attributes_changed
+
+        errors.add(:base, "Cannot modify an archived record.")
       end
 
       def raise_if_not_archival
         missing_columns = []
-        missing_columns << "archive_number" unless self.respond_to?(:archive_number)
-        missing_columns << "archived_at" unless self.respond_to?(:archived_at)
-        raise MissingArchivalColumnError.new("Add '#{missing_columns.join "', '"}' column(s) to '#{self.class.name}' to make it archival") unless missing_columns.blank?
+        missing_columns << "archive_number" unless respond_to?(:archive_number)
+        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")
       end
 
       def archived?
-        !!(self.archived_at? && self.archive_number)
+        !!(archived_at? && archive_number)
       end
 
-      def archive(head_archive_number=nil)
-        self.class.transaction do
-          begin
-            success = run_callbacks(:archive) do
-              unless self.archived?
-                head_archive_number ||= Digest::MD5.hexdigest("#{self.class.name}#{self.id}")
-                self.archive_associations(head_archive_number)
-                self.archived_at = DateTime.now
-                self.archive_number = head_archive_number
-                self.save!
-              end
-            end
-            return !!success
-          rescue => e
-            ActiveRecord::Base.logger.try(:debug, e.message)
-            ActiveRecord::Base.logger.try(:debug, e.backtrace)
-            raise ActiveRecord::Rollback
+      def archive!(head_archive_number = nil)
+        execute_archival_action(:archive) do
+          unless archived?
+            head_archive_number ||= Digest::MD5.hexdigest("#{self.class.name}#{id}")
+            archive_associations(head_archive_number)
+            self.archived_at = DateTime.now
+            self.archive_number = head_archive_number
+            save!
           end
         end
-        false
       end
 
-      def unarchive(head_archive_number=nil)
-        self.class.transaction do
-          begin
-            success = run_callbacks(:unarchive) do
-              if self.archived?
-                head_archive_number ||= self.archive_number
-                self.archived_at = nil
-                self.archive_number = nil
-                self.save!
-                self.unarchive_associations(head_archive_number)
-              end
-            end
-            return !!success
-          rescue => e
-            ActiveRecord::Base.logger.try(:debug, e.message)
-            ActiveRecord::Base.logger.try(:debug, e.backtrace)
-            raise ActiveRecord::Rollback
+      def unarchive!(head_archive_number = nil)
+        execute_archival_action(:unarchive) do
+          if archived?
+            head_archive_number ||= archive_number
+            self.archived_at = nil
+            self.archive_number = nil
+            save!
+            unarchive_associations(head_archive_number)
           end
         end
-        false
       end
 
       def archive_associations(head_archive_number)
@@ -117,6 +131,26 @@ module ExpectedBehavior
       def unarchive_associations(head_archive_number)
         AssociationOperation::Unarchive.new(self, head_archive_number).execute
       end
+
+      private def execute_archival_action(action)
+        self.class.transaction do
+          begin
+            success = run_callbacks(action) { yield }
+            return !!success
+          rescue => e
+            handle_archival_action_exception(e)
+          end
+        end
+        false
+      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
+      end
+
     end
+
   end
 end

data/lib/expected_behavior/acts_as_archival_active_record_methods.rb

@@ -1,20 +1,45 @@
 module ExpectedBehavior
   module ActsAsArchivalActiveRecordMethods
+
     def self.included(base)
       base.extend ARClassMethods
       base.send :include, ARInstanceMethods
     end
 
     module ARClassMethods
-      def is_archival?
-        self.included_modules.include?(ExpectedBehavior::ActsAsArchival::InstanceMethods)
+
+      def archival?
+        included_modules.include?(ExpectedBehavior::ActsAsArchival::InstanceMethods)
       end
+
     end
 
     module ARInstanceMethods
-      def is_archival?
-        self.class.is_archival?
+
+      def archival?
+        self.class.archival?
       end
+
     end
+
+    module ARRelationMethods
+
+      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?
+
+        head_archive_number = Digest::MD5.hexdigest("#{klass}#{Time.now.utc.to_i}")
+        each { |record| record.archive!(head_archive_number) }.tap { reset }
+      end
+
+      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?
+
+        each(&:unarchive!).tap { reset }
+      end
+
+    end
+
   end
 end

data/lib/expected_behavior/association_operation/archive.rb

@@ -7,7 +7,7 @@ module ExpectedBehavior
 
         def act_on_archivals(archivals)
           archivals.unarchived.find_each do |related_record|
-            raise ActiveRecord::Rollback unless related_record.archive(head_archive_number)
+            raise ActiveRecord::Rollback unless related_record.archive!(head_archive_number)
           end
         end
 

data/lib/expected_behavior/association_operation/base.rb

@@ -1,8 +1,8 @@
 module ExpectedBehavior
   module ActsAsArchival
     module AssociationOperation
-
       class Base
+
         attr_reader :model, :head_archive_number
 
         def initialize(model, head_archive_number)
@@ -19,33 +19,36 @@ module ExpectedBehavior
         protected
 
         def each_archivable_association
-          self.model.class.reflect_on_all_associations.each do |association|
+          model.class.reflect_on_all_associations.each do |association|
             yield(association) if archivable_association?(association)
           end
         end
 
         def archivable_association?(association)
           association.macro.to_s =~ /^has/ &&
-            association.klass.is_archival? &&
+            association.klass.archival? &&
             association.options[:through].nil?
         end
 
-        def association_conditions_met?(association)
+        def association_conditions_met?(_association)
           true
         end
 
         def act_on_association(association)
           key = association.respond_to?(:foreign_key) ? association.foreign_key : association.primary_key_name
-          scope = association.klass.where(key => model.id)
+          scope_conditions = { key => model.id }
+          # polymorphic associations need a type so we don't accidentally act on multiple associated objects
+          # that have the same ID
+          scope_conditions[association.type] = model.class.base_class.name if association.type
+          scope = association.klass.where(scope_conditions)
           act_on_archivals(scope)
         end
 
-        def act_on_archivals(scope)
-          raise NotImplementedError,
-            "The #{self.class} hasn't implemented 'act_on_archivals(scope)'"
+        def act_on_archivals(_scope)
+          raise NotImplementedError.new("The #{self.class} hasn't implemented 'act_on_archivals(scope)'")
         end
-      end
 
+      end
     end
   end
 end

data/lib/expected_behavior/association_operation/unarchive.rb

@@ -6,8 +6,8 @@ module ExpectedBehavior
         protected
 
         def act_on_archivals(scope)
-          scope.archived.where(:archive_number => head_archive_number).find_each do |related_record|
-            raise ActiveRecord::Rollback unless related_record.unarchive(head_archive_number)
+          scope.archived.where(archive_number: head_archive_number).find_each do |related_record|
+            raise ActiveRecord::Rollback unless related_record.unarchive!(head_archive_number)
           end
         end
 

data/script/setup

@@ -5,8 +5,5 @@ cd "`dirname \"$0\"`/.."
 echo "\n---=== Bundling ===---"
 bundle install
 
-echo "\n---=== Setting up test databases ===---"
-script/db_setup
-
 echo "\n---=== Setting up various rails versions for testing ===---"
 bundle exec appraisal install

data/test/ambiguous_table_test.rb

@@ -1,14 +1,16 @@
 require_relative "test_helper"
 
 class AmbiguousTableTest < ActiveSupport::TestCase
+
   test "no ambiguous table problem" do
     archival = Archival.create!
     child = archival.archivals.create!
-    child.archive
+    child.archive!
 
     # this is a bug fix for a problem wherein table names weren't being
     # namespaced, so if a table joined against itself, incorrect SQL was
     # generated
     assert_equal 1, Archival.unarchived.joins(:archivals).count
   end
+
 end

data/test/application_record_test.rb

@@ -3,16 +3,18 @@ require_relative "test_helper"
 # Rails 5 introduced a new base class, and this is gonna test that
 if defined?(ApplicationRecord)
   class ApplicationRecordTest < ActiveSupport::TestCase
+
     test "archive archives the record" do
       archival = ApplicationRecordRow.create!
-      archival.archive
+      archival.archive!
       assert archival.reload.archived?
     end
 
     test "unarchive unarchives archival records" do
-      archival = ApplicationRecordRow.create!(:archived_at => Time.now, :archive_number => 1)
-      archival.unarchive
+      archival = ApplicationRecordRow.create!(archived_at: Time.now, archive_number: 1)
+      archival.unarchive!
       assert_not archival.reload.archived?
     end
+
   end
 end

data/test/associations_test.rb

@@ -1,10 +1,11 @@
 require_relative "test_helper"
 
 class AssociationsTest < ActiveSupport::TestCase
+
   test "archive archives 'has_' associated archival objects that are dependent destroy" do
     archival = Archival.create!
     child = archival.archivals.create!
-    archival.archive
+    archival.archive!
 
     assert archival.reload.archived?
     assert child.reload.archived?
@@ -13,7 +14,7 @@ class AssociationsTest < ActiveSupport::TestCase
   test "archive acts on all objects in the 'has_' relationship" do
     archival = Archival.create!
     children = [archival.archivals.create!, archival.archivals.create!]
-    archival.archive
+    archival.archive!
 
     assert archival.reload.archived?
     assert children.map(&:reload).all?(&:archived?)
@@ -23,8 +24,8 @@ class AssociationsTest < ActiveSupport::TestCase
     archival = Archival.create!
     archival.archivals.create!
     prearchived_child = archival.archivals.create!
-    prearchived_child.archive
-    archival.archive
+    prearchived_child.archive!
+    archival.archive!
 
     assert_not_equal archival.archive_number, prearchived_child.reload.archive_number
   end
@@ -32,7 +33,7 @@ class AssociationsTest < ActiveSupport::TestCase
   test "archive does not archive 'has_' associated archival objects that are not dependent destroy" do
     archival = Archival.create!
     non_dependent_child = archival.independent_archivals.create!
-    archival.archive
+    archival.archive!
 
     assert     archival.reload.archived?
     assert_not non_dependent_child.reload.archived?
@@ -41,7 +42,7 @@ class AssociationsTest < ActiveSupport::TestCase
   test "archive doesn't do anything to associated dependent destroy models that are non-archival" do
     archival = Archival.create!
     plain = archival.plains.create!
-    archival.archive
+    archival.archive!
 
     assert archival.archived?
     assert plain.reload
@@ -50,7 +51,7 @@ class AssociationsTest < ActiveSupport::TestCase
   test "archive sets the object hierarchy to all have the same archive_number" do
     archival = Archival.create!
     child = archival.archivals.create!
-    archival.archive
+    archival.archive!
     expected_digest = Digest::MD5.hexdigest("Archival#{archival.id}")
 
     assert_equal expected_digest, archival.archive_number
@@ -60,8 +61,8 @@ class AssociationsTest < ActiveSupport::TestCase
   test "unarchive acts on child objects" do
     archival = Archival.create!
     child = archival.archivals.create!
-    archival.archive
-    archival.unarchive
+    archival.archive!
+    archival.unarchive!
 
     assert_not archival.archived?
     assert_not child.reload.archived?
@@ -71,9 +72,9 @@ class AssociationsTest < ActiveSupport::TestCase
     archival = Archival.create!
     child = archival.archivals.create!
     prearchived_child = archival.archivals.create!
-    prearchived_child.archive
-    archival.archive
-    archival.unarchive
+    prearchived_child.archive!
+    archival.archive!
+    archival.unarchive!
 
     assert_not archival.archived?
     assert_not child.reload.archived?
@@ -83,9 +84,9 @@ class AssociationsTest < ActiveSupport::TestCase
   test "unarchive acts on 'has_' associated non-dependent_destroy objects" do
     archival = Archival.create!
     independent = archival.independent_archivals.create!
-    archival.archive
-    independent.archive(archival.archive_number)
-    archival.unarchive
+    archival.archive!
+    independent.archive!(archival.archive_number)
+    archival.unarchive!
 
     assert_not archival.reload.archived?
     assert_not independent.reload.archived?
@@ -94,9 +95,10 @@ class AssociationsTest < ActiveSupport::TestCase
   test "unarchive doesn't unarchive associated objects if the head object is already unarchived" do
     archival = Archival.create!
     prearchived_child = archival.archivals.create!
-    prearchived_child.archive
-    archival.unarchive
+    prearchived_child.archive!
+    archival.unarchive!
 
     assert prearchived_child.reload.archived?
   end
+
 end

data/test/basic_test.rb

@@ -1,64 +1,66 @@
 require_relative "test_helper"
 
 class BasicTest < ActiveSupport::TestCase
+
   test "archive archives the record" do
     archival = Archival.create!
-    archival.archive
+    archival.archive!
     assert_equal true, archival.reload.archived?
   end
 
   test "unarchive unarchives archival records" do
-    archival = Archival.create!(:archived_at => Time.now, :archive_number => 1)
-    archival.unarchive
+    archival = Archival.create!(archived_at: Time.now, archive_number: 1)
+    archival.unarchive!
     assert_equal false, archival.reload.archived?
   end
 
   test "archive returns true on success" do
     normal = Archival.create!
-    assert_equal true, normal.archive
+    assert_equal true, normal.archive!
   end
 
   test "archive returns false on failure" do
     readonly = Archival.create!
     readonly.readonly!
-    assert_equal false, readonly.archive
+    assert_equal false, readonly.archive!
   end
 
   test "unarchive returns true on success" do
-    normal = Archival.create!(:archived_at => Time.now, :archive_number => "1")
-    assert_equal true, normal.unarchive
+    normal = Archival.create!(archived_at: Time.now, 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, archive_number: "1")
     readonly.readonly!
-    assert_equal false, readonly.unarchive
+    assert_equal false, readonly.unarchive!
   end
 
   test "archive sets archived_at to the time of archiving" do
     archival = Archival.create!
     before = DateTime.now
     sleep(0.001)
-    archival.archive
+    archival.archive!
     sleep(0.001)
     after = DateTime.now
     assert before < archival.archived_at.to_datetime
-    assert after  > archival.archived_at.to_datetime
+    assert after > archival.archived_at.to_datetime
   end
 
   test "archive sets the archive number to the md5 hexdigest for the model and id that is archived" do
     archival = Archival.create!
-    archival.archive
+    archival.archive!
     expected_digest = Digest::MD5.hexdigest("#{archival.class.name}#{archival.id}")
     assert_equal expected_digest, archival.archive_number
   end
 
   test "archive on archived object doesn't alter the archive_number" do
     archived = Archival.create
-    archived.archive
+    archived.archive!
     initial_number = archived.archive_number
-    archived.reload.archive
+    archived.reload.archive!
     second_number = archived.archive_number
     assert_equal initial_number, second_number
   end
+
 end

data/test/callbacks_test.rb

@@ -1,21 +1,22 @@
 require_relative "test_helper"
 
 class CallbacksTest < ActiveSupport::TestCase
+
   if defined?(ApplicationRecord)
     test "can set a value as part of archiving" do
       archival = CallbackArchival5.create
       archival.set_this_value = "a test string"
       assert_nil archival.settable_field
-      archival.archive
+      archival.archive!
       assert_equal "a test string", archival.reload.settable_field
     end
 
     test "can be halted" do
-      archival = archival = CallbackArchival5.create
+      archival = CallbackArchival5.create
       archival.set_this_value = "a test string"
       archival.pass_callback = false
       assert_nil archival.settable_field
-      archival.archive
+      archival.archive!
       assert_nil archival.reload.settable_field
     end
   else
@@ -23,17 +24,18 @@ class CallbacksTest < ActiveSupport::TestCase
       archival = CallbackArchival4.create
       archival.set_this_value = "a test string"
       assert_nil archival.settable_field
-      archival.archive
+      archival.archive!
       assert_equal "a test string", archival.reload.settable_field
     end
 
     test "can be halted" do
-      archival = archival = CallbackArchival4.create
+      archival = CallbackArchival4.create
       archival.set_this_value = "a test string"
       archival.pass_callback = false
       assert_nil archival.settable_field
-      archival.archive
+      archival.archive!
       assert_nil archival.reload.settable_field
     end
   end
+
 end

data/test/column_test.rb

@@ -1,15 +1,17 @@
 require_relative "test_helper"
 
 class ColumnTest < ActiveSupport::TestCase
+
   test "acts_as_archival raises during create if missing archived_at column" do
-    assert_raises(ExpectedBehavior::ActsAsArchival::MissingArchivalColumnError) {
-      MissingArchivedAt.create!(:name => "foo-foo")
-    }
+    assert_raises(ExpectedBehavior::ActsAsArchival::MissingArchivalColumnError) do
+      MissingArchivedAt.create!(name: "foo-foo")
+    end
   end
 
   test "acts_as_archival raises during create if missing archive_number column" do
-    assert_raises(ExpectedBehavior::ActsAsArchival::MissingArchivalColumnError) {
-      MissingArchiveNumber.create!(:name => "rover")
-    }
+    assert_raises(ExpectedBehavior::ActsAsArchival::MissingArchivalColumnError) do
+      MissingArchiveNumber.create!(name: "rover")
+    end
   end
+
 end