paranoid_fu 0.4.0

data/CHANGELOG

@@ -0,0 +1,85 @@
+* (5 Nov 2009)
+Rewrite to use named_scopes
+Remove with_deleted option, now it's the default behavior
+Add without_deleted option to get the previous behavior
+Fix belongs_to polymorphic associations
+
+* (16 Apr 2009)
+
+Allow :with_deleted and :only_deleted options to work with count and calculate.
+Fixes compatibility with will_paginate. [James Le Cuirot]
+
+* (4 Oct 2007)
+
+Update for Edge rails: remove support for legacy #count args 
+
+* (2 Feb 2007)
+
+Add support for custom primary keys [Jeff Dean]
+
+* (2 July 2006)
+
+Add paranoid delete_all implementation [Marshall Roch]
+
+* (23 May 2006)
+
+Allow setting of future dates for content expiration.
+
+* (15 May 2006)
+
+Added support for dynamic finders
+
+* (28 Mar 2006)
+
+Updated for Rails 1.1.  I love removing code.
+
+  Refactored #find method
+  Nested Scopes
+
+*0.3.1* (20 Dec 2005)
+
+* took out deleted association code for 'chainsaw butchery of base classes' [sorry Erik Terpstra]
+* verified tests pass on Rails 1.0
+
+*0.3* (27 Nov 2005)
+
+* Deleted models will find deleted associations by default now [Erik Terpstra]
+* Added :group as valid option for find [Michael Dabney]
+* Changed the module namespace to Caboose::Acts::Paranoid
+
+*0.2.0* (6 Nov 2005)
+
+* Upgrade to Rails 1.0 RC4.  ActiveRecord::Base#constrain has been replaced with scope_with.
+
+*0.1.7* (22 Oct 2005)
+
+* Added :with_deleted as a valid option of ActiveRecord::Base#find
+
+*0.1.6* (25 Sep 2005)
+
+* Fixed bug where nested constrains would get clobbered after multiple queries
+
+*0.1.5* (22 Sep 2005)
+
+* Fixed bug where acts_as_paranoid would clobber other constrains
+* Simplified acts_as_paranoid mixin including.
+
+*0.1.4* (18 Sep 2005)
+
+* First RubyForge release
+
+*0.1.3* (18 Sep 2005)
+
+* ignore multiple calls to acts_as_paranoid on the same model
+
+*0.1.2* (18 Sep 2005)
+
+* fixed a bug that kept you from selecting the first deleted record
+
+*0.1.1* (18 Sep 2005)
+
+* Fixed bug that kept you from selecting deleted records by ID
+
+*0.1* (17 Sep 2005)
+
+* Initial gem

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2005 Rick Olson
+
+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

@@ -0,0 +1,5 @@
+= paranoid_fu
+
+Overrides some basic methods for the current model so that calling #destroy sets a 'deleted_at' field to the current timestamp.  ActiveRecord is required.
+
+http://github.com/scambra/paranoid_fu

data/RUNNING_UNIT_TESTS

@@ -0,0 +1,10 @@
+1. Pick Rails version.  Either dump this plugin in a Rails app and run it from there, or specify it as an ENV var:
+
+  RAILS=2.2.2 rake
+  RAILS=2.2.2 ruby test/paranoid_test.rb
+
+2. Setup your database.  By default sqlite3 is used, and no further setup is necessary.  You can pick any of the listed databases in test/database.yml.  Be sure to create the database first.
+
+  DB=mysql rake
+
+3. Profit!!

data/lib/paranoid_fu.rb

@@ -0,0 +1,6 @@
+module ParanoidFu; end
+ActiveRecord::Associations::BelongsToPolymorphicAssociation.send :include, ParanoidFu::BelongsToPolymorphicAssociation
+ActiveRecord::Reflection::MacroReflection.send :include, ParanoidFu::ReflectionConditions
+ActiveRecord::Base.send :extend, ParanoidFu::Associations
+ActiveRecord::Base.send :extend, ParanoidFu::AssociationPreload
+ActiveRecord::Base.send :include, ParanoidFu::Paranoid

data/lib/paranoid_fu/association_preload.rb

@@ -0,0 +1,12 @@
+module ParanoidFu
+  module AssociationPreload
+    def set_association_single_records(id_to_record_map, reflection_name, associated_records, key)
+      reflection = reflect_on_association(reflection_name)
+      # only it's needed to reject deleted records for polymorphic belongs_to, because in other case deleted records won't be loaded
+      if reflection.options[:without_deleted] && reflection.options[:polymorphic]
+        associated_records.delete_if {|item| item.class.paranoid? && item.deleted?}
+      end
+      super
+    end
+  end
+end

data/lib/paranoid_fu/associations.rb

@@ -0,0 +1,30 @@
+module ParanoidFu #:nodoc:
+  module Associations
+    # === Options
+    # [:without_deleted]
+    #  Don't load associated object if it's deleted.
+    def belongs_to(association_id, options = {})
+      without_deleted = options.delete :without_deleted
+      returning super(association_id, options) do
+        restore_without_deleted(association_id, without_deleted)
+      end
+    end
+  
+    def has_many(association_id, options = {}, &extension)
+      without_deleted = options.delete :without_deleted
+      returning super(association_id, options, &extension) do
+        restore_without_deleted(association_id, without_deleted)
+      end
+    end
+  
+    protected
+    def restore_without_deleted(association_id, value)
+      if value
+        reflection = reflect_on_association(association_id)
+        reflection.options[:without_deleted] = value
+        # has_many :through doesn't use sanitized_conditions, so we set the conditions in options hash
+        reflection.options[:conditions] = reflection.sanitized_conditions unless reflection.options[:polymorphic]
+      end
+    end
+  end
+end

data/lib/paranoid_fu/belongs_to_polymorphic_association.rb

@@ -0,0 +1,25 @@
+module ParanoidFu
+  module BelongsToPolymorphicAssociation
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :find_target, :paranoid_fu
+      end
+    end
+
+    def find_target_with_paranoid_fu
+      old_conditions = @reflection.options[:conditions]
+      if @reflection.options[:without_deleted]
+        # conditions method is not called if conditions isn't set in options hash
+        @reflection.options[:conditions] = association_class.merge_conditions(@reflection.options[:conditions], association_class.without_deleted_conditions(association_class.table_name))
+      end
+      find_target_without_paranoid_fu
+    ensure
+      # restore conditions in options hash
+      @reflection.options[:conditions] = old_conditions
+    end
+
+    def conditions
+      @conditions ||= interpolate_sql(association_class.send(:sanitize_sql, @reflection.options[:conditions])) if @reflection.options[:conditions]
+    end
+  end
+end

data/lib/paranoid_fu/paranoid.rb

@@ -0,0 +1,134 @@
+module ParanoidFu #:nodoc:
+  # Overrides some basic methods for the current model so that calling #destroy sets a 'deleted_at' field to the current timestamp.
+  # This assumes the table has a deleted_at date/time field.  Most normal model operations will work, but there will be some oddities.
+  #
+  #   class Widget < ActiveRecord::Base
+  #     paranoid_fu
+  #   end
+  #
+  #   Widget.find(:all)
+  #   # SELECT * FROM widgets WHERE widgets.deleted_at IS NULL
+  #
+  #   Widget.find(:first, :conditions => ['title = ?', 'test'], :order => 'title')
+  #   # SELECT * FROM widgets WHERE widgets.deleted_at IS NULL AND title = 'test' ORDER BY title LIMIT 1
+  #
+  #   Widget.find_with_deleted(:all)
+  #   # SELECT * FROM widgets
+  #
+  #   Widget.find_only_deleted(:all)
+  #   # SELECT * FROM widgets WHERE widgets.deleted_at IS NOT NULL
+  #
+  #   Widget.find_with_deleted(1).deleted?
+  #   # Returns true if the record was previously destroyed, false if not 
+  #
+  #   Widget.count
+  #   # SELECT COUNT(*) FROM widgets WHERE widgets.deleted_at IS NULL
+  #
+  #   Widget.count ['title = ?', 'test']
+  #   # SELECT COUNT(*) FROM widgets WHERE widgets.deleted_at IS NULL AND title = 'test'
+  #
+  #   Widget.count_with_deleted
+  #   # SELECT COUNT(*) FROM widgets
+  #
+  #   Widget.count_only_deleted
+  #   # SELECT COUNT(*) FROM widgets WHERE widgets.deleted_at IS NOT NULL
+  #
+  #   Widget.delete_all
+  #   # UPDATE widgets SET deleted_at = '2005-09-17 17:46:36'
+  #
+  #   Widget.delete_all!
+  #   # DELETE FROM widgets
+  #
+  #   @widget.destroy
+  #   # UPDATE widgets SET deleted_at = '2005-09-17 17:46:36' WHERE id = 1
+  #
+  #   @widget.destroy!
+  #   # DELETE FROM widgets WHERE id = 1
+  # 
+  module Paranoid
+    def self.included(base) # :nodoc:
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def paranoid_fu(options = {})
+        unless paranoid? # don't let AR call this twice
+          cattr_accessor :deleted_attribute
+          self.deleted_attribute = options[:with] || :deleted_at
+          alias_method :destroy_without_callbacks!, :destroy_without_callbacks
+          class << self
+            alias_method :delete_all!, :delete_all
+          end
+          named_scope :without_deleted, lambda{ {:conditions => without_deleted_conditions} }
+          named_scope :only_deleted, lambda{ {:conditions => only_deleted_conditions} }
+        end
+        include InstanceMethods
+      end
+
+      def paranoid?
+        self.included_modules.include?(InstanceMethods)
+      end
+    end
+
+    module InstanceMethods #:nodoc:
+      def self.included(base) # :nodoc:
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def delete_all(conditions = nil)
+          self.update_all ["#{self.deleted_attribute} = ?", current_time], conditions
+        end
+
+        def without_deleted_conditions(table_name = table_name)
+          ["#{table_name}.#{deleted_attribute} IS NULL OR #{table_name}.#{deleted_attribute} > ?", current_time]
+        end
+
+        def only_deleted_conditions(table_name = table_name)
+          ["#{table_name}.#{deleted_attribute} IS NOT NULL AND #{table_name}.#{deleted_attribute} <= ?", current_time]
+        end
+
+        protected
+        def current_time
+          default_timezone == :utc ? Time.now.utc : Time.now
+        end
+      end
+
+      def destroy_without_callbacks
+        unless new_record?
+          self.class.update_all self.class.send(:sanitize_sql, ["#{self.class.deleted_attribute} = ?", (self.deleted_at = self.class.send(:current_time))]), ["#{self.class.primary_key} = ?", id]
+        end
+        freeze
+      end
+
+      def destroy_with_callbacks!
+        return false if callback(:before_destroy) == false
+        result = destroy_without_callbacks!
+        callback(:after_destroy)
+        result
+      end
+
+      def destroy!
+        transaction { destroy_with_callbacks! }
+      end
+
+      def deleted?
+        !!read_attribute(:deleted_at)
+      end
+
+      def recover!
+        self.deleted_at = nil
+        save!
+      end
+      
+      def recover_with_associations!(*associations)
+        self.recover!
+        associations.to_a.each do |assoc|
+          self.send(assoc).all.each do |a|
+            a.recover! if a.class.paranoid?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/paranoid_fu/reflection_conditions.rb

@@ -0,0 +1,24 @@
+module ParanoidFu
+  module ReflectionConditions
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :sanitized_conditions, :paranoid_fu
+      end
+    end
+  
+    # Returns the SQL string that corresponds to the <tt>:conditions</tt>
+    # option of the macro, if given, or +nil+ otherwise.
+    def sanitized_conditions_with_paranoid_fu
+      sanitized_conditions_without_paranoid_fu
+      if !self.options[:polymorphic] && self.options.delete(:without_deleted)
+        klass = if self.through_reflection
+          self.through_reflection.klass
+        else
+          self.klass
+        end
+        @sanitized_conditions = klass.merge_conditions(@sanitized_conditions, klass.without_deleted_conditions(klass.table_name)) if klass
+      end
+      @sanitized_conditions
+    end
+  end
+end

data/test/database.yml

@@ -0,0 +1,18 @@
+sqlite:
+  :adapter: sqlite
+  :database: paranoid_fu_plugin.sqlite.db
+sqlite3:
+  :adapter: sqlite3
+  :database: paranoid_fu_plugin.sqlite3.db
+postgresql:
+  :adapter: postgresql
+  :username: postgres
+  :password: postgres
+  :database: paranoid_fu_plugin_test
+  :min_messages: ERROR
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: rails
+  :password:
+  :database: paranoid_fu_plugin_test

data/test/fixtures/categories.yml

@@ -0,0 +1,19 @@
+category_1:
+  id: 1
+  widget_id: 1
+  title: 'category 1'
+category_2:
+  id: 2
+  widget_id: 1
+  title: 'category 2'
+  deleted_at: '2005-01-01 00:00:00'
+category_3:
+  id: 3
+  widget_id: 2
+  title: 'category 3'
+  deleted_at: '2005-01-01 00:00:00'
+category_4:
+  id: 4
+  widget_id: 2
+  title: 'category 4'
+  deleted_at: '2005-01-01 00:00:00'

data/test/fixtures/categories_widgets.yml

@@ -0,0 +1,12 @@
+cw_1:
+  category_id: 1
+  widget_id: 1
+cw_2:
+  category_id: 2
+  widget_id: 1
+cw_3:
+  category_id: 3
+  widget_id: 2
+cw_4:
+  category_id: 4
+  widget_id: 2

data/test/fixtures/orders.yml

@@ -0,0 +1,8 @@
+order_1:
+  id: 1
+  item_id: 2
+  item_type: Widget
+order_2:
+  id: 2
+  item_id: 1
+  item_type: Category

data/test/fixtures/taggings.yml

@@ -0,0 +1,9 @@
+tagging_1:
+  id: 1
+  tag_id: 1
+  widget_id: 1
+  deleted_at: '2005-01-01 00:00:00'
+tagging_2:
+  id: 2
+  tag_id: 2
+  widget_id: 1

data/test/fixtures/tags.yml

@@ -0,0 +1,6 @@
+tag_1:
+  id: 1
+  name: 'tag 1'
+tag_2:
+  id: 2
+  name: 'tag 1'

data/test/fixtures/widgets.yml

@@ -0,0 +1,8 @@
+widget_1:
+  id: 1
+  title: 'widget 1'
+widget_2:
+  id: 2
+  title: 'deleted widget 2'
+  deleted_at: '2005-01-01 00:00:00'
+  category_id: 3

data/test/paranoid_test.rb

@@ -0,0 +1,323 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Tagging < ActiveRecord::Base
+  belongs_to :tag
+  belongs_to :widget
+  paranoid_fu
+end
+
+class Widget < ActiveRecord::Base
+  paranoid_fu
+  has_many :categories, :dependent => :destroy
+  has_and_belongs_to_many :habtm_categories, :class_name => 'Category'
+  has_one :category
+  belongs_to :parent_category, :class_name => 'Category'
+  has_many :taggings
+  has_many :tags, :through => :taggings, :without_deleted => true
+  has_many :any_tags, :through => :taggings, :class_name => 'Tag', :source => :tag
+end
+
+class Category < ActiveRecord::Base
+  paranoid_fu
+  belongs_to :widget, :without_deleted => true
+  belongs_to :any_widget, :class_name => 'Widget', :foreign_key => 'widget_id'
+
+  def self.search(name, options = {})
+    without_deleted.all options.merge(:conditions => ['LOWER(title) LIKE ?', "%#{name.to_s.downcase}%"])
+  end
+
+  def self.search_with_deleted(name, options = {})
+    all options.merge(:conditions => ['LOWER(title) LIKE ?', "%#{name.to_s.downcase}%"])
+  end
+end
+
+class Tag < ActiveRecord::Base
+  has_many :taggings
+  has_many :widgets, :through => :taggings
+end
+
+class Order < ActiveRecord::Base
+  belongs_to :item, :polymorphic => true, :without_deleted => true
+  belongs_to :any_item, :polymorphic => true, :foreign_key => 'item_id', :foreign_type => 'item_type'
+end
+
+class NonParanoidAndroid < ActiveRecord::Base
+end
+
+class ParanoidTest < ActiveSupport::TestCase
+  fixtures :widgets, :categories, :categories_widgets, :tags, :taggings, :orders
+  
+  def test_without_deleted_scope
+    assert_equal [1, 2], Widget.all.ids
+    assert_equal [1], Widget.without_deleted.all.ids
+  end
+  
+  def test_only_deleted_scope
+    assert_equal [2], Widget.only_deleted.all.ids
+    assert_equal [1, 2], Widget.all.ids
+  end
+  
+  def test_should_exists_with_deleted
+    assert Widget.exists?(2)
+    assert !Widget.without_deleted.exists?(2)
+  end
+
+  def test_should_exists_only_deleted
+    assert Widget.only_deleted.exists?(2)
+    assert !Widget.only_deleted.exists?(1)
+  end
+
+  def test_should_count_with_deleted
+    assert_equal 1, Widget.without_deleted.count
+    assert_equal 2, Widget.count
+    assert_equal 1, Widget.only_deleted.count
+    assert_equal 2, Widget.calculate(:count, :all)
+    assert_equal 1, Widget.without_deleted.calculate(:count, :all)
+  end
+
+  def test_should_set_deleted_at
+    assert_equal 1, Widget.without_deleted.count
+    assert_equal 1, Category.without_deleted.count
+    widgets(:widget_1).destroy
+    assert_equal 0, Widget.without_deleted.count
+    assert_equal 0, Category.without_deleted.count
+    assert_equal 2, Widget.count
+    assert_equal 4, Category.count
+  end
+  
+  def test_should_destroy
+    assert_equal 1, Widget.without_deleted.count
+    assert_equal 1, Category.without_deleted.count
+    widgets(:widget_1).destroy!
+    assert_equal 0, Widget.without_deleted.count
+    assert_equal 0, Category.without_deleted.count
+    assert_equal 1, Widget.only_deleted.count
+    assert_equal 1, Widget.count
+    # Category doesn't get destroyed because the dependent before_destroy callback uses #destroy
+    assert_equal 4, Category.count
+  end
+  
+  def test_should_set_deleted_at_when_delete_all
+    assert_equal 1, Widget.without_deleted.count
+    assert_equal 2, Widget.count
+    assert_equal 1, Category.without_deleted.count
+    Widget.delete_all
+    assert_equal 0, Widget.without_deleted.count
+    # delete_all doesn't call #destroy, so the dependent callback never fires
+    assert_equal 1, Category.without_deleted.count
+    assert_equal 2, Widget.count
+  end
+  
+  def test_should_set_deleted_at_when_delete_all_with_conditions
+    assert_equal 1, Widget.without_deleted.count
+    assert_equal 2, Widget.count
+    Widget.delete_all("id < 3")
+    assert_equal 0, Widget.without_deleted.count
+    assert_equal 2, Widget.count
+  end
+  
+  def test_should_delete_all
+    assert_equal 1, Category.without_deleted.count
+    assert_equal 4, Category.count
+    Category.delete_all!
+    assert_equal 0, Category.without_deleted.count
+    assert_equal 0, Category.count
+  end
+  
+  def test_should_delete_all_with_conditions
+    assert_equal 1, Category.without_deleted.count
+    assert_equal 4, Category.count
+    Category.delete_all!("id < 3")
+    assert_equal 0, Category.without_deleted.count
+    assert_equal 2, Category.count
+  end
+  
+  def test_should_not_count_deleted
+    assert_equal 1, Widget.without_deleted.count
+    assert_equal 1, Widget.without_deleted.count(:all, :conditions => ['title=?', 'widget 1'])
+    assert_equal 2, Widget.count
+    assert_equal 1, Widget.only_deleted.count
+  end
+  
+  def test_should_find_deleted_has_many_associations
+    assert_equal 2, widgets(:widget_1).categories.size
+    assert_equal [categories(:category_1), categories(:category_2)], widgets(:widget_1).categories
+  end
+  
+  def test_should_not_find_deleted_has_many_associations
+    assert_equal 1, widgets(:widget_1).categories.without_deleted.size
+    assert_equal [categories(:category_1)], widgets(:widget_1).categories.without_deleted
+  end
+  
+  def test_should_find_deleted_habtm_associations
+    assert_equal 2, widgets(:widget_1).habtm_categories.size
+    assert_equal [categories(:category_1), categories(:category_2)], widgets(:widget_1).habtm_categories
+  end
+  
+  def test_should_not_find_deleted_habtm_associations
+    assert_equal 1, widgets(:widget_1).habtm_categories.without_deleted.size
+    assert_equal [categories(:category_1)], widgets(:widget_1).habtm_categories.without_deleted
+  end
+  
+  def test_should_not_find_deleted_has_many_through_associations_without_deleted
+    assert_equal 1, widgets(:widget_1).tags.size
+    assert_equal [tags(:tag_2)], widgets(:widget_1).tags
+  end
+  
+  def test_should_find_has_many_through_associations
+    assert_equal 2, widgets(:widget_1).any_tags.size
+    assert_equal Tag.find(:all), widgets(:widget_1).any_tags
+  end
+
+  def test_should_not_find_deleted_belongs_to_associations_without_deleted
+    assert_nil Category.find(3).widget
+  end
+
+  def test_should_find_belongs_to_assocation
+    assert_equal Widget.find(2), Category.find(3).any_widget
+  end
+
+  def test_should_not_find_deleted_belongs_to_associations_polymorphic_without_deleted
+    assert_nil orders(:order_1).item
+    assert_equal categories(:category_1), orders(:order_2).item
+  end
+
+  def test_should_find_deleted_belongs_to_associations_polymorphic
+    assert_equal widgets(:widget_2), orders(:order_1).any_item
+  end
+
+  def test_should_find_first_with_deleted
+    assert_equal widgets(:widget_1), Widget.without_deleted.first
+    assert_equal 2, Widget.first(:order => 'id desc').id
+  end
+  
+  def test_should_find_single_id
+    assert Widget.without_deleted.find(1)
+    assert Widget.find(2)
+    assert_raises(ActiveRecord::RecordNotFound) { Widget.without_deleted.find(2) }
+  end
+  
+  def test_should_find_multiple_ids
+    assert_equal [1,2], Widget.find(1,2).sort_by { |w| w.id }.ids
+    assert_equal [1,2], Widget.find([1,2]).sort_by { |w| w.id }.ids
+    assert_raises(ActiveRecord::RecordNotFound) { Widget.without_deleted.find(1,2) }
+  end
+  
+  def test_should_ignore_multiple_includes
+    Widget.class_eval { paranoid_fu }
+    assert Widget.find(1)
+  end
+
+  def test_should_not_override_scopes_when_counting
+    assert_equal 1, Widget.send(:with_scope, :find => { :conditions => "title = 'widget 1'" }) { Widget.without_deleted.count }
+    assert_equal 0, Widget.send(:with_scope, :find => { :conditions => "title = 'deleted widget 2'" }) { Widget.without_deleted.count }
+    assert_equal 1, Widget.send(:with_scope, :find => { :conditions => "title = 'deleted widget 2'" }) { Widget.count }
+  end
+
+  def test_should_not_override_scopes_when_finding
+    assert_equal [1], Widget.send(:with_scope, :find => { :conditions => "title = 'widget 1'" }) { Widget.without_deleted.find(:all) }.ids
+    assert_equal [],  Widget.send(:with_scope, :find => { :conditions => "title = 'deleted widget 2'" }) { Widget.without_deleted.find(:all) }.ids
+    assert_equal [2], Widget.send(:with_scope, :find => { :conditions => "title = 'deleted widget 2'" }) { Widget.find(:all) }.ids
+  end
+
+  def test_should_allow_multiple_scoped_calls_when_finding
+    Widget.send(:with_scope, :find => { :conditions => "title = 'deleted widget 2'" }) do
+      assert_equal [2], Widget.find(:all).ids
+      assert_equal [2], Widget.find(:all).ids, "clobbers the constrain on the unmodified find"
+      assert_equal [], Widget.without_deleted.find(:all).ids
+      assert_equal [], Widget.without_deleted.find(:all).ids, 'clobbers the constrain on a paranoid find'
+    end
+  end
+
+  def test_should_allow_multiple_scoped_calls_when_counting
+    Widget.send(:with_scope, :find => { :conditions => "title = 'deleted widget 2'" }) do
+      assert_equal 1, Widget.calculate(:count, :all)
+      assert_equal 1, Widget.calculate(:count, :all), "clobbers the constrain on the unmodified find"
+      assert_equal 0, Widget.without_deleted.count
+      assert_equal 0, Widget.without_deleted.count, 'clobbers the constrain on a paranoid find'
+    end
+  end
+
+  def test_should_give_paranoid_status
+    assert Widget.paranoid?
+    assert !NonParanoidAndroid.paranoid?
+  end
+
+  def test_should_give_record_status
+    assert_equal false, Widget.find(1).deleted? 
+    Widget.find(1).destroy
+    assert Widget.find(1).deleted?
+  end
+
+  def test_should_find_deleted_has_many_assocations_on_deleted_records_by_default
+    w = Widget.find 2
+    assert_equal 2, w.categories.find(:all).length
+    assert_equal 2, w.categories.find(:all).size
+  end
+  
+  def test_should_find_deleted_habtm_assocations_on_deleted_records_by_default
+    w = Widget.find 2
+    assert_equal 2, w.habtm_categories.find(:all).length
+    assert_equal 2, w.habtm_categories.find(:all).size
+  end
+
+  def test_dynamic_finders
+    assert     Widget.without_deleted.find_by_id(1)
+    assert_nil Widget.without_deleted.find_by_id(2)
+  end
+
+  def test_custom_finder_methods
+    w = Widget.all.inject({}) { |all, w| all.merge(w.id => w) }
+    assert_equal [1],       Category.search('c').ids
+    assert_equal [1,2,3,4], Category.search_with_deleted('c', :order => 'id').ids
+    assert_equal [1],       widgets(:widget_1).categories.search('c').collect(&:id)
+    assert_equal [1,2],     widgets(:widget_1).categories.search_with_deleted('c').ids
+    assert_equal [],        w[2].categories.search('c').ids
+    assert_equal [3,4],     w[2].categories.search_with_deleted('c').ids
+  end
+  
+  def test_should_recover_record
+    Widget.find(1).destroy
+    assert_equal true, Widget.find(1).deleted?
+    
+    Widget.find(1).recover!
+    assert_equal false, Widget.find(1).deleted?
+  end
+  
+  def test_should_recover_record_and_has_many_associations
+    Widget.find(1).destroy
+    assert_equal true, Widget.find(1).deleted?
+    assert_equal true, Category.find(1).deleted?
+    
+    Widget.find(1).recover_with_associations!(:categories)
+    assert_equal false, Widget.find(1).deleted?
+    assert_equal false, Category.find(1).deleted?
+  end
+  
+  def test_find_including_associations
+    w = Widget.find(1, :include => :categories)
+    assert_equal widgets(:widget_1), w
+    assert_equal 2, w.instance_variable_get(:@categories).size
+
+    c = Category.find(:first, :include => :widget, :conditions => {'widgets.title' => 'widget 1'})
+    assert_equal categories(:category_1), c
+    assert_equal widgets(:widget_1), c.instance_variable_get(:@widget)
+    c = Category.find(3, :include => :widget)
+    assert_equal categories(:category_3), c
+    assert_nil c.instance_variable_get(:@widget)
+    assert_raises(ActiveRecord::RecordNotFound) { Category.find(3, :include => :widget, :conditions => {'widgets.title' => 'deleted widget 2'}) }
+
+    o = Order.find(:first, :include => :item)
+    assert_equal orders(:order_1), o
+    assert_nil o.instance_variable_get(:@item)
+    o = Order.find(:first, :include => :any_item)
+    assert_equal orders(:order_1), o
+    assert_equal widgets(:widget_2), o.instance_variable_get(:@any_item)
+  end
+end
+
+class Array
+  def ids
+    collect &:id
+  end
+end

data/test/schema.rb

@@ -0,0 +1,35 @@
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table :widgets, :force => true do |t|
+    t.column :title, :string, :limit => 50
+    t.column :category_id, :integer
+    t.column :deleted_at, :timestamp
+  end
+
+  create_table :categories, :force => true do |t|
+    t.column :widget_id, :integer
+    t.column :title, :string, :limit => 50
+    t.column :deleted_at, :timestamp
+  end
+
+  create_table :categories_widgets, :force => true, :id => false do |t|
+    t.column :category_id, :integer
+    t.column :widget_id, :integer
+  end
+  
+  create_table :tags, :force => true do |t|
+    t.column :name, :string, :limit => 50
+  end
+  
+  create_table :taggings, :force => true do |t|
+    t.column :tag_id, :integer
+    t.column :widget_id, :integer
+    t.column :deleted_at, :timestamp
+  end
+  
+  create_table :orders, :force => true do |t|
+    t.column :item_id, :integer
+    t.column :item_type, :string
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,47 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'rubygems'
+if ENV['RAILS'].nil?
+  require File.expand_path(File.join(File.dirname(__FILE__), '../../../../config/environment.rb'))
+else
+  # specific rails version targeted
+  # load activerecord and plugin manually
+  gem 'activerecord', "=#{ENV['RAILS']}"
+  require 'active_record'
+  $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+  Dir["#{$LOAD_PATH.last}/**/*.rb"].each do |path| 
+    require path[$LOAD_PATH.last.size + 1..-1]
+  end
+  require File.join(File.dirname(__FILE__), '..', 'init.rb')
+end
+require 'active_record/fixtures'
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+# do this so fixtures will load
+ActiveRecord::Base.configurations.update config 
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite3'])
+
+load(File.dirname(__FILE__) + "/schema.rb")
+
+class ActiveSupport::TestCase #:nodoc:
+  include ActiveRecord::TestFixtures
+  self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+  
+  def create_fixtures(*table_names)
+    if block_given?
+      Fixtures.create_fixtures(self.class.fixture_path, table_names) { yield }
+    else
+      Fixtures.create_fixtures(self.class.fixture_path, table_names)
+    end
+  end
+
+  # Turn off transactional fixtures if you're working with MyISAM tables in MySQL
+  self.use_transactional_fixtures = true
+  
+  # Instantiated fixtures are slow, but give you @david where you otherwise would need people(:david)
+  self.use_instantiated_fixtures  = false
+
+  # Add more helper methods to be used by all tests here...
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: paranoid_fu
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+platform: ruby
+authors: 
+- Sergio Cambra
+autorequire: paranoid_fu
+bindir: bin
+cert_chain: []
+
+date: 2009-11-05 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: sergio@entrecables.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/paranoid_fu/association_preload.rb
+- lib/paranoid_fu/associations.rb
+- lib/paranoid_fu/belongs_to_polymorphic_association.rb
+- lib/paranoid_fu/paranoid.rb
+- lib/paranoid_fu/reflection_conditions.rb
+- lib/paranoid_fu.rb
+- test/database.yml
+- test/fixtures/categories.yml
+- test/fixtures/categories_widgets.yml
+- test/fixtures/taggings.yml
+- test/fixtures/tags.yml
+- test/fixtures/widgets.yml
+- test/fixtures/orders.yml
+- test/paranoid_test.rb
+- test/schema.rb
+- test/test_helper.rb
+- README
+- MIT-LICENSE
+- CHANGELOG
+- RUNNING_UNIT_TESTS
+has_rdoc: true
+homepage: http://github.com/scambra/paranoid_fu
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: paranoid_fu keeps models from actually being deleted by setting a deleted_at field. It adds without_deleted and only_deleted named_scopes
+test_files: 
+- test/paranoid_test.rb