kakurenbo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 55d1fd72841d413af8d2a8337eb560bc52c5f30c
+  data.tar.gz: 8f41f354916861de37858bd4a9e6110100bd2cdb
+SHA512:
+  metadata.gz: d063beccd963344db1f4197da40b92991209232c39b04fb64dd448fe407f5e0cbf87ee9e8d259006cfaf5b4a78c9775a49cc23c38092a30664d29ef5fe5f78c0
+  data.tar.gz: 7c87e213b0e260bdcda9bf8c007b75230a13404912ac39f77f40b560b8d8523f299960a4488290707cb0834e578da30ade2e4da08392fa50e1833a374907b507

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+vendor/bundle
+
+# --- IDE Project files ---
+# AptanaStudio
+.project

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+script: bundle exec rspec
+before_install:
+  - gem install bundler
+rvm:
+  - 1.9.3
+  - 2.1.0
+env:
+  - RAILS=3.2.16
+  - RAILS=4.0.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kakurenbo.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Atsushi Nakamura
+
+MIT License
+
+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.md

@@ -0,0 +1,77 @@
+# Kakurenbo
+
+Kakurenbo provides soft delete.
+Kakurenbo is a re-implementation of [paranoia](http://github.com/radar/paranoia) and [acts\_as\_paranoid](http://github.com/technoweenie/acts_as_paranoid) for Rails4 and 3. implemented a function that other gems are not enough.
+
+The usage of the Kakurenbo is very very very simple. Only add `deleted_at`(datetime) to column.
+Of course you can use `acts_as_paranoid`.In addition, Kakurenbo has many advantageous.
+
+
+# Installation
+
+
+```ruby
+gem 'kakurenbo'
+```
+
+# Usage
+You need only to add 'deleted_at' to model.
+
+```shell
+rails generate migration AddDeletedAtToModels deleted_at:datetime
+```
+The model having deleted_at becomes able to soft-delete automatically.
+
+_Kakurenbo provides `acts_as_paranoid` method for compatibility._
+
+
+## Basic Example
+
+### soft-delete
+
+``` ruby
+model.destroy
+```
+
+### restore a record
+
+``` ruby
+model.restore!
+
+# This is usable, too.
+Model.restore(id)
+```
+
+When restore, call restore callbacks.`before_restore` `after_restore`
+
+
+### hard-delete
+
+
+``` ruby
+model = Model.new
+model.destroy!
+```
+
+### check if a record is fotdeleted
+
+``` ruby
+model.destroyed?
+```
+
+### find with soft-deleted
+
+``` ruby
+Model.with_deleted
+```
+
+
+### find only the soft-deleted
+
+``` ruby
+Model.only_deleted
+```
+
+
+# License
+This gem is released under the MIT license.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/kakurenbo.gemspec

@@ -0,0 +1,42 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kakurenbo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kakurenbo"
+  spec.version       = Kakurenbo::VERSION
+  spec.authors       = ["alfa-jpn"]
+  spec.email         = ["a.nkmr.ja@gmail.com"]
+
+  spec.summary       = <<-EOF
+    provides soft delete.
+    Kakurenbo is a re-implementation of paranoia and acts_as_paranoid for Rails4 and 3.
+    implemented a function that other gems are not enough.
+  EOF
+
+  spec.description   = <<-EOF
+    provides soft delete.
+    Kakurenbo is a re-implementation of paranoia and acts_as_paranoid for Rails4 and 3.
+    implemented a function that other gems are not enough.
+
+    The usage of the Kakurenbo is very very very simple. Only add `deleted_at`(datetime) to column.
+    Of course you can use `acts_as_paranoid`.In addition, Kakurenbo has many advantageous.
+  EOF
+
+  spec.homepage      = "https://github.com/alfa-jpn/kakurenbo"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "sqlite3"
+
+  spec.add_dependency 'activerecord', '>= 3.2.0'
+end

data/lib/kakurenbo.rb

@@ -0,0 +1,11 @@
+# require need modules.
+require "active_support"
+require "active_record"
+
+# require kakurenbo modules.
+require "kakurenbo/version"
+require "kakurenbo/mixin_ar_base"
+require "kakurenbo/soft_delete_core"
+
+# Kakurenbo Mixin to ActiveRecord::Base.
+ActiveRecord::Base.send :include, Kakurenbo::MixinARBase

data/lib/kakurenbo/mixin_ar_base.rb

@@ -0,0 +1,51 @@
+module Kakurenbo
+  module MixinARBase
+    # Extend ClassMethods after include.
+    def self.included(base_class)
+      base_class.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Initialize Kakurenbo in child class.
+      def inherited(child_class)
+        child_class.instance_eval {
+          next unless column_names.include?('deleted_at')
+          remodel_as_soft_delete
+        }
+        super
+      end
+
+      # Remodel Model as soft-delete.
+      #
+      # @options [Hash] option
+      #   default: {
+      #     :column => :deleted_at
+      #   }
+      def remodel_as_soft_delete(options = {})
+        options.reverse_merge!(
+          :column => :deleted_at
+        )
+
+        unless paranoid?
+          alias_method :delete!,  :delete
+          alias_method :destroy!, :destroy
+
+          class_attribute :kakurenbo_column
+          self.kakurenbo_column = options[:column]
+
+          include Kakurenbo::SoftDeleteCore
+        end
+      end
+      alias_method :acts_as_paranoid, :remodel_as_soft_delete
+
+      # Will be override this method, if class is soft_delete.
+      def paranoid?
+        false
+      end
+    end
+
+    def paranoid?
+      self.class.paranoid?
+    end
+  end
+end

data/lib/kakurenbo/soft_delete_core.rb

@@ -0,0 +1,129 @@
+module Kakurenbo
+  module SoftDeleteCore
+    # Extend ClassMethods after include.
+    def self.included(base_class)
+      base_class.extend ClassMethods
+      base_class.extend Callbacks
+      base_class.extend Scopes
+    end
+
+    module ClassMethods
+      def paranoid?
+        true
+      end
+
+      # Restore models.
+      #
+      # @param id      [Array or Integer] id or ids.
+      # @param options [Hash] options(same restore of instance methods.)
+      def restore(id, options = {})
+        only_deleted.where(:id => id).each{|m| m.restore!(options)}
+      end
+    end
+
+    module Callbacks
+      def self.extended(base_class)
+        # Regist callbacks.
+        [:before, :around, :after].each do |on|
+          base_class.define_singleton_method("#{on}_restore") do |*args, &block|
+            set_callback(:restore, on, *args, &block)
+          end
+        end
+        base_class.define_callbacks :restore
+      end
+    end
+
+    module Scopes
+      def self.extended(base_class)
+        base_class.instance_eval {
+          scope :only_deleted,    ->{ with_deleted.where.not( kakurenbo_column => nil ) }
+          scope :with_deleted,    ->{ all.tap{ |s| s.default_scoped = false } }
+          scope :without_deleted, ->{ where(kakurenbo_column => nil) }
+
+          default_scope ->{ without_deleted }
+        }
+      end
+    end
+
+    def delete
+      return if new_record? or destroyed?
+      update_column kakurenbo_column, current_time_from_proper_timezone
+    end
+
+    def destroy
+      return if destroyed?
+      with_transaction_returning_status {
+        destroy_at = current_time_from_proper_timezone
+        run_callbacks(:destroy){ update_column kakurenbo_column, destroy_at }
+      }
+    end
+
+    def destroyed?
+      !send(kakurenbo_column).nil?
+    end
+    alias_method :deleted?, :destroyed?
+
+    def kakurenbo_column
+      self.class.kakurenbo_column
+    end
+
+    def persisted?
+      !new_record?
+    end
+
+    # restore record.
+    #
+    # @param options [Hash] options.
+    #   defaults: {
+    #     recursive: true
+    #   }
+    def restore!(options = {})
+      options.reverse_merge!(
+        :recursive => true
+      )
+
+      with_transaction_returning_status {
+        run_callbacks(:restore) do
+          parent_deleted_at = send(kakurenbo_column)
+          update_column kakurenbo_column, nil
+          restore_associated_records(parent_deleted_at) if options[:recursive]
+        end
+      }
+    end
+    alias_method :restore, :restore!
+
+    private
+    # Calls the given block once for each dependent destroy records.
+    # @note Only call the class of paranoid.
+    #
+    # @param &block [Proc{|record|.. }] execute block.
+    def each_dependent_destroy_records(&block)
+      self.class.reflect_on_all_associations.each do |association|
+        next unless association.options[:dependent] == :destroy
+        next unless association.klass.paranoid?
+
+        resource = send(association.name)
+        next if resource.nil?
+
+        if association.collection?
+          resource = resource.only_deleted
+        else
+          resource = (resource.destroyed?) ? [resource] : []
+        end
+
+        resource.each &block
+      end
+    end
+
+    # Restore associated records.
+    # @note Not restore if deleted_at older than parent_deleted_at.
+    #
+    # @param parent_deleted_at [Time] The time when parent was deleted.
+    def restore_associated_records(parent_deleted_at)
+      each_dependent_destroy_records do |record|
+        next unless parent_deleted_at <= record.send(kakurenbo_column)
+        record.restore!
+      end
+    end
+  end
+end

data/lib/kakurenbo/version.rb

@@ -0,0 +1,3 @@
+module Kakurenbo
+  VERSION = "0.1.0"
+end

data/spec/kakurenbo/mixin_ar_base_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Kakurenbo::MixinARBase do
+  create_temp_table(:hard_deletes) {}
+  create_temp_table(:soft_deletes) {|t| t.datetime :deleted_at}
+  create_temp_table(:other_columns){|t| t.datetime :destroyed_at}
+
+  context 'when mixin ActiveRecord::Base' do
+    it 'has paranoid? in class methods.'do
+      expect(ActiveRecord::Base.methods).to include(:paranoid?)
+    end
+
+    it 'has paranoid? in instance methods.' do
+      expect(ActiveRecord::Base.instance_methods).to include(:paranoid?)
+    end
+
+    it 'has acts_as_paranoid in class methods.' do
+      expect(ActiveRecord::Base.methods).to include(:acts_as_paranoid)
+    end
+  end
+
+  context 'when define class of HardDelete' do
+    before :all do
+      class HardDelete < ActiveRecord::Base; end
+    end
+
+    it 'paranoid? return false.' do
+      expect(HardDelete.paranoid?).to be_false
+    end
+  end
+
+  context 'when define class of SoftDelete' do
+    before :all do
+      class SoftDelete < ActiveRecord::Base; end
+    end
+
+    it 'paranoid? return true.' do
+      expect(SoftDelete.paranoid?).to be_true
+    end
+  end
+
+  context 'when define class of OtherColumn' do
+    before :all do
+      class OtherColumn < ActiveRecord::Base
+        acts_as_paranoid :column => :destroyed_at
+      end
+    end
+
+    it 'paranoid? return true.' do
+      expect(OtherColumn.paranoid?).to be_true
+    end
+
+    it 'kakurenbo_column is `:destroyed_at`.' do
+      expect(OtherColumn.kakurenbo_column).to eq(:destroyed_at)
+    end
+  end
+end

data/spec/kakurenbo/soft_delete_core_spec.rb

@@ -0,0 +1,420 @@
+require 'spec_helper'
+
+describe Kakurenbo::MixinARBase do
+  create_temp_table(:paranoid_models){ |t| t.datetime :deleted_at }
+
+  create_temp_table(:parent_models)                { |t| t.integer :child_id; t.datetime :deleted_at }
+  create_temp_table(:normal_child_models)          { |t| t.integer :parent_model_id }
+  create_temp_table(:paranoid_child_models)        { |t| t.integer :parent_model_id; t.datetime :deleted_at }
+  create_temp_table(:paranoid_single_child_models) { |t| t.integer :parent_model_id; t.datetime :deleted_at }
+
+  context 'when define ParanoidModel' do
+    before :each do
+      class ParanoidModel < ActiveRecord::Base; end
+    end
+
+    after :each do
+      Object.class_eval{ remove_const :ParanoidModel }
+    end
+
+    describe 'Callbacks' do
+      before :each do
+        @callback_model = ParanoidModel.create!
+      end
+
+      it 'before_restore.' do
+        ParanoidModel.before_restore :before_restore_callback
+        @callback_model.should_receive(:before_restore_callback).once
+        @callback_model.run_callbacks(:restore)
+      end
+
+      it 'around_restore.' do
+        ParanoidModel.around_restore :around_restore_callback
+        @callback_model.should_receive(:around_restore_callback).once
+        @callback_model.run_callbacks(:restore)
+      end
+
+      it 'after_restore.' do
+        ParanoidModel.after_restore :after_restore_callback
+        @callback_model.should_receive(:after_restore_callback).once
+        @callback_model.run_callbacks(:restore)
+      end
+    end
+
+
+    describe 'Scopes' do
+      before :each do
+        @normal_model  = ParanoidModel.create!
+        @deleted_model = ParanoidModel.create!(deleted_at: Time.now)
+      end
+
+      context 'when use default_scope' do
+        it 'show normal model.' do
+          expect(ParanoidModel.find_by(id: @normal_model.id)).not_to be_nil
+        end
+
+        it 'hide deleted model.' do
+          expect(ParanoidModel.find_by(id: @deleted_model.id)).to be_nil
+        end
+      end
+
+      context 'when use only_deleted' do
+        it 'show normal model.' do
+          expect(ParanoidModel.only_deleted.find_by(id: @normal_model.id)).to be_nil
+        end
+
+        it 'show deleted model.' do
+          expect(ParanoidModel.only_deleted.find_by(@deleted_model.id)).not_to be_nil
+        end
+      end
+
+      context 'when use with_deleted' do
+        it 'show normal model.' do
+          expect(ParanoidModel.with_deleted.find_by(id: @normal_model.id)).not_to be_nil
+        end
+
+        it 'show deleted model.' do
+          expect(ParanoidModel.with_deleted.find_by(@deleted_model.id)).not_to be_nil
+        end
+      end
+
+      context 'when use without_deleted' do
+        it 'show normal model.' do
+          expect(ParanoidModel.without_deleted.find_by(id: @normal_model.id)).not_to be_nil
+        end
+
+        it 'hide deleted model.' do
+          expect(ParanoidModel.without_deleted.find_by(id: @deleted_model.id)).to be_nil
+        end
+      end
+    end
+
+
+    describe 'Core' do
+      before :each do
+        @model = ParanoidModel.create!
+      end
+
+      context 'when delete' do
+        it 'soft-delete model.' do
+          expect{
+            @model.delete
+          }.to change(ParanoidModel, :count).by(-1)
+        end
+
+        it 'not hard-delete model.' do
+          expect{
+            @model.delete
+          }.to change{
+            ParanoidModel.all.with_deleted.count
+          }.by(0)
+        end
+
+        it 'call callbacks nothing.' do
+          ParanoidModel.before_destroy :before_destroy_callback
+          ParanoidModel.after_destroy  :after_destroy_callback
+          ParanoidModel.after_commit   :after_commit_callback
+
+          @model.should_receive(:before_destroy_callback).exactly(0).times
+          @model.should_receive(:after_destroy_callback).exactly(0).times
+          @model.should_receive(:after_commit_callback).exactly(0).times
+
+          @model.delete
+        end
+
+        it 'not call callbacks other.' do
+          ParanoidModel.before_update :before_update_callback
+          ParanoidModel.before_save   :before_save_callback
+          ParanoidModel.validate      :validate_callback
+
+          @model.should_receive(:before_update_callback).exactly(0).times
+          @model.should_receive(:before_save_callback).exactly(0).times
+          @model.should_receive(:validate_callback).exactly(0).times
+
+          @model.delete
+        end
+      end
+
+      context 'when delete!' do
+        it 'hard-delete model.' do
+          expect{
+            @model.delete!
+          }.to change{
+            ParanoidModel.all.with_deleted.count
+          }.by(-1)
+        end
+      end
+
+      context 'when destroy' do
+        it 'soft-delete model.' do
+          expect{
+            @model.destroy
+          }.to change(ParanoidModel, :count).by(-1)
+        end
+
+        it 'not hard-delete model.' do
+          expect{
+            @model.destroy
+          }.to change{
+            ParanoidModel.all.with_deleted.count
+          }.by(0)
+        end
+
+        it 'call callbacks of destroy.' do
+          ParanoidModel.before_destroy :before_destroy_callback
+          ParanoidModel.after_destroy  :after_destroy_callback
+          ParanoidModel.after_commit   :after_commit_callback
+
+          @model.should_receive(:before_destroy_callback).once
+          @model.should_receive(:after_destroy_callback).once
+          @model.should_receive(:after_commit_callback).once.and_return(true)
+
+          @model.destroy
+        end
+
+        it 'not call callbacks without destroy.' do
+          ParanoidModel.before_update :before_update_callback
+          ParanoidModel.before_save   :before_save_callback
+          ParanoidModel.validate      :validate_callback
+
+          @model.should_receive(:before_update_callback).exactly(0).times
+          @model.should_receive(:before_save_callback).exactly(0).times
+          @model.should_receive(:validate_callback).exactly(0).times
+
+          @model.destroy
+        end
+      end
+
+      context 'when destroy!' do
+        it 'hard-delete model.' do
+          expect{
+            @model.destroy!
+          }.to change{
+            ParanoidModel.all.with_deleted.count
+          }.by(-1)
+        end
+      end
+
+      context 'when destroyed?' do
+        it 'false if model not destroyed.' do
+          expect(@model.destroyed?).to be_false
+        end
+
+        it 'false if model destroyed.' do
+          @model.destroy
+          expect(@model.destroyed?).to be_true
+        end
+
+        it 'alias_method deleted? to destroyed?' do
+          expect(@model.deleted?).to be_false
+        end
+      end
+
+      context 'when restore.(class method)' do
+        before :each do
+          @model.destroy
+        end
+
+        it 'with id restore of instance method.' do
+          expect{
+            ParanoidModel.restore(@model.id)
+          }.to change(ParanoidModel, :count).by(1)
+
+          expect(@model.reload.destroyed?).to be_false
+        end
+
+        it 'with ids restore of instance method.' do
+          @model2 = ParanoidModel.create!
+          @model2.destroy
+
+          expect{
+            ParanoidModel.restore([@model.id, @model2.id])
+          }.to change(ParanoidModel, :count).by(2)
+
+          expect(@model.reload.destroyed?).to be_false
+          expect(@model2.reload.destroyed?).to be_false
+        end
+      end
+
+      context 'when restore.(instance method)' do
+        before :each do
+          @model.destroy
+        end
+
+        it 'restore model' do
+          expect{
+            @model.restore!
+          }.to change(ParanoidModel, :count).by(1)
+
+          expect(@model.reload.destroyed?).to be_false
+        end
+
+        it 'call callbacks of restore.' do
+          ParanoidModel.before_restore :before_restore_callback
+          ParanoidModel.after_restore  :after_restore_callback
+          ParanoidModel.after_commit   :after_commit_callback
+
+          @model.should_receive(:before_restore_callback).once
+          @model.should_receive(:after_restore_callback).once
+          @model.should_receive(:after_commit_callback).once.and_return(true)
+
+          @model.restore!
+        end
+
+        it 'not call callbacks without restore.' do
+          ParanoidModel.before_update :before_update_callback
+          ParanoidModel.before_save   :before_save_callback
+          ParanoidModel.validate      :validate_callback
+
+          @model.should_receive(:before_update_callback).exactly(0).times
+          @model.should_receive(:before_save_callback).exactly(0).times
+          @model.should_receive(:validate_callback).exactly(0).times
+
+          @model.restore!
+        end
+      end
+    end
+  end
+
+
+  context 'when define relation model' do
+    before :all do
+      class NormalChildModel  < ActiveRecord::Base; end
+      class ParanoidChildModel < ActiveRecord::Base; end
+      class ParanoidSingleChildModel < ActiveRecord::Base; end
+      class ParentModel < ActiveRecord::Base
+        has_many :normal_child_models,   :dependent => :destroy
+        has_many :paranoid_child_models, :dependent => :destroy
+
+        has_one     :paranoid_single_child_model, :dependent => :destroy
+        belongs_to  :child, :class_name => :ParanoidSingleChildModel, :dependent => :destroy
+      end
+    end
+
+    describe 'NormalChildModel' do
+      before :each do
+        @parent = ParentModel.create!
+        @first  = @parent.normal_child_models.create!
+        @second = @parent.normal_child_models.create!
+      end
+
+      context 'when parent was destroyed' do
+        it 'remove normal_child_models' do
+          expect{@parent.destroy}.to change(NormalChildModel, :count).by(-2)
+          expect(@first.destroyed?).to be_true
+          expect(@second.destroyed?).to be_true
+        end
+      end
+    end
+
+    describe 'ParanoidChildModel' do
+      before :each do
+        @parent = ParentModel.create!
+        @first  = @parent.paranoid_child_models.create!
+        @second = @parent.paranoid_child_models.create!
+        @third  = @parent.paranoid_child_models.create!
+      end
+
+      context 'when parent was destroyed' do
+        it 'remove normal_child_models' do
+          expect{@parent.destroy}.to change(ParanoidChildModel, :count).by(-3)
+          expect(@first.reload.destroyed?).to be_true
+          expect(@second.reload.destroyed?).to be_true
+          expect(@third.reload.destroyed?).to be_true
+        end
+
+        it 'restore with normal_child_models' do
+          @parent.destroy
+          expect{@parent.restore!}.to change(ParanoidChildModel, :count).by(3)
+          expect(@first.reload.destroyed?).to be_false
+          expect(@second.reload.destroyed?).to be_false
+          expect(@third.reload.destroyed?).to be_false
+        end
+
+        it 'not restore model that was deleted before parent was deleted.' do
+          # Delete before parent was deleted.
+          delete_at = 1.second.ago
+          Time.stub(:now).and_return(delete_at)
+          @first.destroy
+
+          # Delete after first_child was deleted.
+          Time.unstub(:now)
+          @parent.destroy
+
+          expect{@parent.restore!}.to change(ParanoidChildModel, :count).by(2)
+          expect(@first.reload.destroyed?).to be_true
+          expect(@second.reload.destroyed?).to be_false
+          expect(@third.reload.destroyed?).to be_false
+        end
+      end
+    end
+
+    describe 'ParanoidSingleChildModel' do
+      before :each do
+        @parent = ParentModel.create!
+        @first  = ParanoidSingleChildModel.create!(parent_model_id: @parent.id)
+      end
+
+      context 'when parent was destroyed' do
+        it 'remove normal_child_models' do
+          expect{@parent.destroy}.to change(ParanoidSingleChildModel, :count).by(-1)
+          expect(@first.reload.destroyed?).to be_true
+        end
+
+        it 'restore with normal_child_models' do
+          @parent.destroy
+          expect{@parent.restore!}.to change(ParanoidSingleChildModel, :count).by(1)
+          expect(@first.reload.destroyed?).to be_false
+        end
+
+        it 'not restore model that was deleted before parent was deleted.' do
+          # Delete before parent was deleted.
+          delete_at = 1.second.ago
+          Time.stub(:now).and_return(delete_at)
+          @first.destroy
+
+          # Delete after first_child was deleted.
+          Time.unstub(:now)
+          @parent.destroy
+
+          expect{@parent.restore!}.to change(ParanoidSingleChildModel, :count).by(0)
+          expect(@first.reload.destroyed?).to be_true
+        end
+      end
+    end
+
+    describe 'ParanoidSingleChildModel' do
+      before :each do
+        @first  = ParanoidSingleChildModel.create!
+        @parent = ParentModel.create!(child_id: @first.id)
+      end
+
+      context 'when parent was destroyed' do
+        it 'remove normal_child_models' do
+          expect{@parent.destroy}.to change(ParanoidSingleChildModel, :count).by(-1)
+          expect(@first.reload.destroyed?).to be_true
+        end
+
+        it 'restore with normal_child_models' do
+          @parent.destroy
+          expect{@parent.restore!}.to change(ParanoidSingleChildModel, :count).by(1)
+          expect(@first.reload.destroyed?).to be_false
+        end
+
+        it 'not restore model that was deleted before parent was deleted.' do
+          # Delete before parent was deleted.
+          delete_at = 1.second.ago
+          Time.stub(:now).and_return(delete_at)
+          @first.destroy
+
+          # Delete after first_child was deleted.
+          Time.unstub(:now)
+          @parent.destroy
+
+          expect{@parent.restore!}.to change(ParanoidSingleChildModel, :count).by(0)
+          expect(@first.reload.destroyed?).to be_true
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require "rubygems"
+require "bundler/setup"
+require "kakurenbo"
+
+RSpec.configure do |config|
+  config.mock_framework = :rspec
+  config.before(:all) {
+    Dir.mkdir('tmp') unless Dir.exists?('tmp')
+    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => 'tmp/rspec.sqlite')
+  }
+end
+
+# Create temp table for test.
+#
+# @param name   [Symbol]        Name of table.
+# @param &block [Proc{|t|...}]  Definition column block.
+def create_temp_table(name, &block)
+  raise 'No block given!' unless block_given?
+
+  before :all do
+    migration = ActiveRecord::Migration.new
+    migration.verbose = false
+    migration.create_table name, &block
+  end
+
+  after :all do
+    migration = ActiveRecord::Migration.new
+    migration.verbose = false
+    migration.drop_table name
+  end
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: kakurenbo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- alfa-jpn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  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: rspec
+  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: yard
+  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: sqlite3
+  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: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: |2
+      provides soft delete.
+      Kakurenbo is a re-implementation of paranoia and acts_as_paranoid for Rails4 and 3.
+      implemented a function that other gems are not enough.
+
+      The usage of the Kakurenbo is very very very simple. Only add `deleted_at`(datetime) to column.
+      Of course you can use `acts_as_paranoid`.In addition, Kakurenbo has many advantageous.
+email:
+- a.nkmr.ja@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- kakurenbo.gemspec
+- lib/kakurenbo.rb
+- lib/kakurenbo/mixin_ar_base.rb
+- lib/kakurenbo/soft_delete_core.rb
+- lib/kakurenbo/version.rb
+- spec/kakurenbo/mixin_ar_base_spec.rb
+- spec/kakurenbo/soft_delete_core_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/alfa-jpn/kakurenbo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: provides soft delete. Kakurenbo is a re-implementation of paranoia and acts_as_paranoid
+  for Rails4 and 3. implemented a function that other gems are not enough.
+test_files:
+- spec/kakurenbo/mixin_ar_base_spec.rb
+- spec/kakurenbo/soft_delete_core_spec.rb
+- spec/spec_helper.rb
+has_rdoc: