mislav-is_paranoid 0.0.2

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Jeffrey Chupp
+
+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.markdown

@@ -0,0 +1,64 @@
+Are you paranoid?
+=================
+
+Destroying records is a one-way ticket--you are permanently sending data
+down the drain. *Unless*, of course, you are using this plugin.
+
+Simply declare models paranoid:
+
+    class User < ActiveRecord::Base
+      is_paranoid
+    end
+
+You will need to add the "deleted_at" datetime column on each model table
+you declare paranoid. This is how the plugin tracks destroyed state.
+
+
+Destroying
+----------
+
+Calling `destroy` should work as you expect, only it doesn't actually delete the record:
+
+    User.count  #=> 1
+    
+    User.first.destroy
+    
+    User.count  #=> 0
+    
+    # user is still there, only hidden:
+    User.count_with_destroyed  #=> 1
+
+What `destroy` does is that it sets the "deleted\_at" column to the current time.
+Records that have a value for "deleted\_at" are considered deleted and are filtered
+out from all requests using `default_scope` ActiveRecord feature:
+
+    default_scope :conditions => {:deleted_at => nil}
+
+Restoring
+---------
+
+No sense in keeping the data if we can't restore it, right?
+
+    user = User.find_with_destroyed(:first)
+    
+    user.restore
+    
+    User.count  #=> 1
+
+Restoring resets the "deleted_at" value back to `nil`.
+
+Extra methods
+-------------
+
+Extra class methods provided by this plugin are:
+
+1. `Model.count_with_destroyed(*args)`
+2. `Model.find_with_destroyed(*args)`
+2. `Model.find_only_destroyed(*args)`
+
+
+Pitfalls
+--------
+
+* `validates_uniqueness_of` does not ignore items marked with a "deleted_at" flag
+* various eager-loading and associations-related issues (see ["Killing is_paranoid"](http://blog.semanticart.com/killing_is_paranoid/))

data/Rakefile

@@ -0,0 +1,12 @@
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new do |t|
+  t.ruby_opts = ['-rubygems']
+  t.libs = ['lib', 'spec']
+  t.spec_opts = ['--color']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+task :gem do
+  system %(rm -f *.gem; gem build is_paranoid.gemspec)
+end

data/init.rb

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

data/lib/is_paranoid.rb

@@ -0,0 +1,136 @@
+require 'active_record'
+
+module IsParanoid
+  def self.included(base) # :nodoc:
+    base.extend SafetyNet
+  end
+
+  module SafetyNet
+    # Call this in your model to enable all the safety-net goodness
+    #
+    #  Example:
+    #
+    #  class Android < ActiveRecord::Base
+    #    is_paranoid
+    #  end
+    def is_paranoid
+      class_eval do
+        # This is the real magic.  All calls made to this model will
+        # append the conditions deleted_at => nil.  Exceptions require
+        # using with_destroyed_scope (see self.delete_all,
+        # self.count_with_destroyed, and self.find_with_destroyed )
+        default_scope :conditions => {:deleted_at => nil}
+
+        # Actually delete the model, bypassing the safety net.  Because
+        # this method is called internally by Model.delete(id) and on the
+        # delete method in each instance, we don't need to specify those
+        # methods separately
+        def self.delete_all conditions = nil
+          self.with_destroyed_scope { super conditions }
+        end
+
+        # Return a count that includes the soft-deleted models.
+        def self.count_with_destroyed *args
+          self.with_destroyed_scope { count(*args) }
+        end
+
+        # Perform a count only on destroyed instances.
+        def self.count_only_destroyed *args
+          self.with_only_destroyed_scope { count(*args) }
+        end
+
+        # Return instances of all models matching the query regardless
+        # of whether or not they have been soft-deleted.
+        def self.find_with_destroyed *args
+          self.with_destroyed_scope { find(*args) }
+        end
+        
+        # Perform a find only on destroyed instances.
+        def self.find_only_destroyed *args
+          self.with_only_destroyed_scope { find(*args) }
+        end
+
+        # Returns true if the requested record exists, even if it has
+        # been soft-deleted.
+        def self.exists_with_destroyed? *args
+          self.with_destroyed_scope { exists?(*args) }
+        end
+
+        # Returns true if the requested record has been soft-deleted.
+        def self.exists_only_destroyed? *args
+          self.with_only_destroyed_scope { exists?(*args) }
+        end
+
+        # Override the default destroy to allow us to flag deleted_at.
+        # 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
+          return false if callback(:before_destroy) == false
+          result = destroy_without_callbacks
+          callback(:after_destroy)
+          result
+        end
+
+        # Set deleted_at flag on a model to nil, effectively undoing the
+        # soft-deletion.
+        def restore
+          self.deleted_at_will_change!
+          self.deleted_at = nil
+          update_without_callbacks
+        end
+
+        # Has this model been soft-deleted?
+        def destroyed?
+          super || !deleted_at.nil?
+        end
+        
+        protected
+
+        # Mark the model deleted_at as now.
+        def destroy_without_callbacks
+          self.deleted_at = current_time_from_proper_timezone
+          update_without_callbacks
+        end
+        
+        def self.with_only_destroyed_scope(&block)
+          with_destroyed_scope do
+            table = connection.quote_table_name(table_name)
+            attr = connection.quote_column_name(:deleted_at)
+            with_scope(:find => { :conditions => "#{table}.#{attr} IS NOT NULL" }, &block)
+          end
+        end
+
+        def self.with_destroyed_scope
+          find = current_scoped_methods[:find]
+
+          if find[:conditions]
+            original = find[:conditions].dup
+
+            begin
+              case find[:conditions]
+              when Hash:
+                if find[:conditions][:deleted_at].nil?
+                  find[:conditions].delete(:deleted_at)
+                end
+              when String:
+                conditions = sanitize_conditions(:deleted_at => nil)
+                find[:conditions].gsub!(conditions, '1=1')
+              end
+              
+              result = yield
+            ensure
+              find[:conditions] = original
+              return result if result
+            end
+          else
+            yield
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, IsParanoid)

data/spec/is_paranoid_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+class Person < ActiveRecord::Base
+  has_many :androids, :foreign_key => :owner_id, :dependent => :destroy
+end
+
+class Android < ActiveRecord::Base
+  validates_uniqueness_of :name
+  is_paranoid
+  named_scope :ordered, :order => 'name DESC'
+  named_scope :r2d2, :conditions => { :name => 'R2D2' }
+  named_scope :c3p0, :conditions => { :name => 'C3P0' }
+end
+
+describe Android do
+  before(:each) do
+    Android.connection.execute 'DELETE FROM androids'
+    Person.connection.execute 'DELETE FROM people'
+
+    @luke = Person.create(:name => 'Luke Skywalker')
+    @r2d2 = Android.create(:name => 'R2D2', :owner_id => @luke.id)
+    @c3p0 = Android.create(:name => 'C3P0', :owner_id => @luke.id)
+  end
+
+  it "should delete normally" do
+    Android.count_with_destroyed.should == 2
+    Android.delete_all
+    Android.count_with_destroyed.should == 0
+  end
+
+  it "should handle Model.destroy_all properly" do
+    lambda{
+      Android.destroy_all("owner_id = #{@luke.id}")
+    }.should change(Android, :count).from(2).to(0)
+    Android.count_with_destroyed.should == 2
+  end
+
+  it "should handle Model.destroy(id) properly" do
+    lambda{
+      Android.destroy(@r2d2.id)
+    }.should change(Android, :count).by(-1)
+
+    Android.count_with_destroyed.should == 2
+  end
+
+  it "should be not show up in the relationship to the owner once deleted" do
+    @luke.androids.size.should == 2
+    @r2d2.destroy
+    @luke.androids.size.should == 1
+    Android.count.should == 1
+    Android.first(:conditions => {:name => 'R2D2'}).should be_blank
+  end
+
+  it "should be able to find deleted items via find_with_destroyed" do
+    @r2d2.destroy
+    Android.find(:first, :conditions => {:name => 'R2D2'}).should be_blank
+    Android.find_with_destroyed(:first, :conditions => {:name => 'R2D2'}).should_not be_blank
+  end
+
+  it "should have a proper count inclusively and exclusively of deleted items" do
+    @r2d2.destroy
+    @c3p0.destroy
+    Android.count.should == 0
+    Android.count_with_destroyed.should == 2
+  end
+
+  it "should mark deleted on dependent destroys" do
+    lambda{
+      @luke.destroy
+    }.should change(Android, :count).by(-2)
+    Android.count_with_destroyed.should == 2
+  end
+
+  it "should allow restoring" do
+    @r2d2.destroy
+    lambda{
+      @r2d2.restore
+    }.should change(Android, :count).by(1)
+  end
+
+  # Note:  this isn't necessarily ideal, this just serves to demostrate
+  # how it currently works
+  it "should not ignore deleted items in validation checks" do
+    @r2d2.destroy
+    lambda{
+      Android.create!(:name => 'R2D2')
+    }.should raise_error(ActiveRecord::RecordInvalid)
+  end
+  
+  it "should find only destroyed videos" do
+    @r2d2.destroy
+    Android.find_only_destroyed(:all).should == [@r2d2]
+  end
+
+  it "should honor named scopes" do
+    @r2d2.destroy
+    @c3p0.destroy
+    Android.r2d2.find_only_destroyed(:all).should == [@r2d2]
+    Android.c3p0.ordered.find_only_destroyed(:all).should == [@c3p0]
+    Android.ordered.find_only_destroyed(:all).should == [@r2d2,@c3p0]
+    Android.r2d2.c3p0.find_only_destroyed(:all).should == []
+    Android.find_only_destroyed(:all).should == [@r2d2,@c3p0]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'yaml'
+require 'active_record'
+require 'is_paranoid'
+require 'stringio'
+
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+old_stdout = $stdout
+$stdout = StringIO.new
+
+begin
+  ActiveRecord::Schema.define do
+    create_table :androids do |t|
+      t.string   :name
+      t.integer  :owner_id
+      t.datetime :deleted_at
+      t.timestamps
+    end
+
+    create_table :people do |t|
+      t.string   :name
+      t.timestamps
+    end
+  end
+ensure
+  $stdout = old_stdout
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: mislav-is_paranoid
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Jeffrey Chupp
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-20 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: jeff@semanticart.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- init.rb
+- lib/is_paranoid.rb
+- README.markdown
+- Rakefile
+- MIT-LICENSE
+- spec/is_paranoid_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/jchupp/is_paranoid/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 2
+summary: ActiveRecord 2.3 compatible gem "allowing you to hide and restore records without actually deleting them."  Yes, like acts_as_paranoid, only with less code and less complexity.
+test_files: []
+