active_archive 5.3.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5506e5337187ed5218702b644331efa366c60c44aec95f04825a53961915a138
-  data.tar.gz: 347f68b2b28c200090dbda43423bfc8647757b4d992b2f3b4e97d91dc8820a30
+  metadata.gz: fbe2d37d4d70cc6930e4b7fea4f2248418375434cd4d7a704327214e61b36eb5
+  data.tar.gz: 44bcde3d05e859deaf2839356c2c13258fe73f47225177587777f1ca18483400
 SHA512:
-  metadata.gz: a73ad42afa55fee0e6628d82e0e484ed8064e2eed19a80f053a47a35d13e21086f82d4fed1771a14c445aec653d342f67f3927abf3e2e17797b847d9404228b2
-  data.tar.gz: '096868b1dc4e290062767e4b7574fe90512933b22c710964ff980b5d61c9e781123bd2742edc64a853a83e4f371b3687c117ce02de2aa742b9c6875a66d408de'
+  metadata.gz: 711465df49e3c0f94edc7d0db2231ef2c2dda02f41cb494e6b78de4b2b5ccda7efb73156fc81f322c67359d4f2a7c9568ee00447951bbdf2683b1d209192358b
+  data.tar.gz: 849e0c7fed67835e44a7d54213c39fb3793001e5b2531c380ed370bf4ee073d7a0fac7bd5d67640c05c6616186cbfdf6c505357ed4b6aae6d82978fefea8f93d

data/README.md

@@ -5,6 +5,8 @@
 
 ActiveArchive is a library for preventing database records from being destroyed.
 
+**NOTE: version >= '6.0.0' has a small breaking change with the timestamp key and initializer file.**
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -24,6 +26,7 @@ Or install it yourself as:
 ## Table of Contents
 
 * [Configurations](#configurations)
+* [Usage](#usage)
 * [Methods](#methods)
 * [Scopes](#scopes)
 
@@ -35,7 +38,27 @@ Or install it yourself as:
 ```ruby
 ActiveArchive.configure do |config|
   config.all_records_archivable = false
-  config.dependent_record_window = 3.seconds
+end
+```
+
+## Usage
+To work properly, models which could be archived must have column `archived_at` with type `datetime`. If the model table has not this column, record will be destroy instead of archived.
+
+
+For adding this column, you can use this migration, as example:
+
+```ruby
+class AddArchivedAtColumns < ActiveRecord::Migration
+  def change
+    # Adds archived_at automatically
+    t.timestamp
+
+    # Does NOT add archived_at automatically
+    t.timestamp archive: false
+
+    # Manual column
+    add_column :your_model, :archived_at, :datetime
+  end
 end
 ```
 
@@ -44,43 +67,26 @@ end
 **Options:**
  * `archive`
  * `archive_all`
- * `archive_all!`
- * `destroy`
- * `destroy_all`
- * `destroy_all!`
- * `delete`
- * `delete_all`
  * `unarchive`
  * `unarchive_all`
- * `undestroy`
- * `undestroy_all`
 
 ```ruby
 User.first.archive          #=> archives User record and dependents
-User.first.destroy          #=> archives User record and dependents
-User.first.delete           #=> deletes User record and dependents
 User.first.unarchive        #=> unarchives User record and dependents
 
 User.first.to_archival      #=> returns archival state string
 
-User.first.archive(:force)  #=> destroys User record and dependents
-User.first.destroy(:force)  #=> destroys User record and dependents
-
 User.archive_all            #=> archives all User records and dependents
-User.destroy_all            #=> archives all User records and dependents
-User.delete_all             #=> deletes all User records and dependents
 User.unarchive_all          #=> unarchives all User record and dependents
 ```
 
 ## Scopes
 
 **Options:**
- * `default`
  * `archived`
  * `unarchived`
 
 ```ruby
-User.all                    #=> returns all records
 User.archived.all           #=> returns only archived record
 User.unarchived.all         #=> returns only unarchived record
 ```

data/lib/active_archive/base.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# require "active_record/attribute_mutation_tracker"
-
 module ActiveArchive
   module Base
 
@@ -9,7 +7,16 @@ module ActiveArchive
       base.extend Methods
       base.extend Scopes
 
-      base.instance_eval { define_model_callbacks(:unarchive) }
+      base.instance_eval do
+        define_model_callbacks :archive, only: %i[before after]
+        define_model_callbacks :unarchive, only: %i[before after]
+      end
+    end
+
+    def archival?
+      return destroyed? if unarchivable?
+
+      (will_save_change_to_archived_at? || saved_change_to_archived_at?) && archived?
     end
 
     def archivable?
@@ -20,230 +27,113 @@ module ActiveArchive
       archivable? ? !archived_at.nil? : destroyed?
     end
 
-    def unarchived?
-      !archived?
-    end
+    def archive
+      return destroy if unarchivable?
 
-    def unarchivable?
-      !archivable?
-    end
-
-    def unarchive(opts = nil)
       with_transaction_returning_status do
-        records = should_unarchive_parent_first?(opts) ? unarchival.reverse : unarchival
-        records.each { |rec| rec.call(opts) }
-
-        self
-      end
-    end
+        run_callbacks :archive do
+          mark_as_archived
+          mark_relections_as_archived
 
-    alias_method :undestroy, :unarchive
-
-    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)
-
-          if ::ActiveRecord::VERSION::MAJOR >= 5
-            archived_at_will_change!
-          elsif ::ActiveRecord::VERSION::MAJOR >= 4
-            attribute_will_change!('archived_at')
-          end
+          self
         end
       end
     end
 
-    alias_method :archive, :destroy
+    def unarchival?
+      return !destroyed? if unarchivable?
 
-    def to_archival
-      I18n.t("active_archive.archival.#{archived? ? :archived : :unarchived}")
+      (will_save_change_to_archived_at? || saved_change_to_archived_at?) && unarchived?
     end
 
-    private
-
-    def unarchival
-      [
-        lambda do |validate|
-          unarchive_destroyed_dependent_records(validate)
-        end,
-        lambda do |validate|
-          run_callbacks(:unarchive) do
-            set_archived_at(nil, validate)
-
-            each_counter_cache do |assoc_class, counter_cache_column, assoc_id|
-              assoc_class.increment_counter(counter_cache_column, assoc_id)
-            end
-
-            true
-          end
-        end
-      ]
+    def unarchived?
+      !archived?
     end
 
-    def get_archived_record
-      self.class.unscoped.find(id)
+    def unarchivable?
+      !archivable?
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    def set_archived_at(value, force = nil)
-      return self unless archivable?
-
-      record = get_archived_record
-
-      if ::ActiveRecord::VERSION::MAJOR >= 5
-        record.archived_at_will_change!
-      elsif ::ActiveRecord::VERSION::MAJOR >= 4
-        record.attribute_will_change!('archived_at')
-      end
+    def unarchive
+      return self if unarchivable?
 
-      record.archived_at = value
-
-      begin
-        should_ignore_validations?(force) ? record.save(validate: false) : record.save!
+      with_transaction_returning_status do
+        run_callbacks :unarchive do
+          mark_as_unarchived
+          mark_relections_as_unarchived
 
-        if ::ActiveRecord::VERSION::MAJOR >= 5 && ::ActiveRecord::VERSION::MINOR >= 2
-          @attributes_changed_by_setter = record.send(:saved_changes)
-        elsif ::ActiveRecord::VERSION::MAJOR >= 5 && ::ActiveRecord::VERSION::MINOR >= 1
-          @changed_attributes = record.send(:saved_changes)
-        elsif ::ActiveRecord::VERSION::MAJOR >= 5 && ::ActiveRecord::VERSION::MINOR >= 0
-          @changed_attributes = record.send(:previous_changes)
-        elsif ::ActiveRecord::VERSION::MAJOR >= 4
-          @previously_changed = record.instance_variable_get('@previously_changed')
+          self
         end
-
-        @attributes = record.instance_variable_get('@attributes')
-      rescue => error
-        record.destroy
-        raise error
       end
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-    def each_counter_cache
-      _reflections.each do |name, reflection|
-        next unless respond_to?(name.to_sym)
 
-        association = send(name.to_sym)
-
-        next if association.nil?
-        next unless reflection.belongs_to? && reflection.counter_cache_column
-
-        yield(association.class, reflection.counter_cache_column, send(reflection.foreign_key))
-      end
+    def to_archival
+      I18n.t("active_archive.archival.#{archived? ? :archived : :unarchived}")
     end
 
-    def destroy_with_active_archive(force = nil)
-      run_callbacks(:destroy) do
-        if archived? || new_record?
-          save
-        else
-          set_archived_at(Time.now, force)
-
-          each_counter_cache do |assoc_class, counter_cache_column, assoc_id|
-            assoc_class.decrement_counter(counter_cache_column, assoc_id)
-          end
-        end
-
-        true
-      end
+    private
 
-      archived? ? self : false
+    def mark_as_archived
+      self.archived_at = Time.now
+      save(validate: false)
     end
 
-    def add_record_window(_request, name, reflection)
-      qtn = reflection.table_name
-      window = ActiveArchive.configuration.dependent_record_window
-      query = "#{qtn}.archived_at > ? AND #{qtn}.archived_at < ?"
-
-      send(name).unscope(where: :archived_at)
-                .where(query, archived_at - window, archived_at + window)
+    def mark_as_unarchived
+      self.archived_at = nil
+      save(validate: false)
     end
 
-    def unarchive_destroyed_dependent_records(force = nil)
-      destroyed_dependent_relations.each do |relation|
-        relation.to_a.each do |destroyed_dependent_record|
-          destroyed_dependent_record.try(:unarchive, force)
-        end
-      end
-
-      reload
-    end
-
-    # rubocop:disable Metrics/AbcSize
-    def destroyed_dependent_relations
-      dependent_permanent_reflections(self.class).map do |name, relation|
-        case relation.macro.to_s.gsub('has_', '').to_sym
-        when :many
-          if archived_at
-            add_record_window(send(name), name, relation)
-          else
-            send(name).unscope(where: :archived_at)
-          end
-        when :one, :belongs_to
-          self.class.unscoped { Array(send(name)) }
-        end
-      end
-    end
-    # rubocop:enable Metrics/AbcSize
+    def mark_relections_as_archived
+      self.class.reflections.each do |table_name, reflection|
+        next unless dependent_destroy?(reflection)
 
-    def attempt_notifying_observers(callback)
-      notify_observers(callback)
-    rescue NoMethodError
-      # do nothing
-    end
+        dependents = reflection_dependents(table_name)
+        next if dependents.nil?
 
-    def dependent_record_ids
-      dependent_reflections(self.class).reduce({}) do |records, (key, _)|
-        found = Array(send(key)).compact
-        next records if found.empty?
+        action = case [reflection_marco(reflection), archivable?]
+                 when [:one, true] then :archive
+                 when [:one, false] then :destroy
+                 when [:many, true] then :archive_all
+                 when [:many, false] then :destroy_all
+                 end
 
-        records.update(found.first.class => found.map(&:id))
+        dependents.send(action)
       end
     end
 
-    def permanently_delete_records_after(&block)
-      dependent_records = dependent_record_ids
-      result = yield(block)
-      permanently_delete_records(dependent_records) if result
-      result
-    end
+    def mark_relections_as_unarchived
+      self.class.reflections.each do |table_name, reflection|
+        next unless dependent_destroy?(reflection)
 
-    def permanently_delete_records(dependent_records)
-      dependent_records.each do |klass, ids|
-        ids.each do |id|
-          record = klass.unscoped.where(klass.primary_key => id).first
-          next unless record
+        klass = relection_klass(table_name)
+        next unless klass.archivable?
 
-          record.archived_at = nil
-          record.destroy(:force)
-        end
-      end
-    end
+        dependents = reflection_dependents(table_name)
+        next if dependents.nil?
+
+        action = case reflection_marco(reflection)
+                 when :one then :unarchive
+                 when :many then :unarchive_all
+                 end
 
-    def dependent_reflections(klass)
-      klass.reflections.select do |_, reflection|
-        reflection.options[:dependent] == :destroy
+        dependents.send(action)
       end
     end
 
-    def dependent_permanent_reflections(klass)
-      dependent_reflections(klass).select do |_name, reflection|
-        reflection.klass.archivable?
-      end
+    def dependent_destroy?(reflection)
+      reflection.options[:dependent] == :destroy
     end
 
-    def should_force_destroy?(force)
-      force.is_a?(Hash) ? force[:force] : (force == :force)
+    def reflection_dependents(table_name)
+      send(table_name)
     end
 
-    def should_ignore_validations?(force)
-      force.is_a?(Hash) && (force[:validate] == false)
+    def relection_klass(table_name)
+      table_name.classify.constantize
     end
 
-    def should_unarchive_parent_first?(order)
-      order.is_a?(Hash) && (order[:reverse] == true)
+    def reflection_marco(reflection)
+      reflection.macro.to_s.gsub('has_', '').to_sym
     end
 
   end

data/lib/active_archive/configuration.rb

@@ -3,11 +3,10 @@
 module ActiveArchive
   class Configuration
 
-    attr_accessor :all_records_archivable, :dependent_record_window
+    attr_accessor :all_records_archivable
 
     def initialize
       @all_records_archivable = false
-      @dependent_record_window = 3.seconds
     end
 
   end

data/lib/active_archive/methods.rb

@@ -8,20 +8,18 @@ module ActiveArchive
     end
 
     def archive_all(conditions = nil)
-      (conditions ? where(conditions) : all).to_a.each(&:archive)
+      records(conditions, action: :archive)
     end
 
-    def archive_all!(conditions = nil)
-      (conditions ? where(conditions) : all).to_a.each { |r| r.send(:archive, :force) }
+    def unarchive_all(conditions = nil)
+      records(conditions, action: :unarchive)
     end
 
-    alias_method :destroy_all!, :archive_all!
+    private
 
-    def unarchive_all(conditions = nil)
-      (conditions ? where(conditions) : all).to_a.each(&:unarchive)
+    def records(conditions = nil, action:)
+      where(conditions).find_each(&action)
     end
 
-    alias_method :undestroy_all, :unarchive_all
-
   end
 end

data/lib/active_archive/table_definition.rb

@@ -10,7 +10,7 @@ module ActiveArchive
       column(:updated_at, :datetime, options)
 
       return unless ActiveArchive.configuration.all_records_archivable == true
-      return if options[:skip]
+      return if options[:archive] == false
 
       options[:null] = true
       column(:archived_at, :datetime, options)

data/lib/active_archive/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveArchive
-  VERSION ||= '5.3.0'
+  VERSION ||= '6.0.0'
 end

data/lib/generators/active_archive/templates/install.rb

@@ -2,5 +2,4 @@
 
 ActiveArchive.configure do |config|
   config.all_records_archivable = false
-  config.dependent_record_window = 3.seconds
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_archive
 version: !ruby/object:Gem::Version
-  version: 5.3.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Juan Gomez
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-13 00:00:00.000000000 Z
+date: 2018-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails