acts_as_paranoid 0.6.2 → 0.7.3

data/lib/acts_as_paranoid.rb

@@ -1,13 +1,14 @@
-require 'acts_as_paranoid/core'
-require 'acts_as_paranoid/associations'
-require 'acts_as_paranoid/validations'
-require 'acts_as_paranoid/relation'
-require 'acts_as_paranoid/preloader_association'
+# frozen_string_literal: true
 
-module ActsAsParanoid
+require "active_record"
+require "acts_as_paranoid/core"
+require "acts_as_paranoid/associations"
+require "acts_as_paranoid/validations"
+require "acts_as_paranoid/relation"
 
+module ActsAsParanoid
   def paranoid?
-    self.included_modules.include?(ActsAsParanoid::Core)
+    included_modules.include?(ActsAsParanoid::Core)
   end
 
   def validates_as_paranoid
@@ -15,19 +16,28 @@ module ActsAsParanoid
   end
 
   def acts_as_paranoid(options = {})
-    raise ArgumentError, "Hash expected, got #{options.class.name}" if not options.is_a?(Hash) and not options.empty?
+    if !options.is_a?(Hash) && !options.empty?
+      raise ArgumentError, "Hash expected, got #{options.class.name}"
+    end
 
     class_attribute :paranoid_configuration
 
-    self.paranoid_configuration = { :column => "deleted_at", :column_type => "time", :recover_dependent_associations => true, :dependent_recovery_window => 2.minutes, :recovery_value => nil, double_tap_destroys_fully: true }
-    self.paranoid_configuration.merge!({ :deleted_value => "deleted" }) if options[:column_type] == "string"
-    self.paranoid_configuration.merge!({ :allow_nulls => true }) if options[:column_type] == "boolean"
-    self.paranoid_configuration.merge!(options) # user options
+    self.paranoid_configuration = {
+      column: "deleted_at",
+      column_type: "time",
+      recover_dependent_associations: true,
+      dependent_recovery_window: 2.minutes,
+      double_tap_destroys_fully: true
+    }
+    if options[:column_type] == "string"
+      paranoid_configuration.merge!(deleted_value: "deleted")
+    end
 
-    raise ArgumentError, "'time', 'boolean' or 'string' expected for :column_type option, got #{paranoid_configuration[:column_type]}" unless ['time', 'boolean', 'string'].include? paranoid_configuration[:column_type]
+    paranoid_configuration.merge!(options) # user options
 
-    def self.paranoid_column_reference
-      "#{self.table_name}.#{paranoid_configuration[:column]}"
+    unless %w[time boolean string].include? paranoid_configuration[:column_type]
+      raise ArgumentError, "'time', 'boolean' or 'string' expected" \
+        " for :column_type option, got #{paranoid_configuration[:column_type]}"
     end
 
     return if paranoid?
@@ -37,28 +47,18 @@ module ActsAsParanoid
     # Magic!
     default_scope { where(paranoid_default_scope) }
 
-    if paranoid_configuration[:column_type] == 'time'
-      scope :deleted_inside_time_window, lambda {|time, window|
-        deleted_after_time((time - window)).deleted_before_time((time + window))
-      }
-
-      scope :deleted_after_time, lambda  { |time| where("#{self.table_name}.#{paranoid_column} > ?", time) }
-      scope :deleted_before_time, lambda { |time| where("#{self.table_name}.#{paranoid_column} < ?", time) }
-    end
+    define_deleted_time_scopes if paranoid_column_type == :time
   end
 end
 
 # Extend ActiveRecord's functionality
-ActiveRecord::Base.send :extend, ActsAsParanoid
+ActiveRecord::Base.extend ActsAsParanoid
 
 # Extend ActiveRecord::Base with paranoid associations
-ActiveRecord::Base.send :include, ActsAsParanoid::Associations
+ActiveRecord::Base.include ActsAsParanoid::Associations
 
 # Override ActiveRecord::Relation's behavior
-ActiveRecord::Relation.send :include, ActsAsParanoid::Relation
+ActiveRecord::Relation.include ActsAsParanoid::Relation
 
 # Push the recover callback onto the activerecord callback list
 ActiveRecord::Callbacks::CALLBACKS.push(:before_recover, :after_recover)
-
-# Use with_deleted in preloader build_scope
-ActiveRecord::Associations::Preloader::Association.send :include, ActsAsParanoid::PreloaderAssociation

data/lib/acts_as_paranoid/associations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsParanoid
   module Associations
     def self.included(base)
@@ -16,29 +18,31 @@ module ActsAsParanoid
         end
 
         with_deleted = options.delete(:with_deleted)
-        result = belongs_to_without_deleted(target, scope, options)
-
         if with_deleted
-          if result.is_a? Hash
-            result.values.last.options[:with_deleted] = with_deleted
+          if scope
+            old_scope = scope
+            scope = proc do |*args|
+              if old_scope.arity == 0
+                instance_exec(&old_scope).with_deleted
+              else
+                old_scope.call(*args).with_deleted
+              end
+            end
           else
-            result.options[:with_deleted] = with_deleted
-          end
-
-          unless method_defined? "#{target}_with_unscoped"
-            class_eval <<-RUBY, __FILE__, __LINE__
-              def #{target}_with_unscoped(*args)
-                association = association(:#{target})
-                return nil if association.options[:polymorphic] && association.klass.nil?
-                return #{target}_without_unscoped(*args) unless association.klass.paranoid?
-                association.klass.with_deleted.scoping { association.klass.unscoped { #{target}_without_unscoped(*args) } }
+            scope = proc do
+              if respond_to? :with_deleted
+                self.with_deleted
+              else
+                all
               end
-              alias_method :#{target}_without_unscoped, :#{target}
-              alias_method :#{target}, :#{target}_with_unscoped
-            RUBY
+            end
           end
         end
 
+        result = belongs_to_without_deleted(target, scope, **options)
+
+        result.values.last.options[:with_deleted] = with_deleted if with_deleted
+
         result
       end
     end

data/lib/acts_as_paranoid/core.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsParanoid
   module Core
     def self.included(base)
@@ -23,7 +25,8 @@ module ActsAsParanoid
 
       def only_deleted
         if string_type_with_deleted_value?
-          without_paranoid_default_scope.where(paranoid_column_reference => paranoid_configuration[:deleted_value])
+          without_paranoid_default_scope
+            .where(paranoid_column_reference => paranoid_configuration[:deleted_value])
         elsif boolean_type_not_nullable?
           without_paranoid_default_scope.where(paranoid_column_reference => true)
         else
@@ -36,17 +39,18 @@ module ActsAsParanoid
       end
 
       def delete_all(conditions = nil)
-        where(conditions).update_all(["#{paranoid_configuration[:column]} = ?", delete_now_value])
+        where(conditions)
+          .update_all(["#{paranoid_configuration[:column]} = ?", delete_now_value])
       end
 
       def paranoid_default_scope
         if string_type_with_deleted_value?
-          self.all.table[paranoid_column].eq(nil).
-            or(self.all.table[paranoid_column].not_eq(paranoid_configuration[:deleted_value]))
+          all.table[paranoid_column].eq(nil)
+            .or(all.table[paranoid_column].not_eq(paranoid_configuration[:deleted_value]))
         elsif boolean_type_not_nullable?
-          self.all.table[paranoid_column].eq(false)
+          all.table[paranoid_column].eq(false)
         else
-          self.all.table[paranoid_column].eq(nil)
+          all.table[paranoid_column].eq(nil)
         end
       end
 
@@ -66,8 +70,14 @@ module ActsAsParanoid
         paranoid_configuration[:column_type].to_sym
       end
 
+      def paranoid_column_reference
+        "#{table_name}.#{paranoid_column}"
+      end
+
       def dependent_associations
-        self.reflect_on_all_associations.select {|a| [:destroy, :delete_all].include?(a.options[:dependent]) }
+        reflect_on_all_associations.select do |a|
+          [:destroy, :delete_all].include?(a.options[:dependent])
+        end
       end
 
       def delete_now_value
@@ -78,20 +88,42 @@ module ActsAsParanoid
         end
       end
 
-    protected
+      def recovery_value
+        if paranoid_configuration.key? :recovery_value
+          ActiveSupport::Deprecation.warn \
+            "The recovery_value setting is deprecated and will be removed in" \
+            " ActsAsParanoid 0.8.0"
+          paranoid_configuration[:recovery_value]
+        elsif boolean_type_not_nullable?
+          false
+        else
+          nil
+        end
+      end
+
+      protected
+
+      def define_deleted_time_scopes
+        scope :deleted_inside_time_window, lambda { |time, window|
+          deleted_after_time((time - window)).deleted_before_time((time + window))
+        }
+
+        scope :deleted_after_time, lambda { |time|
+          only_deleted
+            .where("#{table_name}.#{paranoid_column} > ?", time)
+        }
+        scope :deleted_before_time, lambda { |time|
+          only_deleted
+            .where("#{table_name}.#{paranoid_column} < ?", time)
+        }
+      end
 
       def without_paranoid_default_scope
-        scope = self.all
+        scope = all
 
-        if ActiveRecord::VERSION::MAJOR < 5
-          # ActiveRecord 4.0.*
-          scope = scope.with_default_scope if ActiveRecord::VERSION::MINOR < 1
-          scope.where_values.delete(paranoid_default_scope)
-        else
-          scope = scope.unscope(where: paranoid_default_scope)
-          # Fix problems with unscope group chain
-          scope = scope.unscoped if scope.to_sql.include? paranoid_default_scope.to_sql
-        end
+        scope = scope.unscope(where: paranoid_column)
+        # Fix problems with unscope group chain
+        scope = scope.unscoped if scope.to_sql.include? paranoid_default_scope.to_sql
 
         scope
       end
@@ -102,13 +134,13 @@ module ActsAsParanoid
     end
 
     def paranoid_value
-      self.send(self.class.paranoid_column)
+      send(self.class.paranoid_column)
     end
 
     # Straight from ActiveRecord 5.1!
     def delete
       self.class.delete(id) if persisted?
-      @destroyed = true
+      stale_paranoid_value
       freeze
     end
 
@@ -118,13 +150,15 @@ module ActsAsParanoid
           destroy_dependent_associations!
 
           if persisted?
-            # Handle composite keys, otherwise we would just use `self.class.primary_key.to_sym => self.id`.
-            self.class.delete_all!(Hash[[Array(self.class.primary_key), Array(self.id)].transpose])
-
+            # Handle composite keys, otherwise we would just use
+            # `self.class.primary_key.to_sym => self.id`.
+            self.class
+              .delete_all!([Array(self.class.primary_key), Array(id)].transpose.to_h)
             decrement_counters_on_associations
           end
 
-          self.paranoid_value = self.class.delete_now_value
+          stale_paranoid_value
+          @destroyed = true
           freeze
         end
       end
@@ -134,140 +168,162 @@ module ActsAsParanoid
       if !deleted?
         with_transaction_returning_status do
           run_callbacks :destroy do
-
             if persisted?
-              # Handle composite keys, otherwise we would just use `self.class.primary_key.to_sym => self.id`.
-              self.class.delete_all(Hash[[Array(self.class.primary_key), Array(self.id)].transpose])
-
+              # Handle composite keys, otherwise we would just use
+              # `self.class.primary_key.to_sym => self.id`.
+              self.class
+                .delete_all([Array(self.class.primary_key), Array(id)].transpose.to_h)
               decrement_counters_on_associations
             end
 
             @_trigger_destroy_callback = true
 
-            self.paranoid_value = self.class.delete_now_value
+            stale_paranoid_value
             self
           end
         end
-      else
-        if paranoid_configuration[:double_tap_destroys_fully]
-          destroy_fully!
-        end
+      elsif paranoid_configuration[:double_tap_destroys_fully]
+        destroy_fully!
       end
     end
 
-    alias_method :destroy, :destroy!
+    alias destroy destroy!
+
+    def recover(options = {})
+      return if !deleted?
 
-    def recover(options={})
-      return if !self.deleted?
       options = {
-        :recursive => self.class.paranoid_configuration[:recover_dependent_associations],
-        :recovery_window => self.class.paranoid_configuration[:dependent_recovery_window]
+        recursive: self.class.paranoid_configuration[:recover_dependent_associations],
+        recovery_window: self.class.paranoid_configuration[:dependent_recovery_window],
+        raise_error: false
       }.merge(options)
 
       self.class.transaction do
         run_callbacks :recover do
-          recover_dependent_associations(options[:recovery_window], options) if options[:recursive]
           increment_counters_on_associations
-          self.paranoid_value = self.class.paranoid_configuration[:recovery_value]
-          self.save
+          deleted_value = paranoid_value
+          self.paranoid_value = self.class.recovery_value
+          result = if options[:raise_error]
+                     save!
+                   else
+                     save
+                   end
+          recover_dependent_associations(deleted_value, options) if options[:recursive]
+          result
         end
       end
     end
 
-    def recover_dependent_associations(window, options)
-      self.class.dependent_associations.each do |reflection|
-        next unless (klass = get_reflection_class(reflection)).paranoid?
-
-        scope = klass.only_deleted
+    def recover!(options = {})
+      options[:raise_error] = true
 
-        # Merge in the association's scope
-        scope = if ActiveRecord::VERSION::MAJOR >= 6
-          scope.merge(ActiveRecord::Associations::AssociationScope.scope(association(reflection.name)))
-        else
-          scope.merge(association(reflection.name).association_scope)
-        end
-
-        # We can only recover by window if both parent and dependant have a
-        # paranoid column type of :time.
-        if self.class.paranoid_column_type == :time && klass.paranoid_column_type == :time
-          scope = scope.deleted_inside_time_window(paranoid_value, window)
-        end
+      recover(options)
+    end
 
-        scope.each do |object|
-          object.recover(options)
-        end
+    def recover_dependent_associations(deleted_value, options)
+      self.class.dependent_associations.each do |reflection|
+        recover_dependent_association(reflection, deleted_value, options)
       end
     end
 
     def destroy_dependent_associations!
       self.class.dependent_associations.each do |reflection|
-        next unless (klass = get_reflection_class(reflection)).paranoid?
-
-        scope = klass.only_deleted
+        assoc = association(reflection.name)
+        next unless (klass = assoc.klass).paranoid?
 
-        # Merge in the association's scope
-        scope = if ActiveRecord::VERSION::MAJOR >= 6
-          scope.merge(ActiveRecord::Associations::AssociationScope.scope(association(reflection.name)))
-        else
-          scope.merge(association(reflection.name).association_scope)
-        end
-
-        scope.each do |object|
-          object.destroy!
-        end
+        klass
+          .only_deleted.merge(get_association_scope(assoc))
+          .each(&:destroy!)
       end
     end
 
     def deleted?
-      !if self.class.string_type_with_deleted_value?
-        paranoid_value != self.class.delete_now_value || paranoid_value.nil?
+      return true if @destroyed
+
+      if self.class.string_type_with_deleted_value?
+        paranoid_value == paranoid_configuration[:deleted_value]
       elsif self.class.boolean_type_not_nullable?
-        paranoid_value == false
+        paranoid_value == true
       else
-        paranoid_value.nil?
+        !paranoid_value.nil?
       end
     end
 
-    alias_method :destroyed?, :deleted?
+    alias destroyed? deleted?
+
+    def deleted_fully?
+      @destroyed
+    end
+
+    alias destroyed_fully? deleted_fully?
 
     private
 
-    def get_reflection_class(reflection)
-      if reflection.macro == :belongs_to && reflection.options.include?(:polymorphic)
-        self.send(reflection.foreign_type).constantize
-      else
-        reflection.klass
+    def recover_dependent_association(reflection, deleted_value, options)
+      assoc = association(reflection.name)
+      return unless (klass = assoc.klass).paranoid?
+
+      if reflection.belongs_to? && attributes[reflection.association_foreign_key].nil?
+        return
       end
+
+      scope = klass.only_deleted.merge(get_association_scope(assoc))
+
+      # We can only recover by window if both parent and dependant have a
+      # paranoid column type of :time.
+      if self.class.paranoid_column_type == :time && klass.paranoid_column_type == :time
+        scope = scope.deleted_inside_time_window(deleted_value, options[:recovery_window])
+      end
+
+      recovered = false
+      scope.each do |object|
+        object.recover(options)
+        recovered = true
+      end
+
+      assoc.reload if recovered && reflection.has_one? && assoc.loaded?
+    end
+
+    def get_association_scope(dependent_association)
+      ActiveRecord::Associations::AssociationScope.scope(dependent_association)
     end
 
     def paranoid_value=(value)
-      self.send("#{self.class.paranoid_column}=", value)
+      write_attribute(self.class.paranoid_column, value)
     end
 
-    def update_counters_on_associations method_sym
+    def update_counters_on_associations(method_sym)
+      each_counter_cached_association_reflection do |assoc_reflection|
+        reflection_options = assoc_reflection.options
+        next unless reflection_options[:counter_cache]
 
-      return unless [:decrement_counter, :increment_counter].include? method_sym
+        associated_object = send(assoc_reflection.name)
+        next unless associated_object
 
-      each_counter_cached_association_reflection do |assoc_reflection|
-        if associated_object = send(assoc_reflection.name)
-          counter_cache_column = assoc_reflection.counter_cache_column
-          associated_object.class.send(method_sym, counter_cache_column, associated_object.id)
-        end
+        counter_cache_column = assoc_reflection.counter_cache_column
+        associated_object.class.send(method_sym, counter_cache_column,
+                                     associated_object.id)
+        associated_object.touch if reflection_options[:touch]
       end
     end
 
     def each_counter_cached_association_reflection
-      _reflections.each do |name, reflection|
+      _reflections.each do |_name, reflection|
         yield reflection if reflection.belongs_to? && reflection.counter_cache_column
       end
     end
 
     def increment_counters_on_associations
-        update_counters_on_associations :increment_counter
+      update_counters_on_associations :increment_counter
     end
 
     def decrement_counters_on_associations
-        update_counters_on_associations :decrement_counter
+      update_counters_on_associations :decrement_counter
+    end
+
+    def stale_paranoid_value
+      self.paranoid_value = self.class.delete_now_value
+      clear_attribute_changes([self.class.paranoid_column])
     end
   end
 end