acts_as_paranoid 0.6.3 → 0.7.1

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,7 +119,7 @@ module ActsAsParanoid
     end
 
     def paranoid_value
-      self.send(self.class.paranoid_column)
+      send(self.class.paranoid_column)
     end
 
     # Straight from ActiveRecord 5.1!
@@ -118,9 +135,10 @@ 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
 
@@ -135,11 +153,11 @@ 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
 
@@ -149,38 +167,39 @@ module ActsAsParanoid
             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],
-        :raise_error => false
+        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]
+          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]
-            self.save!
+            save!
           else
-            self.save
+            save
           end
         end
       end
     end
 
-    def recover!(options={})
+    def recover!(options = {})
       options[:raise_error] = true
 
       recover(options)
@@ -190,14 +209,7 @@ 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 = if ActiveRecord::VERSION::MAJOR >= 6
-          scope.merge(ActiveRecord::Associations::AssociationScope.scope(association(reflection.name)))
-        else
-          scope.merge(association(reflection.name).association_scope)
-        end
+        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.
@@ -215,77 +227,77 @@ 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 = 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(reflection: reflection))
+          .each(&:destroy!)
       end
     end
 
     def deleted?
-      @destroyed || !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_method :destroyed_fully?, :deleted_fully?
+    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
+    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

data/lib/acts_as_paranoid/relation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsParanoid
   module Relation
     def self.included(base)

data/lib/acts_as_paranoid/validations.rb

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/array/wrap'
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/wrap"
 
 module ActsAsParanoid
   module Validations
@@ -6,85 +8,17 @@ module ActsAsParanoid
       base.extend ClassMethods
     end
 
-    class UniquenessWithoutDeletedValidator
-      def self.[](version)
-        name = "V#{version.to_s.tr('.', '_')}"
-        unless constants.include? name.to_sym
-          raise "Unknown validator version #{name.inspect}; expected one of #{constants.sort.join(', ')}"
-        end
-        const_get name
-      end
-
-      class V5 < ActiveRecord::Validations::UniquenessValidator
-        def validate_each(record, attribute, value)
-          finder_class = find_finder_class_for(record)
-          table = finder_class.arel_table
-
-          relation = build_relation(finder_class, attribute, value)
-          [Array(finder_class.primary_key), Array(record.send(:id))].transpose.each do |pk_key, pk_value|
-            relation = relation.where(table[pk_key.to_sym].not_eq(pk_value))
-          end if record.persisted?
-
-          Array.wrap(options[:scope]).each do |scope_item|
-            relation = relation.where(table[scope_item].eq(record.public_send(scope_item)))
-          end
-
-          if relation.where(finder_class.paranoid_default_scope).exists?(relation)
-            record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
-          end
-        end
-
-        protected
-
-        def build_relation(klass, attribute, value)
-          if ActiveRecord::VERSION::MINOR == 0 && ActiveRecord::VERSION::MAJOR == 5
-            return super(klass, klass.arel_table, attribute, value)
-          else
-            super
-          end
-        end
-      end
-
-      class V4 < ActiveRecord::Validations::UniquenessValidator
-        def validate_each(record, attribute, value)
-          finder_class = find_finder_class_for(record)
-          table = finder_class.arel_table
-
-          # TODO: Use record.class.column_types[attribute.to_s].coder ?
-          coder = record.class.column_types[attribute.to_s]
-
-          if value && coder
-            value = if coder.respond_to? :type_cast_for_database
-                      coder.type_cast_for_database value
-                    else
-                      coder.type_cast_for_write value
-                    end
-          end
-
-          relation = build_relation(finder_class, table, attribute, value)
-          [Array(finder_class.primary_key), Array(record.send(:id))].transpose.each do |pk_key, pk_value|
-            relation = relation.and(table[pk_key.to_sym].not_eq(pk_value))
-          end if record.persisted?
-
-          Array.wrap(options[:scope]).each do |scope_item|
-            scope_value = record.send(scope_item)
-            relation = relation.and(table[scope_item].eq(scope_value))
-          end
-
-          # Re-add ActsAsParanoid default scope conditions manually.
-          if finder_class.unscoped.where(finder_class.paranoid_default_scope).where(relation).exists?
-            record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
-          end
-        end
-      end
+    class UniquenessWithoutDeletedValidator < ActiveRecord::Validations::UniquenessValidator
+      private
 
-      class V6 < V5
+      def build_relation(klass, attribute, value)
+        super.where(klass.paranoid_default_scope)
       end
     end
 
     module ClassMethods
       def validates_uniqueness_of_without_deleted(*attr_names)
-        validates_with UniquenessWithoutDeletedValidator[ActiveRecord::VERSION::MAJOR], _merge_attributes(attr_names)
+        validates_with UniquenessWithoutDeletedValidator, _merge_attributes(attr_names)
       end
     end
   end

data/lib/acts_as_paranoid/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsParanoid
-  VERSION = "0.6.3"
+  VERSION = "0.7.1"
 end

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,29 @@ 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
-
-    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]
+    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
 
-    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 +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