paranoia 2.1.3 → 2.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16d15104c160fe11573395f01bcf18d026d64291
-  data.tar.gz: 009671430b1d508dc3a020773aa8a34666933b30
+  metadata.gz: 45933ae6db17d7ae34422587c41002a61915c588
+  data.tar.gz: 993a0cf0d2414179bcc916b3a3f00debf582332a
 SHA512:
-  metadata.gz: 9d8cbcb3adc56426e31fdfdfe551c0e557ea023053358ce22083ef5a7140fa480ef004c6e363b95dfddd838f244090edf8cc6dc86a0cc05d98d00f6716d892a0
-  data.tar.gz: c9a6eb1e4da8f21976b01152b0faed9ce736f9019896db44595475c75079266b3dccc6dc4f41a972ef1fba25003ebcb0b3ef76f29fb13884535b02ea5fa8fd69
+  metadata.gz: ef70ba0f7801c7f6cc624159120fd149a25d15e3ba8a06b050a1549bedb75bfc4bcf16c70c2882104ee7623294890c4760c2baae0f99ef2eb18dca8093c3a3f1
+  data.tar.gz: 452e9212c38168259988b8df9e26656cb3799cae8ab093341a9679b5d6b5430eae3430da82d67e4a46aa92cdefd92354dc61d126394e96f934b3bd6fb6119a92

data/CONTRIBUTING.md

@@ -0,0 +1,34 @@
+Paranoia is an open source project and we encourage contributions.
+
+## Filing an issue
+
+When filing an issue on the Paranoia project, please provide these details:
+
+* A comprehensive list of steps to reproduce the issue.
+* What you're *expecting* to happen compared with what's *actually* happening.
+* Your application's complete `Gemfile.lock`, and `Gemfile.lock` as text in a [Gist](https://gist.github.com) (*not as an image*)
+* Any relevant stack traces ("Full trace" preferred)
+
+In 99% of cases, this information is enough to determine the cause and solution
+to the problem that is being described.
+
+Please remember to format code using triple backticks (\`) so that it is neatly
+formatted when the issue is posted.
+
+## Pull requests
+
+We gladly accept pull requests to add documentation, fix bugs and, in some circumstances,
+add new features to Paranoia.
+
+Here's a quick guide:
+
+1. Fork the repo.
+
+2. Run the tests. We only take pull requests with passing tests, and it's great
+to know that you have a clean slate.
+
+3. Create new branch then make changes and add tests for your changes. Only
+refactoring and documentation changes require no new tests. If you are adding
+functionality or fixing a bug, we need tests!
+
+4. Push to your fork and submit a pull request.

data/README.md

@@ -2,14 +2,14 @@
 
 Paranoia is a re-implementation of [acts\_as\_paranoid](http://github.com/technoweenie/acts_as_paranoid) for Rails 3 and Rails 4, 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 it, but just *hide* 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.
+When your app is using Paranoia, calling `destroy` on an ActiveRecord object doesn't actually destroy the database record, but just *hides* it. 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 `really_destroy!`. **WARNING**: This will also *really destroy* all `dependent: :destroy` records, so please aim this method away from face when using.
 
 If a record has `has_many` associations defined AND those associations have `dependent: :destroy` set on them, then they will also be soft-deleted if `acts_as_paranoid` is set,  otherwise the normal destroy will be called.
 
 ## Getting Started Video
-Setup and basic usage of the paranoia gem  
+Setup and basic usage of the paranoia gem
 [GoRails #41](https://gorails.com/episodes/soft-delete-with-paranoia)
 
 ## Installation & Usage
@@ -94,22 +94,6 @@ If you really want it gone *gone*, call `really_destroy!`:
 # => client
 ```
 
-If you want a method to be called on destroy, simply provide a `before_destroy` callback:
-
-``` ruby
-class Client < ActiveRecord::Base
-  acts_as_paranoid
-
-  before_destroy :some_method
-
-  def some_method
-    # do stuff
-  end
-
-  # ...
-end
-```
-
 If you want to use a column other than `deleted_at`, you can pass it as an option:
 
 ``` ruby
@@ -180,12 +164,6 @@ Client.restore(id, :recursive => true)
 client.restore(: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.
 
 #### About indexes:
@@ -207,6 +185,49 @@ add_index :clients, [:group_id, :other_id], where: "deleted_at IS NULL"
 
 Of course, this is not necessary for the indexes you always use in association with `with_deleted` or `only_deleted`.
 
+##### Unique Indexes
+
+Becuse NULL != NULL in standard SQL, we can not simply create a unique index
+on the deleted_at column and expect it to enforce that there only be one record
+with a certain combination of values.
+
+If your database supports them, good alternatives include partial indexes
+(above) and indexes on computed columns. E.g.
+
+``` ruby
+add_index :clients, [:group_id, 'COALESCE(deleted_at, false)'], unique: true
+```
+
+If not, an alternative is to create a separate column which is maintained
+alongside deleted_at for the sake of enforcing uniqueness. To that end,
+paranoia makes use of two method to make its destroy and restore actions:
+paranoia_restore_attributes and paranoia_destroy_attributes.
+
+``` ruby
+add_column :clients, :active, :boolean
+add_index :clients, [:group_id, :active], unique: true
+
+class Client < ActiveRecord::Base
+  # optionally have paranoia make use of your unique column, so that
+  # your lookups will benefit from the unique index
+  acts_as_paranoid column: :active, sentinel_value: true
+
+  def paranoia_restore_attributes
+    {
+      deleted_at: nil,
+      active: true
+    }
+  end
+
+  def paranoia_destroy_attributes
+    {
+      deleted_at: current_time_from_proper_timezone,
+      active: nil
+    }
+  end
+end
+```
+
 ## Acts As Paranoid Migration
 
 You can replace the older `acts_as_paranoid` methods as follows:
@@ -221,6 +242,24 @@ You can replace the older `acts_as_paranoid` methods as follows:
 The `recover` method in `acts_as_paranoid` runs `update` callbacks.  Paranoia's
 `restore` method does not do this.
 
+## Callbacks
+
+Paranoia provides few callbacks. It triggers `destroy` callback when the record is marked as deleted and `real_destroy` when the record is completely removed from database. It also calls `restore` callback when record is restored via paranoia
+
+For example if you want to index you records in some search engine you can do like this:
+
+```ruby
+class Product < ActiveRecord::Base
+  acts_as_paranoid
+
+  after_destroy      :update_document_in_search_engine
+  after_restore      :update_document_in_search_engine
+  after_real_destroy :remove_document_from_search_engine
+end
+```
+
+You can use these events just like regular Rails callbacks with before, after and around hooks.
+
 ## License
 
 This gem is released under the MIT license.

data/lib/paranoia.rb

@@ -22,14 +22,21 @@ module Paranoia
 
     def with_deleted
       if ActiveRecord::VERSION::STRING >= "4.1"
-        unscope where: paranoia_column
-      else
-        all.tap { |x| x.default_scoped = false }
+        return unscope where: paranoia_column
       end
+      all.tap { |x| x.default_scoped = false }
     end
 
     def only_deleted
-      with_deleted.where.not(paranoia_column => paranoia_sentinel_value)
+      if paranoia_sentinel_value.nil?
+        return with_deleted.where.not(paranoia_column => paranoia_sentinel_value)
+      end
+      # if paranoia_sentinel_value is not null, then it is possible that
+      # some deleted rows will hold a null value in the paranoia column
+      # these will not match != sentinel value because "NULL != value" is
+      # NULL under the sql standard
+      quoted_paranoia_column = connection.quote_column_name(paranoia_column)
+      with_deleted.where("#{quoted_paranoia_column} IS NULL OR #{quoted_paranoia_column} != ?", paranoia_sentinel_value)
     end
     alias :deleted :only_deleted
 
@@ -47,18 +54,20 @@ module Paranoia
 
   module Callbacks
     def self.extended(klazz)
-      klazz.define_callbacks :restore
+      [:restore, :real_destroy].each do |callback_name|
+        klazz.define_callbacks callback_name
 
-      klazz.define_singleton_method("before_restore") do |*args, &block|
-        set_callback(:restore, :before, *args, &block)
-      end
+        klazz.define_singleton_method("before_#{callback_name}") do |*args, &block|
+          set_callback(callback_name, :before, *args, &block)
+        end
 
-      klazz.define_singleton_method("around_restore") do |*args, &block|
-        set_callback(:restore, :around, *args, &block)
-      end
+        klazz.define_singleton_method("around_#{callback_name}") do |*args, &block|
+          set_callback(callback_name, :around, *args, &block)
+        end
 
-      klazz.define_singleton_method("after_restore") do |*args, &block|
-        set_callback(:restore, :after, *args, &block)
+        klazz.define_singleton_method("after_#{callback_name}") do |*args, &block|
+          set_callback(callback_name, :after, *args, &block)
+        end
       end
     end
   end
@@ -66,16 +75,13 @@ module Paranoia
   def destroy
     transaction do
       run_callbacks(:destroy) do
-        result = touch_paranoia_column
-        if result && ActiveRecord::VERSION::STRING >= '4.2'
-          each_counter_cached_associations do |association|
-            foreign_key = association.reflection.foreign_key.to_sym
-            unless destroyed_by_association && destroyed_by_association.foreign_key.to_sym == foreign_key
-              if send(association.reflection.name)
-                association.decrement_counters
-              end
-            end
-          end
+        result = delete
+        next result unless result && ActiveRecord::VERSION::STRING >= '4.2'
+        each_counter_cached_associations do |association|
+          foreign_key = association.reflection.foreign_key.to_sym
+          next if destroyed_by_association && destroyed_by_association.foreign_key.to_sym == foreign_key
+          next unless send(association.reflection.name)
+          association.decrement_counters
         end
         result
       end
@@ -83,7 +89,16 @@ module Paranoia
   end
 
   def delete
-    touch_paranoia_column
+    raise ActiveRecord::ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
+    if persisted?
+      # if a transaction exists, add the record so that after_commit
+      # callbacks can be run
+      add_to_transaction
+      update_columns(paranoia_destroy_attributes)
+    elsif !frozen?
+      assign_attributes(paranoia_destroy_attributes)
+    end
+    self
   end
 
   def restore!(opts = {})
@@ -94,7 +109,7 @@ module Paranoia
         noop_if_frozen = ActiveRecord.version < Gem::Version.new("4.1")
         if (noop_if_frozen && !@attributes.frozen?) || !noop_if_frozen
           write_attribute paranoia_column, paranoia_sentinel_value
-          update_column paranoia_column, paranoia_sentinel_value
+          update_columns(paranoia_restore_attributes)
         end
         restore_associated_records if opts[:recursive]
       end
@@ -111,16 +126,16 @@ module Paranoia
 
   private
 
-  # touch paranoia column.
-  # insert time to paranoia column.
-  def touch_paranoia_column
-    raise ActiveRecord::ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
-    if persisted?
-      touch(paranoia_column)
-    elsif !frozen?
-      write_attribute(paranoia_column, current_time_from_proper_timezone)
-    end
-    self
+  def paranoia_restore_attributes
+    {
+      paranoia_column => paranoia_sentinel_value
+    }
+  end
+
+  def paranoia_destroy_attributes
+    {
+      paranoia_column => current_time_from_proper_timezone
+    }
   end
 
   # restore associated records that have been soft deleted when
@@ -154,7 +169,7 @@ module Paranoia
           association_find_conditions = { association_foreign_key => self.id }
         end
 
-        association_class = Object.const_get(association_class_name)
+        association_class = association_class_name.constantize
         if association_class.paranoid?
           association_class.only_deleted.where(association_find_conditions).first.try!(:restore, recursive: true)
         end
@@ -172,25 +187,27 @@ class ActiveRecord::Base
 
     alias :destroy_without_paranoia :destroy
     def really_destroy!
-      dependent_reflections = self.class.reflections.select do |name, reflection|
-        reflection.options[:dependent] == :destroy
-      end
-      if dependent_reflections.any?
-        dependent_reflections.each do |name, reflection|
-          association_data = self.send(name)
-          # has_one association can return nil
-          # .paranoid? will work for both instances and classes
-          if association_data && association_data.paranoid?
-            if reflection.collection?
-              association_data.with_deleted.each(&:really_destroy!)
-            else
+      transaction do
+        run_callbacks(:real_destroy) do
+          dependent_reflections = self.class.reflections.select do |name, reflection|
+            reflection.options[:dependent] == :destroy
+          end
+          if dependent_reflections.any?
+            dependent_reflections.each do |name, reflection|
+              association_data = self.send(name)
+              # has_one association can return nil
+              # .paranoid? will work for both instances and classes
+              next unless association_data && association_data.paranoid?
+              if reflection.collection?
+                next association_data.with_deleted.each(&:really_destroy!)
+              end
               association_data.really_destroy!
             end
           end
+          write_attribute(paranoia_column, current_time_from_proper_timezone)
+          destroy_without_paranoia
         end
       end
-      write_attribute(paranoia_column, current_time_from_proper_timezone)
-      destroy_without_paranoia
     end
 
     include Paranoia
@@ -237,3 +254,17 @@ class ActiveRecord::Base
 end
 
 require 'paranoia/rspec' if defined? RSpec
+
+module ActiveRecord
+  module Validations
+    class UniquenessValidator < ActiveModel::EachValidator
+      protected
+      def build_relation_with_paranoia(klass, table, attribute, value)
+        relation = build_relation_without_paranoia(klass, table, attribute, value)
+        return relation unless klass.respond_to?(:paranoia_column)
+        relation.and(klass.arel_table[klass.paranoia_column].eq(klass.paranoia_sentinel_value))
+      end
+      alias_method_chain :build_relation, :paranoia
+    end
+  end
+end

data/lib/paranoia/version.rb

@@ -1,3 +1,3 @@
 module Paranoia
-  VERSION = "2.1.3"
+  VERSION = "2.1.4"
 end

data/test/paranoia_test.rb

@@ -1,10 +1,10 @@
+require 'bundler/setup'
 require 'active_record'
-ActiveRecord::Base.raise_in_transactional_callbacks = true if ActiveRecord::VERSION::STRING >= '4.2'
-
 require 'minitest/autorun'
-test_framework = defined?(MiniTest::Test) ? MiniTest::Test : MiniTest::Unit::TestCase
+require 'paranoia'
 
-require File.expand_path(File.dirname(__FILE__) + "/../lib/paranoia")
+test_framework = defined?(MiniTest::Test) ? MiniTest::Test : MiniTest::Unit::TestCase
+ActiveRecord::Base.raise_in_transactional_callbacks = true if ActiveRecord::VERSION::STRING >= '4.2'
 
 def connect!
   ActiveRecord::Base.establish_connection :adapter => 'sqlite3', database: ':memory:'
@@ -28,7 +28,7 @@ def setup!
     'fail_callback_models' => 'deleted_at DATETIME',
     'related_models' => 'parent_model_id INTEGER, parent_model_with_counter_cache_column_id INTEGER, deleted_at DATETIME',
     'asplode_models' => 'parent_model_id INTEGER, deleted_at DATETIME',
-    'employers' => 'deleted_at DATETIME',
+    'employers' => 'name VARCHAR(32), deleted_at DATETIME',
     'employees' => 'deleted_at DATETIME',
     'jobs' => 'employer_id INTEGER NOT NULL, employee_id INTEGER NOT NULL, deleted_at DATETIME',
     'custom_column_models' => 'destroyed_at DATETIME',
@@ -37,6 +37,9 @@ def setup!
     'polymorphic_models' => 'parent_id INTEGER, parent_type STRING, deleted_at DATETIME',
     'namespaced_paranoid_has_ones' => 'deleted_at DATETIME, paranoid_belongs_tos_id INTEGER',
     'namespaced_paranoid_belongs_tos' => 'deleted_at DATETIME, paranoid_has_one_id INTEGER',
+    'unparanoid_unique_models' => 'name VARCHAR(32), paranoid_with_unparanoids_id INTEGER',
+    'active_column_models' => 'deleted_at DATETIME, active BOOLEAN',
+    'active_column_model_with_uniqueness_validations' => 'name VARCHAR(32), deleted_at DATETIME, active BOOLEAN'
   }.each do |table_name, columns_as_sql_string|
     ActiveRecord::Base.connection.execute "CREATE TABLE #{table_name} (id INTEGER NOT NULL PRIMARY KEY, #{columns_as_sql_string})"
   end
@@ -120,6 +123,22 @@ class ParanoiaTest < test_framework
     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_delete_in_transaction_behavior_for_plain_models_callbacks
+    model = CallbackModel.new
+    model.save
+    model.remove_called_variables     # clear called callback flags
+    CallbackModel.transaction do
+      model.delete
+    end
+
     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)
@@ -184,6 +203,38 @@ class ParanoiaTest < test_framework
     assert_equal nil, ParanoidModel.paranoia_sentinel_value
   end
 
+  def test_active_column_model
+    model = ActiveColumnModel.new
+    assert_equal 0, model.class.count
+    model.save!
+    assert_nil model.deleted_at
+    assert_equal true, model.active
+    assert_equal 1, model.class.count
+    model.destroy
+
+    assert_equal false, model.deleted_at.nil?
+    assert_nil model.active
+    assert model.paranoia_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_active_column_model_with_uniqueness_validation_only_checks_non_deleted_records
+    a = ActiveColumnModelWithUniquenessValidation.create!(name: "A")
+    a.destroy
+    b = ActiveColumnModelWithUniquenessValidation.new(name: "A")
+    assert b.valid?
+  end
+
+  def test_active_column_model_with_uniqueness_validation_still_works_on_non_deleted_records
+    a = ActiveColumnModelWithUniquenessValidation.create!(name: "A")
+    b = ActiveColumnModelWithUniquenessValidation.new(name: "A")
+    refute b.valid?
+  end
+
   def test_sentinel_value_for_custom_sentinel_models
     model = CustomSentinelModel.new
     assert_equal 0, model.class.count
@@ -453,6 +504,14 @@ class ParanoiaTest < test_framework
     assert RelatedModel.unscoped.exists?(child_2.id)
   end
 
+  def test_really_destroy_behavior_for_callbacks
+    model = CallbackModel.new
+    model.save
+    model.really_destroy!
+
+    assert model.instance_variable_get(:@real_destroy_callback_called)
+  end
+
   def test_really_delete
     model = ParanoidModel.new
     model.save
@@ -685,6 +744,19 @@ class ParanoiaTest < test_framework
     # essentially, we're just ensuring that this doesn't crash
   end
 
+  def test_validates_uniqueness_only_checks_non_deleted_records
+    a = Employer.create!(name: "A")
+    a.destroy
+    b = Employer.new(name: "A")
+    assert b.valid?
+  end
+
+  def test_validates_uniqueness_still_works_on_non_deleted_records
+    a = Employer.create!(name: "A")
+    b = Employer.new(name: "A")
+    refute b.valid?
+  end
+
   def test_i_am_the_destroyer
     expected = %Q{
       Sharon: "There should be a method called I_AM_THE_DESTROYER!"
@@ -800,6 +872,13 @@ class ParanoiaTest < test_framework
     # assert related_model.instance_variable_get(:@after_commit_on_destroy_callback_called)
   end
 
+  def test_uniqueness_for_unparanoid_associated
+    parent_model = ParanoidWithUnparanoids.create
+    related = parent_model.unparanoid_unique_models.create
+    # will raise exception if model is not checked for paranoia
+    related.valid?
+  end
+
   # TODO: find a fix for Rails 4.1
   if ActiveRecord::VERSION::STRING !~ /\A4\.1/
     def test_counter_cache_column_update_on_really_destroy
@@ -841,6 +920,16 @@ class ParanoidModel < ActiveRecord::Base
   acts_as_paranoid
 end
 
+class ParanoidWithUnparanoids < ActiveRecord::Base
+  self.table_name = 'plain_models'
+  has_many :unparanoid_unique_models
+end
+
+class UnparanoidUniqueModel < ActiveRecord::Base
+  belongs_to :paranoid_with_unparanoids
+  validates :name, :uniqueness => true
+end
+
 class FailCallbackModel < ActiveRecord::Base
   belongs_to :parent_model
   acts_as_paranoid
@@ -853,20 +942,25 @@ class FeaturefulModel < ActiveRecord::Base
   validates :name, :presence => true, :uniqueness => true
 end
 
+class NonParanoidChildModel < ActiveRecord::Base
+  validates :name, :presence => true, :uniqueness => true
+end
+
 class PlainModel < ActiveRecord::Base
 end
 
 class CallbackModel < ActiveRecord::Base
   acts_as_paranoid
-  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}
+  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}
+  before_real_destroy { |model| model.instance_variable_set :@real_destroy_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 }
+  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 }
+  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}
@@ -909,6 +1003,7 @@ end
 
 class Employer < ActiveRecord::Base
   acts_as_paranoid
+  validates_uniqueness_of :name
   has_many :jobs
   has_many :employees, :through => :jobs
 end
@@ -933,6 +1028,43 @@ class CustomSentinelModel < ActiveRecord::Base
   acts_as_paranoid sentinel_value: DateTime.new(0)
 end
 
+class ActiveColumnModel < ActiveRecord::Base
+  acts_as_paranoid column: :active, sentinel_value: true
+
+  def paranoia_restore_attributes
+    {
+      deleted_at: nil,
+      active: true
+    }
+  end
+
+  def paranoia_destroy_attributes
+    {
+      deleted_at: current_time_from_proper_timezone,
+      active: nil
+    }
+  end
+end
+
+class ActiveColumnModelWithUniquenessValidation < ActiveRecord::Base
+  validates :name, :uniqueness => true
+  acts_as_paranoid column: :active, sentinel_value: true
+
+  def paranoia_restore_attributes
+    {
+      deleted_at: nil,
+      active: true
+    }
+  end
+
+  def paranoia_destroy_attributes
+    {
+      deleted_at: current_time_from_proper_timezone,
+      active: nil
+    }
+  end
+end
+
 class NonParanoidModel < ActiveRecord::Base
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: paranoia
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 2.1.4
 platform: ruby
 authors:
 - radarlistener@gmail.com
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-17 00:00:00.000000000 Z
+date: 2015-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -66,6 +66,7 @@ files:
 - ".gitignore"
 - ".travis.yml"
 - CHANGELOG.md
+- CONTRIBUTING.md
 - Gemfile
 - LICENSE
 - README.md
@@ -94,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: paranoia
-rubygems_version: 2.4.8
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Paranoia is a re-implementation of acts_as_paranoid for Rails 3, using much,