paranoia 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3024de08e3ab1e77b80e2f9ad7b975f0b642d204
-  data.tar.gz: 05e1fa475bbc9a4db39cec410375d7f33d8f09b4
+  metadata.gz: 0fe3ef85f4b72d9f860b21f59bcf8f0416b6462f
+  data.tar.gz: a60d2f35334726d1d2af0fc45c03fe0a8fbe8653
 SHA512:
-  metadata.gz: f03869fc8a9c06d6fe005db5deaea540240b05aa65b707698e4a47bcaabef77fc24541777c90e3401060340afa1fc26940ef49e2ac3d0df66b8f6d2d7bf56389
-  data.tar.gz: d60317d533c98f1ca9cf157467fb122a969dc530f022f59a1a98006f4a6b2adef0e741993dd65ab84fb61d3fd63abed36bacffddded47dcfdc6c8a1eb3b13e5c
+  metadata.gz: d9c966fc4c04b1ce8bc50bdaf988f7d16290cece9913dcd49cfe738d8751f692450f4daf57e7fe0289c6575dad031317756462326232efb5418a03d427560642
+  data.tar.gz: 76b091060495418ac3ccf2163a226b8ce43f6ec2e078e75a55e16c566bd968715a9a2694f3b4358e51e308a2be17f674ab9f50fc205c2e75e7e2d04b23ddef59

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - jruby-19mode
+  - rbx
+
+env:
+  - RAILS='~> 4.0.2'
+  - RAILS='~> 4.1.0.beta1'

data/Gemfile

@@ -1,4 +1,17 @@
-source :gemcutter
+source 'https://rubygems.org'
+
+gem 'sqlite3', :platforms => [:ruby]
+gem 'activerecord-jdbcsqlite3-adapter', :platforms => [:jruby]
+
+platforms :rbx do
+  gem 'rubysl', '~> 2.0'
+  gem 'rubysl-test-unit'
+  gem 'rubinius-developer_tools'
+end
+
+rails = ENV['RAILS'] || '~> 4.0.2'
+
+gem 'rails', rails
 
 # Specify your gem's dependencies in paranoia.gemspec
 gemspec

data/README.md

@@ -4,7 +4,7 @@ Paranoia is a re-implementation of [acts\_as\_paranoid](http://github.com/techno
 
 You would use either plugin / gem if you wished that when you called `destroy` on an Active Record object that it didn't actually destroy it, but just "hid" the record. Paranoia does this by setting a `deleted_at` field to the current time when you `destroy` a record, and hides it by scoping all queries on your model to only include records which do not have a `deleted_at` field.
 
-If you wish to actually destroy an object you may call destroy! on it or simply call destroy twice on the same object.
+If you wish to actually destroy an object you may call `really_destroy!`.
 
 ## Installation & Usage
 
@@ -66,9 +66,23 @@ class Client < ActiveRecord::Base
 end
 ```
 
-Hey presto, it's there!
+Hey presto, it's there! Calling `destroy` will now set the `deleted_at` column:
 
-If you want a method to be called on destroy, simply provide a _before\_destroy_ callback:
+
+```
+>> client.deleted_at => nil
+>> client.destroy => client
+>> client.deleted_at => [current timestamp]
+```
+
+If you really want it gone *gone*, call `really_destroy!`
+
+```
+>> client.deleted_at => nil
+>> client.real_destroy! => client
+```
+
+If you want a method to be called on destroy, simply provide a `before_destroy` callback:
 
 ```ruby
 class Client < ActiveRecord::Base
@@ -84,6 +98,70 @@ class Client < ActiveRecord::Base
 end
 ```
 
+If you want to use a column other than `deleted_at`, you can pass it as an option:
+
+```ruby
+class Client < ActiveRecord::Base
+  acts_as_paranoid column: :destroyed_at
+
+  ...
+end
+```
+
+If you want to access soft-deleted associations, override the getter method:
+
+```ruby
+def product
+  Product.unscoped { super }
+end
+```
+
+If you want to find all records, even those which are deleted:
+
+```ruby
+Client.with_deleted
+```
+
+If you want to find only the deleted records:
+
+```ruby
+Client.only_deleted
+```
+
+If you want to check if a record is soft-deleted:
+
+```ruby
+client.destroyed?
+```
+
+If you want to restore a record:
+
+```ruby
+Client.restore(id)
+```
+
+If you want to restore a whole bunch of records:
+
+```ruby
+Client.restore([id1, id2, ..., idN])
+```
+
+If you want to restore a record and their dependently destroyed associated records:
+
+```ruby
+Client.restore(id, :recursive => true)
+```
+
+If you want callbacks to trigger before a restore:
+
+```ruby
+before_restore :callback_name_goes_here
+```
+
+For more information, please look at the tests.
+
+## Acts As Paranoid Migration
+
 You can replace the older acts_as_paranoid methods as follows:
 
 | Old Syntax                 | New Syntax                     |

data/lib/paranoia.rb

@@ -8,19 +8,23 @@ module Paranoia
     def paranoid? ; true ; end
 
     def with_deleted
-      all.tap { |x| x.default_scoped = false }
+      if ActiveRecord::VERSION::STRING >= "4.1"
+        unscope where: paranoia_column
+      else
+        all.tap { |x| x.default_scoped = false }
+      end
     end
 
     def only_deleted
-      with_deleted.where.not(deleted_at: nil)
+      with_deleted.where.not(paranoia_column => nil)
     end
     alias :deleted :only_deleted
 
-    def restore(id)
+    def restore(id, opts = {})
       if id.is_a?(Array)
-        id.map { |one_id| restore(one_id) }
+        id.map { |one_id| restore(one_id, opts) }
       else
-        only_deleted.find(id).restore!
+        only_deleted.find(id).restore!(opts)
       end
     end
   end
@@ -44,30 +48,97 @@ module Paranoia
   end
 
   def destroy
-    run_callbacks(:destroy) { delete }
+    run_callbacks(:destroy) { touch_paranoia_column(true) }
+  end
+
+  # As of Rails 4.1.0 +destroy!+ will no longer remove the record from the db
+  # unless you touch the paranoia column before.
+  # We need to override it here otherwise children records might be removed
+  # when they shouldn't
+  if ActiveRecord::VERSION::STRING >= "4.1"
+    def destroy!
+      destroyed? ? super : destroy || raise(ActiveRecord::RecordNotDestroyed)
+    end
   end
 
   def delete
     return if new_record?
-    destroyed? ? destroy! : update_column(:deleted_at, Time.now)
+    touch_paranoia_column(false)
   end
 
-  def restore!
-    run_callbacks(:restore) { update_column :deleted_at, nil }
+  def restore!(opts = {})
+    ActiveRecord::Base.transaction do
+      run_callbacks(:restore) do
+        update_column paranoia_column, nil
+        restore_associated_records if opts[:recursive]
+      end
+    end
   end
+  alias :restore :restore!
 
   def destroyed?
-    !!deleted_at
+    !!send(paranoia_column)
   end
   alias :deleted? :destroyed?
+
+  private
+
+  # touch paranoia column.
+  # insert time to paranoia column.
+  # @param with_transaction [Boolean] exec with ActiveRecord Transactions.
+  def touch_paranoia_column(with_transaction=false)
+    if with_transaction
+      with_transaction_returning_status { touch(paranoia_column) }
+    else
+      touch(paranoia_column)
+    end
+  end
+
+  # restore associated records that have been soft deleted when
+  # we called #destroy
+  def restore_associated_records
+    destroyed_associations = self.class.reflect_on_all_associations.select do |association|
+      association.options[:dependent] == :destroy
+    end
+
+    destroyed_associations.each do |association|
+      association = send(association.name)
+
+      if association.paranoid?
+        association.only_deleted.each { |record| record.restore(:recursive => true) }
+      end
+    end
+  end
 end
 
 class ActiveRecord::Base
-  def self.acts_as_paranoid
+  def self.acts_as_paranoid(options={})
+    alias :really_destroy! :destroy
     alias :destroy! :destroy
-    alias :delete!  :delete
+    alias :delete! :delete
     include Paranoia
-    default_scope { where(self.quoted_table_name + '.deleted_at IS NULL') }
+    class_attribute :paranoia_column
+
+    self.paranoia_column = options[:column] || :deleted_at
+    default_scope { where(paranoia_column => nil) }
+
+    before_restore {
+      self.class.notify_observers(:before_restore, self) if self.class.respond_to?(:notify_observers)
+    }
+    after_restore {
+      self.class.notify_observers(:after_restore, self) if self.class.respond_to?(:notify_observers)
+    }
+  end
+
+  # Please do not use this method in production.
+  # Pretty please.
+  def self.I_AM_THE_DESTROYER!
+    # TODO: actually implement spelling error fixes
+    puts %Q{
+      Sharon: "There should be a method called I_AM_THE_DESTROYER!"
+      Ryan:   "What should this method do?"
+      Sharon: "It should fix all the spelling errors on the page!"
+}
   end
 
   def self.paranoid? ; false ; end
@@ -79,4 +150,10 @@ class ActiveRecord::Base
   def persisted?
     paranoid? ? !new_record? : super
   end
+
+  private
+
+  def paranoia_column
+    self.class.paranoia_column
+  end
 end

data/lib/paranoia/version.rb

@@ -1,3 +1,3 @@
 module Paranoia
-  VERSION = "2.0.1"
+  VERSION = "2.0.2"
 end

data/paranoia.gemspec

@@ -17,8 +17,7 @@ Gem::Specification.new do |s|
   s.add_dependency "activerecord", "~> 4.0"
 
   s.add_development_dependency "bundler", ">= 1.0.0"
-  s.add_development_dependency "sqlite3"
-  s.add_development_dependency "rake", "0.8.7"
+  s.add_development_dependency "rake"
 
   s.files        = `git ls-files`.split("\n")
   s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact

data/test/paranoia_test.rb

@@ -1,13 +1,15 @@
-require 'test/unit'
 require 'active_record'
-require File.expand_path(File.dirname(__FILE__) + "/../lib/paranoia")
-
-DB_FILE = 'tmp/test_db'
 
-FileUtils.mkdir_p File.dirname(DB_FILE)
-FileUtils.rm_f DB_FILE
+test_framework = if ActiveRecord::VERSION::STRING >= "4.1"
+  require 'minitest/autorun'
+  MiniTest::Test
+else
+  require 'test/unit'
+  Test::Unit::TestCase
+end
+require File.expand_path(File.dirname(__FILE__) + "/../lib/paranoia")
 
-ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => DB_FILE
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', database: ':memory:'
 ActiveRecord::Base.connection.execute 'CREATE TABLE parent_models (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
 ActiveRecord::Base.connection.execute 'CREATE TABLE paranoid_models (id INTEGER NOT NULL PRIMARY KEY, parent_model_id INTEGER, deleted_at DATETIME)'
 ActiveRecord::Base.connection.execute 'CREATE TABLE featureful_models (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME, name VARCHAR(32))'
@@ -17,8 +19,16 @@ ActiveRecord::Base.connection.execute 'CREATE TABLE related_models (id INTEGER N
 ActiveRecord::Base.connection.execute 'CREATE TABLE employers (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
 ActiveRecord::Base.connection.execute 'CREATE TABLE employees (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
 ActiveRecord::Base.connection.execute 'CREATE TABLE jobs (id INTEGER NOT NULL PRIMARY KEY, employer_id INTEGER NOT NULL, employee_id INTEGER NOT NULL, deleted_at DATETIME)'
+ActiveRecord::Base.connection.execute 'CREATE TABLE custom_column_models (id INTEGER NOT NULL PRIMARY KEY, destroyed_at DATETIME)'
+ActiveRecord::Base.connection.execute 'CREATE TABLE non_paranoid_models (id INTEGER NOT NULL PRIMARY KEY, parent_model_id INTEGER)'
+
+class ParanoiaTest < test_framework
+  def setup
+    ActiveRecord::Base.connection.tables.each do |table|
+      ActiveRecord::Base.connection.execute "DELETE FROM #{table}"
+    end
+  end
 
-class ParanoiaTest < Test::Unit::TestCase
   def test_plain_model_class_is_not_paranoid
     assert_equal false, PlainModel.paranoid?
   end
@@ -42,7 +52,7 @@ class ParanoiaTest < Test::Unit::TestCase
 
     model.destroy
 
-    assert_not_equal nil, model.to_param
+    assert model.to_param
     assert_equal to_param, model.to_param
   end
 
@@ -59,6 +69,37 @@ class ParanoiaTest < Test::Unit::TestCase
     assert_equal 0, model.class.unscoped.count
   end
 
+  # Anti-regression test for #81, which would've introduced a bug to break this test.
+  def test_destroy_behavior_for_plain_models_callbacks
+    model = CallbackModel.new
+    model.save
+    model.remove_called_variables     # clear called callback flags
+    model.destroy
+
+    assert_equal nil, model.instance_variable_get(:@update_callback_called)
+    assert_equal nil, model.instance_variable_get(:@save_callback_called)
+    assert_equal nil, model.instance_variable_get(:@validate_called)
+
+    assert model.instance_variable_get(:@destroy_callback_called)
+    assert model.instance_variable_get(:@after_destroy_callback_called)
+    assert model.instance_variable_get(:@after_commit_callback_called)
+  end
+
+
+  def test_delete_behavior_for_plain_models_callbacks
+    model = CallbackModel.new
+    model.save
+    model.remove_called_variables     # clear called callback flags
+    model.delete
+
+    assert_equal nil, model.instance_variable_get(:@update_callback_called)
+    assert_equal nil, model.instance_variable_get(:@save_callback_called)
+    assert_equal nil, model.instance_variable_get(:@validate_called)
+    assert_equal nil, model.instance_variable_get(:@destroy_callback_called)
+    assert_equal nil, model.instance_variable_get(:@after_destroy_callback_called)
+    assert_equal nil, model.instance_variable_get(:@after_commit_callback_called)
+  end
+
   def test_destroy_behavior_for_paranoid_models
     model = ParanoidModel.new
     assert_equal 0, model.class.count
@@ -73,7 +114,6 @@ class ParanoiaTest < Test::Unit::TestCase
   end
 
   def test_scoping_behavior_for_paranoid_models
-    ParanoidModel.unscoped.delete_all
     parent1 = ParentModel.create
     parent2 = ParentModel.create
     p1 = ParanoidModel.create(:parent_model => parent1)
@@ -88,6 +128,23 @@ class ParanoiaTest < Test::Unit::TestCase
     assert_equal [p1,p3], parent1.paranoid_models.with_deleted
   end
 
+  def test_destroy_behavior_for_custom_column_models
+    model = CustomColumnModel.new
+    assert_equal 0, model.class.count
+    model.save!
+    assert_nil model.destroyed_at
+    assert_equal 1, model.class.count
+    model.destroy
+
+    assert_equal false, model.destroyed_at.nil?
+    assert model.destroyed?
+
+    assert_equal 0, model.class.count
+    assert_equal 1, model.class.unscoped.count
+    assert_equal 1, model.class.only_deleted.count
+    assert_equal 1, model.class.deleted.count
+  end
+
   def test_destroy_behavior_for_featureful_paranoid_models
     model = get_featureful_model
     assert_equal 0, model.class.count
@@ -164,14 +221,14 @@ class ParanoiaTest < Test::Unit::TestCase
     model = CallbackModel.new
     model.save
     model.delete
-    assert_equal nil, model.instance_variable_get(:@callback_called)
+    assert_equal nil, model.instance_variable_get(:@destroy_callback_called)
   end
 
   def test_destroy_behavior_for_callbacks
     model = CallbackModel.new
     model.save
     model.destroy
-    assert model.instance_variable_get(:@callback_called)
+    assert model.instance_variable_get(:@destroy_callback_called)
   end
 
   def test_restore
@@ -189,13 +246,14 @@ class ParanoiaTest < Test::Unit::TestCase
     assert_equal false, model.destroyed?
   end
 
+  # Regression test for #92
   def test_destroy_twice
     model = ParanoidModel.new
     model.save
     model.destroy
     model.destroy
 
-    assert_equal 0, ParanoidModel.unscoped.where(id: model.id).count
+    assert_equal 1, ParanoidModel.unscoped.where(id: model.id).count
   end
 
   def test_restore_behavior_for_callbacks
@@ -216,11 +274,19 @@ class ParanoiaTest < Test::Unit::TestCase
   def test_real_destroy
     model = ParanoidModel.new
     model.save
-    model.destroy!
-
+    model.really_destroy!
     refute ParanoidModel.unscoped.exists?(model.id)
   end
 
+  if ActiveRecord::VERSION::STRING < "4.1"
+    def test_real_destroy
+      model = ParanoidModel.new
+      model.save
+      model.destroy!
+      refute ParanoidModel.unscoped.exists?(model.id)
+    end
+  end
+
   def test_real_delete
     model = ParanoidModel.new
     model.save
@@ -256,6 +322,59 @@ class ParanoiaTest < Test::Unit::TestCase
     refute c.destroyed?
   end
 
+  def test_restore_with_associations
+    parent = ParentModel.create
+    first_child = parent.very_related_models.create
+    second_child = parent.non_paranoid_models.create
+
+    parent.destroy
+    assert_equal false, parent.deleted_at.nil?
+    assert_equal false, first_child.reload.deleted_at.nil?
+    assert_equal true, second_child.destroyed?
+
+    parent.restore!
+    assert_equal true, parent.deleted_at.nil?
+    assert_equal false, first_child.reload.deleted_at.nil?
+    assert_equal true, second_child.destroyed?
+
+    parent.destroy
+    parent.restore(:recursive => true)
+    assert_equal true, parent.deleted_at.nil?
+    assert_equal true, first_child.reload.deleted_at.nil?
+    assert_equal true, second_child.destroyed?
+
+    parent.destroy
+    ParentModel.restore(parent.id, :recursive => true)
+    assert_equal true, parent.reload.deleted_at.nil?
+    assert_equal true, first_child.reload.deleted_at.nil?
+    assert_equal true, second_child.destroyed?
+  end
+
+  def test_observers_notified
+    a = ParanoidModelWithObservers.create
+    a.destroy
+    a.restore!
+
+    assert a.observers_notified.select {|args| args == [:before_restore, a]}
+    assert a.observers_notified.select {|args| args == [:after_restore, a]}
+  end
+
+  def test_observers_not_notified_if_not_supported
+    a = ParanoidModelWithObservers.create
+    a.destroy
+    a.restore!
+    # essentially, we're just ensuring that this doesn't crash
+  end
+
+  def test_i_am_the_destroyer
+    output = capture(:stdout) { ParanoidModel.I_AM_THE_DESTROYER! }
+    assert_equal %Q{
+      Sharon: "There should be a method called I_AM_THE_DESTROYER!"
+      Ryan:   "What should this method do?"
+      Sharon: "It should fix all the spelling errors on the page!"
+}, output
+  end
+
   private
   def get_featureful_model
     FeaturefulModel.new(:name => "not empty")
@@ -264,10 +383,6 @@ end
 
 # Helper classes
 
-class ParentModel < ActiveRecord::Base
-  has_many :paranoid_models
-end
-
 class ParanoidModel < ActiveRecord::Base
   belongs_to :parent_model
   acts_as_paranoid
@@ -283,13 +398,27 @@ end
 
 class CallbackModel < ActiveRecord::Base
   acts_as_paranoid
-  before_destroy {|model| model.instance_variable_set :@callback_called, true }
+  before_destroy {|model| model.instance_variable_set :@destroy_callback_called, true }
   before_restore {|model| model.instance_variable_set :@restore_callback_called, true }
+  before_update  {|model| model.instance_variable_set :@update_callback_called, true }
+  before_save    {|model| model.instance_variable_set :@save_callback_called, true}
+
+  after_destroy  {|model| model.instance_variable_set :@after_destroy_callback_called, true }
+  after_commit   {|model| model.instance_variable_set :@after_commit_callback_called, true }
+
+  validate       {|model| model.instance_variable_set :@validate_called, true }
+
+  def remove_called_variables
+    instance_variables.each {|name| (name.to_s.end_with?('_called')) ? remove_instance_variable(name) : nil}
+  end
 end
 
 class ParentModel < ActiveRecord::Base
   acts_as_paranoid
+  has_many :paranoid_models
   has_many :related_models
+  has_many :very_related_models, :class_name => 'RelatedModel', dependent: :destroy
+  has_many :non_paranoid_models, dependent: :destroy
 end
 
 class RelatedModel < ActiveRecord::Base
@@ -314,3 +443,24 @@ class Job < ActiveRecord::Base
   belongs_to :employer
   belongs_to :employee
 end
+
+class CustomColumnModel < ActiveRecord::Base
+  acts_as_paranoid column: :destroyed_at
+end
+
+class NonParanoidModel < ActiveRecord::Base
+end
+
+class ParanoidModelWithObservers < ParanoidModel
+  def observers_notified
+    @observers_notified ||= []
+  end
+
+  def self.notify_observer(*args)
+    observers_notified << args
+  end
+end
+
+class ParanoidModelWithoutObservers < ParanoidModel
+  self.class.send(remove_method :notify_observers) if method_defined?(:notify_observers)
+end

metadata

@@ -1,71 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: paranoia
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors:
 - radarlistener@gmail.com
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-24 00:00:00.000000000 Z
+date: 2014-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.0
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.8.7
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.8.7
 description: Paranoia is a re-implementation of acts_as_paranoid for Rails 3, using
   much, much, much less code. You would use either plugin / gem if you wished that
   when you called destroy on an Active Record object that it didn't actually destroy
@@ -77,7 +63,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -95,17 +82,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
 rubyforge_project: paranoia
-rubygems_version: 2.1.0
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Paranoia is a re-implementation of acts_as_paranoid for Rails 3, using much,