acts_as_paranoid 0.5.0 → 0.7.0

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,18 +16,30 @@ 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?
-
-    class_attribute :paranoid_configuration, :paranoid_column_reference
-
-    self.paranoid_configuration = { :column => "deleted_at", :column_type => "time", :recover_dependent_associations => true, :dependent_recovery_window => 2.minutes }
-    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
+    if !options.is_a?(Hash) && !options.empty?
+      raise ArgumentError, "Hash expected, got #{options.class.name}"
+    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]
+    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
+    }
+    if options[:column_type] == "string"
+      paranoid_configuration.merge!(deleted_value: "deleted")
+    end
+    paranoid_configuration.merge!(allow_nulls: true) if options[:column_type] == "boolean"
+    paranoid_configuration.merge!(options) # user options
 
-    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?
 
@@ -35,28 +48,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,37 +1,48 @@
+# frozen_string_literal: true
+
 module ActsAsParanoid
   module Associations
     def self.included(base)
       base.extend ClassMethods
       class << base
-        alias_method_chain :belongs_to, :deleted
+        alias_method :belongs_to_without_deleted, :belongs_to
+        alias_method :belongs_to, :belongs_to_with_deleted
       end
     end
 
     module ClassMethods
       def belongs_to_with_deleted(target, scope = nil, options = {})
-        with_deleted = (scope.is_a?(Hash) ? scope : options).delete(:with_deleted)
-        result = belongs_to_without_deleted(target, scope, options)
+        if scope.is_a?(Hash)
+          options = scope
+          scope = nil
+        end
 
+        with_deleted = options.delete(:with_deleted)
         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 { #{target}_without_unscoped(*args) }
+            scope = proc do
+              if respond_to? :with_deleted
+                self.with_deleted
+              else
+                all
               end
-              alias_method_chain :#{target}, :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,27 @@ module ActsAsParanoid
         end
       end
 
-    protected
+      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|
+          where("#{table_name}.#{paranoid_column} > ?", time)
+        }
+        scope :deleted_before_time, lambda { |time|
+          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,16 +119,31 @@ 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?
+      stale_paranoid_value
+      freeze
     end
 
     def destroy_fully!
       with_transaction_returning_status do
         run_callbacks :destroy do
           destroy_dependent_associations!
-          # 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]) if persisted?
-          self.paranoid_value = self.class.delete_now_value
+
+          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(id)].transpose])
+            decrement_counters_on_associations
+          end
+
+          stale_paranoid_value
+          @destroyed = true
           freeze
         end
       end
@@ -121,43 +153,63 @@ module ActsAsParanoid
       if !deleted?
         with_transaction_returning_status do
           run_callbacks :destroy do
-            # 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]) if persisted?
-            self.paranoid_value = self.class.delete_now_value
+            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(id)].transpose])
+              decrement_counters_on_associations
+            end
+
+            @_trigger_destroy_callback = true
+
+            stale_paranoid_value
             self
           end
         end
-      else
+      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={})
       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]
-
-          self.paranoid_value = nil
-          self.save
+          if options[:recursive]
+            recover_dependent_associations(options[:recovery_window], options)
+          end
+          increment_counters_on_associations
+          self.paranoid_value = self.class.paranoid_configuration[:recovery_value]
+          if options[:raise_error]
+            save!
+          else
+            save
+          end
         end
       end
     end
 
+    def recover!(options = {})
+      options[:raise_error] = true
+
+      recover(options)
+    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
-
-        # Merge in the association's scope
-        scope = scope.merge(association(reflection.name).association_scope)
+        scope = klass.only_deleted.merge(get_association_scope(reflection: reflection))
 
         # We can only recover by window if both parent and dependant have a
         # paranoid column type of :time.
@@ -175,41 +227,80 @@ module ActsAsParanoid
       self.class.dependent_associations.each do |reflection|
         next unless (klass = get_reflection_class(reflection)).paranoid?
 
-        scope = klass.only_deleted
-
-        # Merge in the association's scope
-        scope = scope.merge(association(reflection.name).association_scope)
-
-        scope.each do |object|
-          object.destroy!
-        end
+        klass
+          .only_deleted.merge(get_association_scope(reflection: reflection))
+          .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_association_scope(reflection:)
+      ActiveRecord::Associations::AssociationScope.scope(association(reflection.name))
+    end
+
     def get_reflection_class(reflection)
       if reflection.macro == :belongs_to && reflection.options.include?(:polymorphic)
-        self.send(reflection.foreign_type).constantize
+        send(reflection.foreign_type).constantize
       else
         reflection.klass
       end
     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)
+      return unless [:decrement_counter, :increment_counter].include? method_sym
+
+      each_counter_cached_association_reflection do |assoc_reflection|
+        associated_object = send(assoc_reflection.name)
+        next unless associated_object
+
+        counter_cache_column = assoc_reflection.counter_cache_column
+        associated_object.class.send(method_sym, counter_cache_column,
+                                     associated_object.id)
+      end
+    end
+
+    def each_counter_cached_association_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
+    end
+
+    def decrement_counters_on_associations
+      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