paranoid 0.0.1

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,99 @@
+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.count_with_destroyed # => 1
+
+# where is that large automobile?
+that_large_automobile = Automobile.find_with_destroyed(:all).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.count_with_destroyed # => 1
+
+Automobile.delete_all
+Automobile.count_with_destroyed # => 0
+# And you may say to yourself, "My god!  What have I done?"
+</pre>
+
+Any find/count/sum/etc. _with_destroyed calls should work and you can also do find/count/sum/etc._destroyed_only.
+
+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,25 @@
+require "spec"
+require "spec/rake/spectask"
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = %q{paranoid}
+    s.summary = %q{Enable soft delete of ActiveRecord records. Based off defunct ActsAsParanoid and IsParanoid}
+    s.email = %q{github@xspond.com}
+    s.homepage = %q{http://github.com/xspond/paranoid/}
+    s.description = ""
+    s.authors = ["David Genord II"]
+    s.add_dependency('activerecord', '~> 3.0.0.beta')
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end
+
+task :default  => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 0
+:patch: 1

data/init.rb

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

data/lib/paranoid.rb

@@ -0,0 +1,3 @@
+require 'active_record'
+require 'paranoid/base'
+require 'paranoid/relation'

data/lib/paranoid/base.rb

@@ -0,0 +1,90 @@
+module Paranoid
+  module Base
+    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
+      self.destroyed_field, self.field_destroyed, self.field_not_destroyed = opts[:field]
+
+      extend ClassMethods
+      include InstanceMethods
+
+      class_eval do
+        class << self
+          delegate :with_destroyed, :to => :scoped
+        end
+      end
+    end
+
+    def paranoid?
+      @paranoid = false unless defined?(@paranoid)
+      @paranoid
+    end
+
+    module ClassMethods
+      def paranoid_condition
+        {destroyed_field => field_not_destroyed}
+      end
+
+      def paranoid_only_condition
+        ["#{table_name}.#{destroyed_field} IS NOT ?", field_not_destroyed]
+      end
+
+      def disable_paranoid
+        if block_given?
+          @paranoid = false
+          yield
+        end
+      ensure
+        @paranoid = true
+      end
+    end
+
+    module InstanceMethods
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method_chain :create_or_update, :paranoid
+      end
+
+      def restore
+        set_destroyed(field_not_destroyed.respond_to?(:call) ? field_not_destroyed.call : field_not_destroyed)
+        @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
+
+      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 = 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
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval { extend Paranoid::Base }

data/lib/paranoid/relation.rb

@@ -0,0 +1,49 @@
+module Paranoid
+  module Relation
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method_chain :arel, :paranoid
+      alias_method_chain :delete_all, :paranoid
+    end
+
+    def add_paranoid_condition?
+      @add_paranoid = true unless defined?(@add_paranoid)
+      @klass.paranoid? && @add_paranoid
+    end
+
+    def arel_with_paranoid
+      if add_paranoid_condition?
+        @arel ||= without_destroyed.arel_without_paranoid
+      else
+        arel_without_paranoid
+      end
+    end
+
+    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
+
+    def skip_paranoid_condition
+      @add_paranoid = false
+    end
+
+    def with_destroyed
+      spawn.tap {|relation| relation.skip_paranoid_condition }
+    end
+
+    def with_destroyed_only
+      where(@klass.paranoid_only_condition).tap {|relation| relation.skip_paranoid_condition }
+    end
+
+    def without_destroyed
+      where(@klass.paranoid_condition).tap {|relation| relation.skip_paranoid_condition }
+    end
+  end
+end
+
+ActiveRecord::Relation.class_eval { include Paranoid::Relation }

data/paranoid.gemspec

@@ -0,0 +1,60 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{paranoid}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["David Genord II"]
+  s.date = %q{2010-02-18}
+  s.description = %q{}
+  s.email = %q{github@xspond.com}
+  s.extra_rdoc_files = [
+    "README.textile"
+  ]
+  s.files = [
+    "MIT-LICENSE",
+     "README.textile",
+     "Rakefile",
+     "VERSION.yml",
+     "init.rb",
+     "lib/paranoid.rb",
+     "lib/paranoid/base.rb",
+     "lib/paranoid/relation.rb",
+     "paranoid.gemspec",
+     "spec/database.yml",
+     "spec/models.rb",
+     "spec/paranoid_spec.rb",
+     "spec/schema.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/xspond/paranoid/}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Enable soft delete of ActiveRecord records. Based off defunct ActsAsParanoid and IsParanoid}
+  s.test_files = [
+    "spec/models.rb",
+     "spec/paranoid_spec.rb",
+     "spec/schema.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, ["~> 3.0.0.beta"])
+    else
+      s.add_dependency(%q<activerecord>, ["~> 3.0.0.beta"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, ["~> 3.0.0.beta"])
+  end
+end
+

data/spec/database.yml

@@ -0,0 +1,3 @@
+test:
+  :adapter: sqlite3
+  :database: paranoid.db

data/spec/models.rb

@@ -0,0 +1,135 @@
+class Person < ActiveRecord::Base #:nodoc:
+  validates_uniqueness_of :name
+  has_many :androids, :foreign_key => :owner_id, :dependent => :destroy
+end
+
+class Android < ActiveRecord::Base #:nodoc:
+  paranoid
+  validates_uniqueness_of :name
+  has_many :components, :dependent => :destroy
+  has_one :sticker
+  has_many :memories, :foreign_key => 'parent_id'
+  has_many :dents
+  has_many :dings, :through => :dents
+  has_many :scratches, :through => :dents
+  has_and_belongs_to_many :places
+
+  # this code is to ensure that our destroy and restore methods
+  # work without triggering before/after_update callbacks
+  before_update :raise_hell
+  def raise_hell
+    raise "hell"
+  end
+end
+
+class Dent < ActiveRecord::Base #:nodoc:
+  paranoid
+  belongs_to :android
+  has_many :dings
+  has_many :scratches
+end
+
+class Ding < ActiveRecord::Base #:nodoc:
+  paranoid :field => [:not_deleted, true, false]
+  belongs_to :dent
+end
+
+class Scratch < ActiveRecord::Base #:nodoc:
+  paranoid
+  belongs_to :dent
+end
+
+class Component < ActiveRecord::Base #:nodoc:
+  paranoid
+  belongs_to :android, :dependent => :destroy
+  has_many :sub_components, :dependent => :destroy
+  NEW_NAME = 'Something Else!'
+
+  after_destroy :change_name
+  def change_name
+    self.update_attribute(:name, NEW_NAME)
+  end
+end
+
+class SubComponent < ActiveRecord::Base #:nodoc:
+  paranoid
+  belongs_to :component, :dependent => :destroy
+end
+
+class Memory < ActiveRecord::Base #:nodoc:
+  paranoid
+  belongs_to :android, :class_name => "Android", :foreign_key => "parent_id"
+end
+
+class Sticker < ActiveRecord::Base #:nodoc:
+  MM_NAME = "You've got method_missing"
+
+  # this simply serves to ensure that we don't break method_missing
+  # if it is implemented on a class and called before is_paranoid
+  def method_missing name, *args, &block
+    self.name = MM_NAME
+  end
+
+  paranoid
+  belongs_to :android
+end
+
+class AndroidWithScopedUniqueness < ActiveRecord::Base #:nodoc:
+  set_table_name :androids
+  validates_uniqueness_of :name, :scope => :deleted_at
+  paranoid
+end
+
+class Place < ActiveRecord::Base #:nodoc:
+  paranoid
+  has_and_belongs_to_many :androids
+end
+
+class AndroidsPlaces < ActiveRecord::Base #:nodoc:
+end
+
+class Ninja < ActiveRecord::Base #:nodoc:
+  validates_uniqueness_of :name, :scope => :visible
+  paranoid :field => [:visible, false, true]
+  
+  alias_method :vanish, :destroy
+end
+
+class Pirate < ActiveRecord::Base #:nodoc:
+  paranoid :field => [:alive, false, true]
+end
+
+class DeadPirate < ActiveRecord::Base #:nodoc:
+  set_table_name :pirates
+  paranoid :field => [:alive, true, false]
+end
+
+class RandomPirate < ActiveRecord::Base #:nodoc:
+  set_table_name :pirates
+
+  after_destroy :raise_an_error
+  def raise_an_error
+    raise 'after_destroy works'
+  end
+end
+
+class UndestroyablePirate < ActiveRecord::Base #:nodoc:
+  set_table_name :pirates
+  paranoid :field => [:alive, false, true]
+
+  before_destroy :ret_false
+  def ret_false
+    false
+  end
+end
+
+class Uuid < ActiveRecord::Base #:nodoc:
+  set_primary_key "uuid"
+
+  before_create :set_uuid
+  def set_uuid
+    self.uuid = "295b3430-85b8-012c-cfe4-002332cf7d5e"
+  end
+
+  paranoid
+end

data/spec/paranoid_spec.rb

@@ -0,0 +1,99 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/models')
+
+LUKE = 'Luke Skywalker'
+
+describe Paranoid do
+  before(:each) do
+    Sticker.delete_all
+    Place.delete_all
+    Android.delete_all
+    Person.delete_all
+    Component.delete_all
+
+    @luke = Person.create(:name => LUKE)
+    @r2d2 = Android.create(:name => 'R2D2', :owner_id => @luke.id)
+    @c3p0 = Android.create(:name => 'C3P0', :owner_id => @luke.id)
+
+    @r2d2.components.create(:name => 'Rotors')
+
+    @r2d2.memories.create(:name => 'A pretty sunset')
+    @c3p0.sticker = Sticker.create(:name => 'OMG, PONIES!')
+    @tatooine = Place.create(:name => "Tatooine")
+    @r2d2.places << @tatooine
+  end
+
+  it 'should recognize a class as paranoid' do
+    Person.paranoid?.should be_false
+    Place.paranoid?.should be_true
+  end
+
+  it 'should hide destroyed records' do
+    @tatooine.update_attribute('deleted_at', Time.now)
+    Place.first(:conditions => {:name => 'Tatooine'}).should be_nil
+  end
+
+  it 'should reveal destroyed records when with_destroyed' do
+    @tatooine.update_attribute('deleted_at', Time.now)
+    Place.with_destroyed.first(:conditions => {:name => 'Tatooine'}).should_not be_nil
+  end
+
+  it 'should restore the destroyed record' do
+    @tatooine.update_attribute('deleted_at', Time.now)
+
+    @tatooine = Place.with_destroyed.first(:conditions => {:name => 'Tatooine'})
+    @tatooine.restore
+
+    Place.first(:conditions => {:name => 'Tatooine'}).should_not be_nil
+  end
+
+  it 'should soft delete paranoid records' do
+    @tatooine.destroy
+
+    record = Place.with_destroyed.first(:conditions => {:name => 'Tatooine'})
+    record.should_not be_nil
+    record.deleted_at.should_not be_nil
+  end
+
+  it 'should mark the record destroyed' do
+    @tatooine.destroy
+    @tatooine.destroyed?.should be_true
+  end
+
+  it 'should set the deleted_field' do
+    @tatooine.destroy
+    @tatooine.deleted_at.should_not be_nil
+  end
+
+  describe 'for alternate field information' do
+    before(:each) do
+      Ninja.delete_all
+      @ninja = Ninja.create(:name => 'Steve')
+    end
+
+    it 'should vanish the ninja' do
+      @ninja.destroy
+
+      record = Ninja.first(:conditions => {:name => 'Steve'})
+      record.should be_nil
+    end
+
+    it 'should not delete the ninja' do
+      @ninja.destroy
+
+      record = Ninja.with_destroyed.first(:conditions => {:name => 'Steve'})
+      record.should_not be_nil
+      record.visible.should be_false
+    end
+
+    it 'should mark the ninja vanished' do
+      @ninja.destroy
+      @ninja.destroyed?.should be_true
+    end
+
+    it 'should set visible to false' do
+      @ninja.destroy
+      @ninja.visible.should be_false
+    end
+  end
+end

data/spec/schema.rb

@@ -0,0 +1,86 @@
+ActiveRecord::Schema.define do
+  create_table "androids", :force => true do |t|
+    t.string   "name"
+    t.integer  "owner_id"
+    t.datetime "deleted_at"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "dents", :force => true do |t|
+    t.integer  "android_id"
+    t.string   "description"
+    t.datetime "deleted_at"
+  end
+
+  create_table "dings", :force => true do |t|
+    t.integer  "dent_id"
+    t.string   "description"
+    t.boolean  "not_deleted"
+  end
+
+  create_table "scratches", :force => true do |t|
+    t.integer  "dent_id"
+    t.string   "description"
+    t.datetime "deleted_at"
+  end
+
+  create_table "androids_places", :force => true, :id => false do |t|
+    t.integer  "android_id"
+    t.integer  "place_id"
+  end
+
+  create_table "places", :force => true do |t|
+    t.string   "name"
+    t.datetime "deleted_at"
+  end
+
+  create_table "people", :force => true do |t|
+    t.string   "name"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "components", :force => true do |t|
+    t.string   "name"
+    t.integer  "android_id"
+    t.datetime "deleted_at"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "sub_components", :force => true do |t|
+    t.string "name"
+    t.integer "component_id"
+    t.datetime "deleted_at"
+  end
+
+  create_table "memories", :force => true do |t|
+    t.string   "name"
+    t.integer  "parent_id"
+    t.datetime "deleted_at"
+  end
+
+  create_table "stickers", :force => true do |t|
+    t.string   "name"
+    t.integer  "android_id"
+    t.datetime "deleted_at"
+  end
+
+  create_table "ninjas", :force => true do |t|
+    t.string   "name"
+    t.boolean  "visible", :default => false
+  end
+
+  create_table "pirates", :force => true do |t|
+    t.string   "name"
+    t.boolean  "alive", :default => true
+  end
+
+  create_table "uuids", :id => false, :force => true  do |t|
+    t.string   "uuid",     :limit => 36,  :primary => true
+    t.string   "name"
+    t.datetime "deleted_at"
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'active_record'
+require 'paranoid'
+require 'yaml'
+require 'spec'
+
+def connect(environment)
+  conf = YAML::load(File.open(File.dirname(__FILE__) + '/database.yml'))
+  ActiveRecord::Base.establish_connection(conf[environment])
+end
+
+# Open ActiveRecord connection
+connect('test')
+
+original_stdout = $stdout
+$stdout = StringIO.new
+
+begin
+  load(File.dirname(__FILE__) + "/schema.rb")
+ensure
+  $stdout = original_stdout
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: paranoid
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- David Genord II
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-18 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.0.beta
+    version: 
+description: ""
+email: github@xspond.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- MIT-LICENSE
+- README.textile
+- Rakefile
+- VERSION.yml
+- init.rb
+- lib/paranoid.rb
+- lib/paranoid/base.rb
+- lib/paranoid/relation.rb
+- paranoid.gemspec
+- spec/database.yml
+- spec/models.rb
+- spec/paranoid_spec.rb
+- spec/schema.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/xspond/paranoid/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: Enable soft delete of ActiveRecord records. Based off defunct ActsAsParanoid and IsParanoid
+test_files: 
+- spec/models.rb
+- spec/paranoid_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb