on_destroy 0.0.1

data/README.md

@@ -0,0 +1,62 @@
+on_destroy
+=====
+
+This is a Rails 3.x ActiveRecord enhancement that allows you to:
+* use `:do_not_delete` option to not call the delete callback on destroy by sending an empty block to `run_callbacks(:destroy)`.
+* use `:set_column` to specify the column to update.
+* use `:to` to specify the value to set the column to.
+
+So, basically it will let you update a column/attribute of a model without actually deleting the record.
+
+Also take a look at [acts_as_paranoid][acts_as_paranoid] [rails3_acts_as_paranoid][rails3_acts_as_paranoid], [soft_destroyable][soft_destroyable], [paranoia][paranoia], and other similar gems to be sure this is what you are looking for. The difference is that this gem does nothing with scoping, it just lets you mark a record as deleted without deleting it when you call destroy. This is just meant to provide a shortcut and slight safeguard in the situations where you want the client side to do the filtering of deleted records so that you can retain references to old models and maybe just color them differently in the UI to indicate that they are no longer active.
+
+Add to your Gemfile:
+
+    gem 'on_destroy'
+
+Then run:
+
+    bundle install
+
+In your model you could include one of the following. You must ensure that the column exists and supports the value you are trying to set on it:
+
+    on_destroy :do_not_delete, set: :some_column, to: 'some string value'
+    on_destroy :do_not_delete, set: :some_column, to: nil
+    on_destroy :do_not_delete, set: :some_column, to: false
+    on_destroy :do_not_delete, set: :some_column, to: 1
+    on_destroy :do_not_delete, set: :some_column, to: lambda {Time.now}
+
+Something similar to light version of rails3_acts_as_paranoid could be produced by the following (note: default_scope is not implemented or affected by this plugin, I'm just using it for an example):
+
+    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:
+
+    # Do it for everything
+    OnDestroy.configure do
+      self.do_not_delete = true
+      self.set = [:deleted]
+      self.to = true
+    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
+
+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
+
+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.
+
+### License
+
+Copyright (c) 2012 Gary S. Weaver, released under the [MIT license][lic].
+
+[paranoia]: https://github.com/radar/paranoia
+[soft_destroyable]: https://github.com/rockrep/soft_destroyable
+[acts_as_paranoid]: http://github.com/technoweenie/acts_as_paranoid
+[rails3_acts_as_paranoid]: https://github.com/goncalossilva/rails3_acts_as_paranoid
+[lic]: http://github.com/garysweaver/on_destroy/blob/master/LICENSE

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/testtask'
+
+#http://nicksda.apotomo.de/2010/10/testing-your-rails-3-engine-sitting-in-a-gem/
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+desc "Run tests"
+task :default => :test

data/lib/on_destroy/config.rb

@@ -0,0 +1,20 @@
+module OnDestroy
+  OPTIONS = [
+    :do_not_delete,
+    :set,
+    :to,
+    :is_deleted_if
+  ]
+  
+  class << self
+    OPTIONS.each{|o|attr_accessor o; define_method("#{o}?".to_sym){!!send("#{o}")}}
+    def configure(&blk); class_eval(&blk); end
+  end
+end
+
+# Do it for everything
+#OnDestroy.configure do
+#  self.do_not_delete = true
+#  self.set = [:deleted]
+#  self.to = true
+#end

data/lib/on_destroy/model.rb

@@ -0,0 +1,81 @@
+module OnDestroy
+  module Model
+    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))
+      end
+      around_destroy :do_on_destroy
+    end
+
+    module ClassMethods
+      # a shortcut to set configuration:
+      # self.do_not_delete, self.set, self.to, self.is_deleted_if
+      # 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 == send(options[:to])}
+        end
+      end
+    end
+
+    # Instance methods
+
+    # 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
+      end
+      yield
+    end
+
+    # if self.do_not_delete? runs no/empty callback on :destroy, otherwise calls super.
+    def destroy
+      if self.do_not_delete?
+        # don't destroy
+        run_callbacks(:destroy) {}
+      else
+        # destroy
+        super
+      end
+    end
+
+    # runs delete callback on :destroy
+    def really_destroy
+      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(send(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
+      else
+        self.is_deleted_if == send(self.to)
+      end
+    end
+
+    alias_method :deleted?, :destroyed?
+  end
+end

data/lib/on_destroy/railtie.rb

@@ -0,0 +1,12 @@
+require 'on_destroy'
+
+module OnDestroy
+  class Railtie < Rails::Railtie
+    initializer "on_destroy.active_record" do
+      ActiveSupport.on_load(:active_record) do
+        # ActiveRecord::Base gets new behavior
+        include OnDestroy::Model
+      end
+    end
+  end
+end

data/lib/on_destroy/version.rb

@@ -0,0 +1,3 @@
+module OnDestroy
+  VERSION = '0.0.1'
+end

data/lib/on_destroy.rb

@@ -0,0 +1,4 @@
+require 'on_destroy/version'
+require 'on_destroy/config'
+require 'on_destroy/model'
+require 'on_destroy/railtie' if defined?(Rails)

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: on_destroy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Gary S. Weaver
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Change ActiveModel's destroy behavior.
+email:
+- garysweaver@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/on_destroy/config.rb
+- lib/on_destroy/model.rb
+- lib/on_destroy/railtie.rb
+- lib/on_destroy/version.rb
+- lib/on_destroy.rb
+- Rakefile
+- README.md
+homepage: https://github.com/garysweaver/on_destroy
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Change destroy's behavior.
+test_files: []