cmoran92-paranoia 2.0.2a

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/*
+*.gem
+.bundle
+tmp
+.rvmrc
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - jruby-19mode
+
+env:
+  - RAILS='~> 4.0.8'
+  - RAILS='~> 4.1.4'

data/Gemfile

@@ -0,0 +1,17 @@
+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.1.4'
+
+gem 'rails', rails
+
+# Specify your gem's dependencies in paranoia.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,17 @@
+Permission is hereby granted, without written agreement and without
+license or royalty fees, to use, copy, modify, and distribute this
+software and its documentation for any purpose, provided that the
+above copyright notice and the following two paragraphs appear in
+all copies of this software.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
+DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
+IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
+PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

data/README.md

@@ -0,0 +1,208 @@
+# Paranoia
+
+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.
+
+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.
+
+## Installation & Usage
+
+For Rails 3, please use version 1 of Paranoia:
+
+``` ruby
+gem "paranoia", "~> 1.0"
+```
+
+For Rails 4, please use version 2 of Paranoia:
+
+``` ruby
+gem "paranoia", "~> 2.0"
+```
+
+Of course you can install this from GitHub as well:
+
+``` ruby
+gem "paranoia", :github => "radar/paranoia", :branch => "master"
+# or
+gem "paranoia", :github => "radar/paranoia", :branch => "rails4"
+```
+
+Then run:
+
+``` shell
+bundle install
+```
+
+Updating is as simple as `bundle update paranoia`.
+
+#### Run your migrations for the desired models
+
+Run:
+
+``` shell
+rails generate migration AddDeletedAtToClients deleted_at:datetime:index
+```
+
+and now you have a migration
+
+``` ruby
+class AddDeletedAtToClients < ActiveRecord::Migration
+  def change
+    add_column :clients, :deleted_at, :datetime
+    add_index :clients, :deleted_at
+  end
+end
+```
+
+### Usage
+
+#### In your model:
+
+``` ruby
+class Client < ActiveRecord::Base
+  acts_as_paranoid
+
+  # ...
+end
+```
+
+Hey presto, it's there! Calling `destroy` will now set the `deleted_at` column:
+
+
+``` ruby
+>> client.deleted_at
+# => nil
+>> client.destroy
+# => client
+>> client.deleted_at
+# => [current timestamp]
+```
+
+If you really want it gone *gone*, call `really_destroy!`:
+
+``` ruby
+>> client.deleted_at
+# => nil
+>> client.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
+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                     |
+|:-------------------------- |:------------------------------ |
+|`find_with_deleted(:all)`   | `Client.with_deleted`          |
+|`find_with_deleted(:first)` | `Client.with_deleted.first`    |
+|`find_with_deleted(id)`     | `Client.with_deleted.find(id)` |
+
+
+The `recover` method in `acts_as_paranoid` runs `update` callbacks.  Paranoia's
+`restore` method does not do this.
+
+## Support for Unique Keys with Null Values
+
+Most databases ignore null columns when it comes to resolving unique index
+constraints.  This means unique constraints that involve nullable columns may be
+problematic. Instead of using `NULL` to represent a not-deleted row, you can pick
+a value that you want paranoia to mean not deleted. Note that you can/should
+now apply a `NOT NULL` constraint to your `deleted_at` column.
+
+Per model:
+
+```ruby
+# pick some value
+acts_as_paranoid sentinel_value: DateTime.new(0)
+```
+
+or globally in a rails initializer, e.g. `config/initializer/paranoia.rb`
+
+```ruby
+Paranoia.default_sentinel_value = DateTime.new(0)
+```
+
+## License
+
+This gem is released under the MIT license.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :test do
+  Dir['test/*_test.rb'].each do |testfile|
+    load testfile
+  end
+end
+
+task :default => :test

data/lib/paranoia/rspec.rb

@@ -0,0 +1,13 @@
+require 'rspec/expectations'
+
+# Validate the subject's class did call "acts_as_paranoid"
+RSpec::Matchers.define :act_as_paranoid do
+  match { |subject| subject.class.ancestors.include?(Paranoia) }
+
+  failure_message { "expected #{subject.class} to use `acts_as_paranoid`" }
+  failure_message_when_negated { "expected #{subject.class} not to use `acts_as_paranoid`" }
+
+  # RSpec 2 compatibility:
+  alias_method :failure_message_for_should, :failure_message
+  alias_method :failure_message_for_should_not, :failure_message_when_negated
+end

data/lib/paranoia/version.rb

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

data/lib/paranoia.rb

@@ -0,0 +1,227 @@
+require 'active_record' unless defined? ActiveRecord
+
+module Paranoia
+  @@default_sentinel_value = nil
+
+  # Change default_sentinel_value in a rails initilizer
+  def self.default_sentinel_value=(val)
+    @@default_sentinel_value = val
+  end
+
+  def self.default_sentinel_value
+    @@default_sentinel_value
+  end
+
+  def self.included(klazz)
+    klazz.extend Query
+    klazz.extend Callbacks
+  end
+
+  module Query
+    def paranoid? ; true ; end
+
+    def with_deleted
+      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(table_name => { paranoia_column => paranoia_sentinel_value} )
+    end
+    alias :deleted :only_deleted
+
+    def restore(id, opts = {})
+      Array(id).flatten.map { |one_id| only_deleted.find(one_id).restore!(opts) }
+    end
+  end
+
+  module Callbacks
+    def self.extended(klazz)
+      klazz.define_callbacks :restore
+
+      klazz.define_singleton_method("before_restore") do |*args, &block|
+        set_callback(:restore, :before, *args, &block)
+      end
+
+      klazz.define_singleton_method("around_restore") do |*args, &block|
+        set_callback(:restore, :around, *args, &block)
+      end
+
+      klazz.define_singleton_method("after_restore") do |*args, &block|
+        set_callback(:restore, :after, *args, &block)
+      end
+    end
+  end
+
+  def destroy
+    callbacks_result = transaction do
+      run_callbacks(:destroy) do
+        touch_paranoia_column
+      end
+    end
+    callbacks_result ? self : false
+  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?
+    touch_paranoia_column(false)
+  end
+
+  def restore!(opts = {})
+    self.class.transaction do
+      run_callbacks(:restore) do
+        # Fixes a bug where the build would error because attributes were frozen.
+        # This only happened on Rails versions earlier than 4.1.
+        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
+        end
+        restore_associated_records if opts[:recursive]
+      end
+    end
+
+    self
+  end
+  alias :restore :restore!
+
+  def destroyed?
+    send(paranoia_column) != paranoia_sentinel_value
+  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)
+    # This method is (potentially) called from really_destroy
+    # The object the method is being called on may be frozen
+    # Let's not touch it if it's frozen.
+    unless self.frozen?
+      if with_transaction
+        with_transaction_returning_status { touch(paranoia_column) }
+      else
+        touch(paranoia_column)
+      end
+    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_data = send(association.name)
+
+      unless association_data.nil?
+        if association_data.paranoid?
+          if association.collection?
+            association_data.only_deleted.each { |record| record.restore(:recursive => true) }
+          else
+            association_data.restore(:recursive => true)
+          end
+        end
+      end
+
+      if association_data.nil? && association.macro.to_s == "has_one"
+        association_class_name = association.options[:class_name].present? ? association.options[:class_name] : association.name.to_s.camelize
+        association_foreign_key = association.options[:foreign_key].present? ? association.options[:foreign_key] : "#{self.class.name.to_s.underscore}_id"
+        Object.const_get(association_class_name).only_deleted.where(association_foreign_key, self.id).first.try(:restore, recursive: true)
+      end
+    end
+
+    clear_association_cache if destroyed_associations.present?
+  end
+end
+
+class ActiveRecord::Base
+  def self.acts_as_paranoid(options={})
+    alias :destroy! :destroy
+    alias :delete! :delete
+    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, _|
+          associated_records = self.send(name)
+          # has_one association can return nil
+          if associated_records && associated_records.respond_to?(:with_deleted)
+            # Paranoid models will have this method, non-paranoid models will not
+            associated_records.with_deleted.each(&:really_destroy!)
+            self.send(name).reload
+          elsif associated_records && !associated_records.respond_to?(:each) # single record
+            associated_records.really_destroy!
+          end
+        end
+      end
+      touch_paranoia_column if ActiveRecord::VERSION::STRING >= "4.1"
+      destroy!
+    end
+
+    include Paranoia
+    class_attribute :paranoia_column, :paranoia_sentinel_value
+
+    self.paranoia_column = (options[:column] || :deleted_at).to_s
+    self.paranoia_sentinel_value = options.fetch(:sentinel_value) { Paranoia.default_sentinel_value }
+    default_scope { where(table_name => { paranoia_column => paranoia_sentinel_value }) }
+
+    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
+  def paranoid? ; self.class.paranoid? ; end
+
+  # Override the persisted method to allow for the paranoia gem.
+  # If a paranoid record is selected, then we only want to check
+  # if it's a new record, not if it is "destroyed".
+  def persisted?
+    paranoid? ? !new_record? : super
+  end
+
+  private
+
+  def paranoia_column
+    self.class.paranoia_column
+  end
+
+  def paranoia_sentinel_value
+    self.class.paranoia_sentinel_value
+  end
+end
+
+require 'paranoia/rspec' if defined? RSpec

data/paranoia.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/paranoia/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "cmoran92-paranoia"
+  s.version     = Paranoia::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["radarlistener@gmail.com"]
+  s.email       = []
+  s.homepage    = "http://rubygems.org/gems/paranoia"
+  s.summary     = "Paranoia is a re-implementation of acts_as_paranoid for Rails 3, using much, much, much less code."
+  s.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 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."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "paranoia"
+
+  s.add_dependency "activerecord", "~> 4.0"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  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
+  s.require_path = 'lib'
+end