on_destroy 0.0.3 → 0.1.0

data/README.md

@@ -31,23 +31,22 @@ Something similar to light version of rails3_acts_as_paranoid could be produced
     default_scope where("deleted_at IS NOT NULL")
     on_destroy :do_not_delete, set: :deleted_at, to: lambda {Time.now}
 
-Do on_destroy for all models with:
+If you have the same deleted column and process for all models, instead of using on_destroy in every model, use configure:
 
     # Do it for everything
     OnDestroy.configure do
       self.do_not_delete = true
-      self.set = [:deleted]
-      self.to = true
+      self.on_destroy_options = [:do_not_delete, {set: :deleted_at, to: lambda {Time.now}]
     end
 
 If you want control over how it intuits how something is deleted (which is to look at the deleted date) use `:is_deleted_if` which can be a value, nil, or a Proc that takes the attribute value:
 
     on_destroy :do_not_delete, set: :some_column, to: lambda {Time.now}, is_deleted_if: {|c|Time.now > c} # provide time-travel resistent behavior of destroyed?/deleted?
-    on_destroy :do_not_delete, set: :some_column, to: 1 is_deleted_if: 1 # this is not necessary, as it will already check for 1 since you specified it in the :to
+    on_destroy :do_not_delete, set: :some_column, to: 1, is_deleted_if: 1 # this is not necessary, as it will already check for 1 since you specified it in the :to
 
 If you use a proc to set the value and a value of nil indicates that it should be deleted (which is kind of wierd), you'll need to set:
 
-    on_destroy :do_not_delete, set: :some_column, to: lambda {nil} is_deleted_if: nil
+    on_destroy :do_not_delete, set: :some_column, to: lambda {nil}, is_deleted_if: nil
 
 To call a normal-ish `destroy` method, use the `really_destroy` method. I think this is better than using `destroy!` because all of the other bang methods on ActiveRecord.base tend to just throw errors, not behave that differently, despite the `destroy!` method being a naming convention from acts_as_paranoid.
 

data/lib/on_destroy/config.rb

@@ -1,9 +1,7 @@
 module OnDestroy
   OPTIONS = [
     :do_not_delete,
-    :set,
-    :to,
-    :is_deleted_if
+    :on_destroy_options,
   ]
   
   class << self
@@ -12,9 +10,8 @@ module OnDestroy
   end
 end
 
-# Do it for everything
+# defaults
 #OnDestroy.configure do
-#  self.do_not_delete = true
-#  self.set = [:deleted]
-#  self.to = true
+#  self.do_not_delete = false
+#  self.on_destroy_options = nil
 #end

data/lib/on_destroy/model.rb

@@ -3,8 +3,6 @@ module OnDestroy
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :defined_is_deleted_if
-      # use values from config
       OnDestroy::OPTIONS.each do |key|
         class_attribute key, instance_writer: true
         self.send("#{key}=".to_sym, OnDestroy.send(key))
@@ -18,20 +16,8 @@ module OnDestroy
       # and to default self.is_deleted_if to a proc that 
       def on_destroy(*args)
         options = args.extract_options!
-        self.do_not_delete = true if args.include?(:do_not_delete)
-        self.set = options[:set] if options[:set]
-        self.to = options[:to] if options[:to]
-        if options[:is_deleted_if]
-          # set defined_is_deleted_if to allow explicit set to nil
-          self.defined_is_deleted_if = true
-          self.is_deleted_if = options[:is_deleted_if]
-        elsif (options[:to].is_a?(Proc))
-          # if :to is a Proc, assume that a nil value means it is not deleted and if not-nil is deleted.
-          # that is just a guess, based on the mark with deleted_at date example.
-          self.is_deleted_if = Proc.new {|v| v != nil}
-        else
-          self.is_deleted_if = Proc.new {|v| v == options[:to]}
-        end
+        self.do_not_delete = args.include?(:do_not_delete)
+        self.on_destroy_options = options
       end
     end
 
@@ -39,11 +25,14 @@ module OnDestroy
 
     # if self.set then will use update_attributes! to set the self.set attribute to self.to or self.to.call if it is a Proc. 
     def do_on_destroy
-      if self.set
-        to_value = self.to.is_a?(Proc) ? self.to.call : self.to
-        update_attributes! self.set => to_value
+      if self.on_destroy_options
+        o_set = self.on_destroy_options[:set]
+        o_to = self.on_destroy_options[:to]
+        if o_set
+          update_attributes! o_set => (o_to.is_a?(Proc) ? o_to.call : o_to)
+        end
+        yield
       end
-      yield
     end
 
     # if self.do_not_delete? runs no/empty callback on :destroy, otherwise calls super.
@@ -62,17 +51,21 @@ module OnDestroy
       run_callbacks(:destroy) {delete}
     end
 
-    # if self.is_deleted_if is a Proc compares self.is_deleted_if.call to send(self.to).
-    # if self.is_deleted_if is not nil compares self.is_deleted_if.call to send(self.to).
-    # If self.is_deleted_if not a Proc, calls super.
     def destroyed?
-      if self.is_deleted_if.is_a?(Proc)
-        self.is_deleted_if.call(self.to)
-      elsif self.is_deleted_if.nil? && !(self.defined_is_deleted_if == true)
-        # will default to super only if self.is_deleted_if not defined by user
-        super
+      if self.on_destroy_options
+        is_deleted_if = self.on_destroy_options[:is_deleted_if]
+        o_set = self.on_destroy_options[:set]
+        o_to = self.on_destroy_options[:to]
+        if is_deleted_if.is_a?(Proc)
+          send(o_set) == is_deleted_if.call
+        elsif o_to.is_a?(Proc)
+          # assume that a :to defined as a Proc is going to evaluate to a non-nil to indicate the model is null
+          send(o_set) != nil
+        else
+          send(o_set) == o_to
+        end
       else
-        self.is_deleted_if == self.to
+        super
       end
     end
 

data/lib/on_destroy/version.rb

@@ -1,3 +1,3 @@
 module OnDestroy
-  VERSION = '0.0.3'
+  VERSION = '0.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: on_destroy
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors: