paranoid_create 0.0.10

data/.gitignore

@@ -0,0 +1,3 @@
+paranoid.db
+.rvmrc
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,4 @@
+source('http://rubygems.org')
+
+# Specify your gem's dependencies in paranoid.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Xspond Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.textile

@@ -0,0 +1,109 @@
+h1. paranoid
+
+h3. advice and disclaimer
+
+You should never expect _any_ library to work or behave exactly how you want it to:  test, test, test and file an issue if you have any problems. Bonus points if you include sample failing code.  Extra bonus points if you send a pull request that implements a feature/fixes a bug.
+
+h3. How did I get here?
+
+Sometimes you want to delete something in ActiveRecord, but you realize you might need it later (for an undo feature, or just as a safety net, etc.). There are a plethora of plugins that accomplish this, the most famous of which was the venerable acts_as_paranoid which is great but not really actively developed any more. What's more, acts_as_paranoid was written for an older version of ActiveRecord. Is_paranoid was written for ActiveRecord 2.3 and default_scope. This however became, as the author stated, a mess of hacks to catch all the edge cases. *Paranoid* is an attempt to utilize ActiveRecord::Relation and JoinDependency in ActiveRecord 3 to do all the heavy lifting without using default_scope and with_exclusive_scope.
+
+h3. How does it work?
+
+You should read the specs, or the RDOC, or even the source itself (which is very readable), but for the lazy, here's the hand-holding:
+
+You need ActiveRecord 3 and you need to properly install this gem.  Then you need a model with a field to serve as a flag column on its database table. For this example we'll use a timestamp named "deleted_at".  If that column is null, the item isn't deleted.  If it has a timestamp, it should count as deleted.
+
+So let's assume we have a model Automobile that has a deleted_at column on the automobiles table.
+
+If you're working with Rails, in your Gemfile, add the following (you may want to change the version number).
+
+<pre>
+gem "paranoid", :require => 'paranoid', :version => ">= 0.1.0"
+</pre>
+
+Then in your ActiveRecord model
+
+<pre>
+class Automobile < ActiveRecord::Base
+  paranoid
+end
+</pre>
+
+Now our automobiles are soft-deleteable.
+
+<pre>
+that_large_automobile = Automobile.create()
+Automobile.count # => 1
+
+that_large_automobile.destroy
+Automobile.count # => 0
+Automobile.with_destroyed.count # => 1
+
+# where is that large automobile?
+that_large_automobile = Automobile.with_destroyed.first
+that_large_automobile.restore
+Automobile.count # => 1
+</pre>
+
+One thing to note, destroying is always undo-able, but deleting is not.  This is a behavior difference between acts_as_paranoid and paranoid and the same as is_paranoid.
+
+<pre>
+Automobile.destroy_all
+Automobile.count # => 0
+Automobile.with_destroyed.count # => 1
+
+Automobile.delete_all
+Automobile.with_destroyed.count # => 0
+# And you may say to yourself, "My god!  What have I done?"
+</pre>
+
+You can also lookup only destroyed record with with_destroyed_only.
+
+<pre>
+auto1 = Automobile.create()
+auto2 = Automobile.create()
+auto2.destroy
+Automobile.count # => 1
+Automobile.with_destroyed.count # => 2
+Automobile.with_destroyed_only.count # => 1
+Automobile.with_destroyed_only.first # => auto2
+</pre>
+
+h3. Specifying alternate rules for what should be considered destroyed
+
+"deleted_at" as a timestamp is what acts_as_paranoid uses to define what is and isn't destroyed (see above), but you can specify alternate options with paranoid.  In the paranoid line of your model you can specify the field, the value the field should have if the entry should count as destroyed, and the value the field should have if the entry is not destroyed.  Consider the following models:
+
+<pre>
+class Pirate < ActiveRecord::Base
+  paranoid :field => [:alive, false, true]
+end
+
+class DeadPirate < ActiveRecord::Base
+  set_table_name :pirates
+  paranoid :field => [:alive, true, false]
+end
+</pre>
+
+These two models share the same table, but when we are finding Pirates, we're only interested in those that are alive.  To break it down, we specify :alive as our field to check, false as what the model field should be marked at when destroyed and true to what the field should be if they're not destroyed.  DeadPirates are specified as the opposite.  Check out the specs if you're still confused.
+
+h3. Note about validates_uniqueness_of:
+
+validates_uniqueness_of does not, by default, ignore items marked with a deleted_at (or other field name) flag.  This is a behavior difference between paranoid and acts_as_paranoid and the same as is_paranoid.  You can overcome this by specifying the field name you are using to mark destroyed items as your scope.  Example:
+
+<pre>
+class Android < ActiveRecord::Base
+  validates_uniqueness_of :name, :scope => :deleted_at
+  paranoid
+end
+</pre>
+
+And now the validates_uniqueness_of will ignore items that are destroyed.
+
+h3. and you may ask yourself, where does that highway go to?
+
+If you find any bugs, have any ideas of features you think are missing, or find things you're like to see work differently, feel free to file an issue or send a pull request.
+
+h3. Thanks
+
+Thanks to Rick Olson for acts_as_paranoid and to Jeffrey Chupp for is_paranoid.

data/Rakefile

@@ -0,0 +1,11 @@
+require('bundler')
+require('rspec/core/rake_task')
+
+Bundler::GemHelper.install_tasks
+
+desc('Run RSpec')
+RSpec::Core::RakeTask.new do |t|
+  t.verbose = false
+end
+
+task(:default => :spec)

data/init.rb

@@ -0,0 +1 @@
+require 'paranoid'

data/lib/paranoid/base.rb

@@ -0,0 +1,65 @@
+module Paranoid
+  module Base
+    # Call this in your model to enable paranoid.
+    #
+    # === Examples
+    #
+    #   Post < ActiveRecord::Base
+    #     paranoid
+    #   end
+    #
+    #   Item < ActiveRecord::Base
+    #     paranoid :field => [:available, fales, true]
+    #   end
+    #
+    # === Options
+    #
+    # [:field]
+    #   The field used to recognize a record as destroyed.
+    #   Default: :deleted_at
+    #   IsParanoid Compatibility: Also accepts an Array of form
+    #   [field_name, destroyed_value, not_destroyed_value]
+    #   however :destroyed_value and :not_destroyed_value will
+    #   be ignored
+    #
+    # [:destroyed_value]
+    #   The value to set the paranoid field to on destroy.
+    #   Can be either a static value or a Proc which will be
+    #   evaluated when destroy is called.
+    #   Default: Proc.new{Time.now.utc}
+    #
+    # [:not_destroyed_value]
+    #   The value used to recognize a record as not destroyed.
+    #   Default: nil
+    def paranoid(opts = {})
+      return if paranoid?
+      @paranoid = true
+
+      opts[:field] ||= [:deleted_at, Proc.new{Time.now.utc}, nil]
+      class_inheritable_accessor :destroyed_field, :field_destroyed, :field_not_destroyed
+      if opts[:field].is_a?(Array)
+        self.destroyed_field, self.field_destroyed, self.field_not_destroyed = opts[:field]
+      else
+        self.destroyed_field = opts.key?(:field) ? opts[:field] : :deleted_at
+        self.field_destroyed = opts.key?(:destroyed_value) ? opts[:destroyed_value] : Proc.new{Time.now.utc}
+        self.field_not_destroyed = opts.key?(:not_destroyed_value) ? opts[:not_destroyed_value] : nil
+      end
+
+      include Paranoid::ParanoidMethods
+
+      class_eval do
+        class << self
+          delegate :with_destroyed, :with_destroyed_only, :to => :scoped
+        end
+      end
+    end
+
+    # Returns true if the model is paranoid and paranoid is enabled
+    def paranoid?
+      @paranoid = (self != ActiveRecord::Base && self.superclass.paranoid?) unless defined?(@paranoid)
+      @paranoid
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval { extend Paranoid::Base }

data/lib/paranoid/join_association.rb

@@ -0,0 +1,24 @@
+module Paranoid
+  module JoinAssociation
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method_chain :association_join, :paranoid
+    end
+
+    # Overrides ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation#association_join
+    # adding paranoid conditions when necessary
+    def association_join_with_paranoid
+      return @join if @join
+      result = association_join_without_paranoid
+      if reflection.klass.paranoid?
+        aliased_table = Arel::Table.new(table_name, :as => @aliased_table_name, :engine => arel_engine)
+        pb = ActiveRecord::PredicateBuilder.new(arel_engine)
+        result.concat(pb.build_from_hash(reflection.klass.paranoid_condition, aliased_table))
+      end
+      result
+    end
+  end
+end
+
+ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.class_eval { include Paranoid::JoinAssociation }

data/lib/paranoid/paranoid_methods.rb

@@ -0,0 +1,92 @@
+module Paranoid
+  module ParanoidMethods
+    extend ActiveSupport::Concern
+
+    included do
+      extend ClassMethods
+      alias_method_chain :create_or_update, :paranoid
+    end
+
+    module ClassMethods
+      # Returns the condition used to scope the return to exclude
+      # soft deleted records
+      def paranoid_condition
+        {destroyed_field => field_not_destroyed}
+      end
+
+      # Returns the condition used to scope the return to contain
+      # only soft deleted records
+      def paranoid_only_condition
+        val = field_not_destroyed.respond_to?(:call) ? field_not_destroyed.call : field_not_destroyed
+        column_sql = self.sanitize_sql_for_assignment(destroyed_field)
+        case val
+        when nil then "#{column_sql} IS NOT NULL"
+        else          ["#{column_sql} != ?", val]
+        end
+      end
+
+      # Temporarily disables paranoid on the model
+      def disable_paranoid
+        if block_given?
+          @paranoid = false
+          yield
+        else
+          raise 'Only block form is supported'
+        end
+      ensure
+        @paranoid = true
+      end
+    end
+
+    # Restores the record
+    def restore
+      set_destroyed(field_not_destroyed.respond_to?(:call) ? field_not_destroyed.call : field_not_destroyed)
+      
+      self.class.reflect_on_all_associations.each do |association|
+        if association.options[:dependent] == :destroy && association.klass.paranoid?
+          restore_related(association.klass, association.primary_key_name, association.options[:primary_key] || 'id', association.options) if association.macro.to_s =~ /^has/
+        end
+      end
+      
+      @destroyed = false
+      self
+    end
+
+    # Override the default destroy to allow us to soft delete records.
+    # This preserves the before_destroy and after_destroy callbacks.
+    # Because this is also called internally by Model.destroy_all and
+    # the Model.destroy(id), we don't need to specify those methods
+    # separately.
+    def destroy
+      _run_destroy_callbacks do
+        set_destroyed(field_destroyed.respond_to?(:call) ? field_destroyed.call : field_destroyed)
+        @destroyed = true
+      end
+
+      self
+    end
+
+    protected
+
+    # Overrides ActiveRecord::Base#create_or_update
+    # to disable paranoid during the create and update operations
+    def create_or_update_with_paranoid
+      self.class.disable_paranoid { create_or_update_without_paranoid }
+    end
+
+    # Set the value for the destroyed field.
+    def set_destroyed(val)
+      self[destroyed_field] = val
+      updates = Arel::Nodes::SqlLiteral.new(self.class.send(:sanitize_sql_for_assignment, {destroyed_field => val}))
+      self.class.unscoped.with_destroyed.where(self.class.arel_table[self.class.primary_key].eq(id)).arel.update(updates)
+      @destroyed = true
+    end
+    
+    # Restores related records
+    def restore_related(klass, key_name, id_name, options)
+      klass.unscoped.with_destroyed_only.where(klass.arel_table[key_name].eq(send(id_name))).each do |model|
+        model.restore
+      end
+    end
+  end
+end

data/lib/paranoid/relation.rb

@@ -0,0 +1,81 @@
+module Paranoid
+  module Relation
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method_chain :arel, :paranoid
+      alias_method_chain :delete_all, :paranoid
+      alias_method_chain :except, :paranoid
+      alias_method_chain :only, :paranoid
+    end
+
+    # Returns true if the relation should be scoped to
+    # exclude soft deleted records
+    def add_paranoid_condition?
+      @add_paranoid = true unless defined?(@add_paranoid)
+      @klass.paranoid? && @add_paranoid
+    end
+
+    # Overrides ActiveRecord::Relation#arel
+    def arel_with_paranoid
+      if add_paranoid_condition?
+        @arel ||= without_destroyed.arel_without_paranoid
+      else
+        arel_without_paranoid
+      end
+    end
+
+    # Overrides ActiveRecord::Relation#delete_all
+    # forcing delete_all to ignore deleted flag
+    def delete_all_with_paranoid(*args)
+      if add_paranoid_condition?
+        with_destroyed.delete_all_without_paranoid(*args)
+      else
+        delete_all_without_paranoid(*args)
+      end
+    end
+
+    # Overrides ActiveRecord::Relation#except
+    def except_with_paranoid(*args)
+      result = except_without_paranoid(*args)
+      result.instance_variable_set(:@add_paranoid, @add_paranoid) if defined?(@add_paranoid)
+      result
+    end
+
+    # Overrides ActiveRecord::Relation#only
+    def only_with_paranoid(*args)
+      result = only_without_paranoid(*args)
+      result.instance_variable_set(:@add_paranoid, @add_paranoid) if defined?(@add_paranoid)
+      result
+    end
+
+    # Returns a new relation scoped to include soft deleted records
+    def with_destroyed
+      clone.tap {|relation| relation.skip_paranoid_condition }
+    end
+
+    # Returns a new relation scoped to include only deleted records
+    def with_destroyed_only
+      where(@klass.paranoid_only_condition).tap {|relation| relation.skip_paranoid_condition }
+    end
+
+    # Can be used to force the exclusion of soft deleted records down
+    # the chain from a with_destroyed call. *WARNING*: with_destroyed
+    # will do nothing after this has been called! So
+    # Model.without_destroyed.with_destroyed.all will *NOT* return
+    # soft deleted records
+    def without_destroyed
+      where(@klass.paranoid_condition).tap {|relation| relation.skip_paranoid_condition }
+    end
+
+    protected
+
+    # Tell the relation to skip adding the paranoid conditions. DO NOT
+    # call directly. Call with_destroyed.
+    def skip_paranoid_condition
+      @add_paranoid = false
+    end
+  end
+end
+
+ActiveRecord::Relation.class_eval { include Paranoid::Relation }

data/lib/paranoid/version.rb

@@ -0,0 +1,3 @@
+module Paranoid
+  VERSION = '0.0.10'
+end

data/lib/paranoid.rb

@@ -0,0 +1,5 @@
+require 'active_record'
+require 'paranoid/base'
+require 'paranoid/paranoid_methods'
+require 'paranoid/relation'
+require 'paranoid/join_association'

data/paranoid.gemspec

@@ -0,0 +1,26 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# -*- encoding: utf-8 -*-
+$:.push(File.expand_path('../lib', __FILE__))
+require('paranoid/version')
+
+Gem::Specification.new do |s|
+  s.name        = 'paranoid_create'
+  s.version     = Paranoid::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Philipp Ullmann']
+  s.email       = 'philipp.ullmann@create.at'
+  s.homepage    = 'http://github.com/create-philipp-ullmann/paranoid/'
+  s.summary     = 'Enable soft delete of ActiveRecord records. Based off defunct ActsAsParanoid and IsParanoid'
+
+  s.rubyforge_project = 'paranoid_create'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+  
+  s.add_development_dependency('rspec', ['>= 2.5.0'])
+  s.add_development_dependency('sqlite3-ruby', ['>= 1.3.3'])
+  s.add_development_dependency('activerecord', ['>= 3.0.5'])
+end