kakurenbo 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 346d73c09028575300edf7ae7d3f5e3e67eb4a26
-  data.tar.gz: 29a988182dbcf85583edbe4ce740d15bc736c0ac
+  metadata.gz: 1db2fcbe670f950ac46f450c5365921042ec298b
+  data.tar.gz: b52de24c10f252966d25f629b86679142fcb0024
 SHA512:
-  metadata.gz: bb22422cb2a04879d74e6387b2ac481678813e7f621a37961b35a452d434194f123fa4c64a748bd22de44a18543c04d11a035891dfdb243228e1e156612163f8
-  data.tar.gz: f6013d0b2a5373f3df8c17b5cd3d9783fd003fe1bde2162b3c04ebe3d45acf86815e28be39ac9b722307f6257f4624cb524d35297cb1001c749630914e0b0e0b
+  metadata.gz: ad49f6368d5bd864abbe3847ceeae2db12f0df1a55977fc3de36b94758ea6ce561be9e60504e4218f40afaba2c29b174cc1122fc71bc8c7f936fa716e664fbec
+  data.tar.gz: 7f198fd7fb0ab7a0cd41e17ffcffe8f2c3e8464759d0db95cc7334c79202765f57195afdbd628bb8a1a3311f8021e3122d69e0b89b895db26121b97498933575

data/README.md

@@ -31,6 +31,16 @@ _Kakurenbo provides `acts_as_paranoid` method for compatibility._
 
 ``` ruby
 model.destroy
+
+# This is usable, too.
+Model.destroy(id)
+Model.destroy([id1,id2,id3])
+```
+
+when want without callbacks.
+
+``` ruby
+model.delete
 ```
 
 ### restore a record
@@ -40,6 +50,7 @@ model.restore!
 
 # This is usable, too.
 Model.restore(id)
+Model.restore([id1,id2,id3])
 ```
 
 When restore, call restore callbacks.`before_restore` `after_restore`

data/lib/kakurenbo/mixin_ar_base.rb

@@ -13,7 +13,7 @@ module Kakurenbo
             next unless column_names.include?('deleted_at')
             remodel_as_soft_delete
           rescue
-            # When migrate.
+            # When exec first db:migrate and db:migrate:reset.
           end
         }
         super
@@ -31,8 +31,8 @@ module Kakurenbo
         )
 
         unless paranoid?
-          alias_method :delete!,  :delete
-          alias_method :destroy!, :destroy
+          alias_method :hard_delete!,  :delete
+          alias_method :hard_destroy!, :destroy
 
           class_attribute :kakurenbo_column
           self.kakurenbo_column = options[:column]

data/lib/kakurenbo/soft_delete_core.rb

@@ -5,6 +5,7 @@ module Kakurenbo
       base_class.extend ClassMethods
       base_class.extend Callbacks
       base_class.extend Scopes
+      base_class.extend Aliases
     end
 
     module ClassMethods
@@ -12,12 +13,23 @@ module Kakurenbo
         true
       end
 
-      # Restore models.
+      # Destroy model(s).
       #
-      # @param id      [Array or Integer] id or ids.
+      # @param id [Array<Integer> or Integer] id or ids
+      def destroy(id)
+        transaction do
+          where(:id => id).each{|m| m.destroy}
+        end
+      end
+
+      # Restore model(s).
+      #
+      # @param id      [Array<Integer> 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)}
+      def restore(id, options = {:recursive => true})
+        transaction do
+          only_deleted.where(:id => id).each{|m| m.restore!(options)}
+        end
       end
     end
 
@@ -45,6 +57,17 @@ module Kakurenbo
       end
     end
 
+    module Aliases
+      def self.extended(base_class)
+        base_class.instance_eval {
+          alias_method :delete!,  :hard_delete!
+          alias_method :deleted?, :destroyed?
+          alias_method :restore,  :restore!
+          alias_method :recover,  :restore!
+        }
+      end
+    end
+
     def delete
       return if new_record? or destroyed?
       update_column kakurenbo_column, current_time_from_proper_timezone
@@ -52,16 +75,22 @@ module Kakurenbo
 
     def destroy
       return if destroyed?
-      with_transaction_returning_status {
+      with_transaction_returning_status do
         destroy_at = current_time_from_proper_timezone
         run_callbacks(:destroy){ update_column kakurenbo_column, destroy_at }
-      }
+      end
+    end
+
+    def destroy!
+      with_transaction_returning_status do
+        hard_destroy_associated_records
+        self.reload.hard_destroy!
+      end
     end
 
     def destroyed?
       !send(kakurenbo_column).nil?
     end
-    alias_method :deleted?, :destroyed?
 
     def kakurenbo_column
       self.class.kakurenbo_column
@@ -77,22 +106,32 @@ module Kakurenbo
     #   defaults: {
     #     recursive: true
     #   }
-    def restore!(options = {})
-      options.reverse_merge!(
-        :recursive => true
-      )
-
-      with_transaction_returning_status {
+    def restore!(options = {:recursive => true})
+      with_transaction_returning_status do
         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
     end
-    alias_method :restore, :restore!
 
     private
+    # get recoreds of association.
+    #
+    # @param association [ActiveRecord::Associations] association.
+    # @return [Array or CollectionProxy] records.
+    def associated_records(association)
+      resource = send(association.name)
+      if resource.nil?
+        []
+      elsif association.collection?
+        resource.with_deleted
+      else
+        [resource]
+      end
+    end
+
     # Calls the given block once for each dependent destroy records.
     # @note Only call the class of paranoid.
     #
@@ -102,16 +141,14 @@ module Kakurenbo
         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
+        associated_records(association).each &block
+      end
+    end
 
-        resource.each &block
+    # Hard-Destroy associated records.
+    def hard_destroy_associated_records
+      each_dependent_destroy_records do |record|
+        record.destroy!
       end
     end
 
@@ -121,6 +158,7 @@ module Kakurenbo
     # @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 record.destroyed?
         next unless parent_deleted_at <= record.send(kakurenbo_column)
         record.restore!
       end

data/lib/kakurenbo/version.rb

@@ -1,3 +1,3 @@
 module Kakurenbo
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/spec/kakurenbo/soft_delete_cores/associations_spec.rb

@@ -0,0 +1,270 @@
+require 'spec_helper'
+
+describe Kakurenbo::SoftDeleteCore do
+  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 }
+
+  before :each 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
+
+  after :each do
+    Object.class_eval do
+      remove_const :NormalChildModel
+      remove_const :ParanoidChildModel
+      remove_const :ParanoidSingleChildModel
+      remove_const :ParentModel
+    end
+  end
+
+  describe 'NormalChildModel' do
+    before :each do
+      @parent = ParentModel.create!
+      @first  = @parent.normal_child_models.create!
+      @second = @parent.normal_child_models.create!
+
+      @hitori = NormalChildModel.create!
+    end
+
+    context 'when parent be destroyed' do
+      it 'destroy children who parent has.' do
+        expect{@parent.destroy}.to change(NormalChildModel, :count).by(-2)
+      end
+
+      it 'not destroy children who parent does not have.' do
+        @parent.destroy
+        expect(@hitori.reload.destroyed?).to be_false
+      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!
+
+      @hitori = ParanoidChildModel.create!
+    end
+
+    context 'when parent be destroyed' do
+      it 'destroy children who parent has.' 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 'not destroy children who parent does not have.' do
+        @parent.destroy
+        expect(@hitori.reload.destroyed?).to be_false
+      end
+    end
+
+    context 'when parent be restored' do
+      before :each do
+        @parent.destroy
+        @hitori.destroy
+      end
+
+      it 'restore children who parent has.' do
+        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 children who parent does not have.' do
+        @parent.restore!
+        expect(@hitori.reload.destroyed?).to be_true
+      end
+    end
+
+    context 'when delete child before parent was deleted' do
+      before :each do
+        # First, delete child.
+        delete_at = 1.second.ago
+        Time.stub(:now).and_return(delete_at)
+        @first.destroy
+
+        # Next, delete parent.
+        Time.unstub(:now)
+        @parent.destroy
+      end
+
+      it 'not restore child who deleted before parent was deleted' do
+        expect{@parent.restore!}.to change(ParanoidChildModel, :count).by(2)
+        expect(@first.reload.destroyed?).to be_true
+      end
+
+      it 'restore children who deleted after parent was deleted' do
+        expect{@parent.restore!}.to change(ParanoidChildModel, :count).by(2)
+        expect(@second.reload.destroyed?).to be_false
+        expect(@third.reload.destroyed?).to be_false
+      end
+    end
+  end
+
+  describe 'ParanoidSingleChildModel(has_one)' do
+    before :each do
+      @parent = ParentModel.create!
+      @first  = ParanoidSingleChildModel.create!(parent_model_id: @parent.id)
+
+      @hitori = ParanoidSingleChildModel.create!
+    end
+
+    context 'when parent be destroyed' do
+      it 'destroy child who parent has.' do
+        expect{@parent.destroy}.to change(ParanoidSingleChildModel, :count).by(-1)
+        expect(@first.reload.destroyed?).to be_true
+      end
+
+      it 'not destroy child who parent does not have.' do
+        @parent.destroy
+        expect(@hitori.reload.destroyed?).to be_false
+      end
+    end
+
+    context 'when parent be restored' do
+      before :each do
+        @parent.destroy
+        @hitori.destroy
+      end
+
+      it 'restore child who parent has.' do
+        expect{@parent.restore!}.to change(ParanoidSingleChildModel, :count).by(1)
+        expect(@first.reload.destroyed?).to be_false
+      end
+
+      it 'not restore child who parent does not have.' do
+        @parent.restore
+        expect(@hitori.reload.destroyed?).to be_true
+      end
+    end
+
+    context 'when delete child before parent was deleted' do
+      before :each do
+        # First, delete child.
+        delete_at = 1.second.ago
+        Time.stub(:now).and_return(delete_at)
+        @first.destroy
+
+        # Next, delete parent.
+        Time.unstub(:now)
+        @parent.destroy
+      end
+
+      it 'not restore child who deleted before parent was deleted' do
+        expect{@parent.restore!}.to change(ParanoidSingleChildModel, :count).by(0)
+        expect(@first.reload.destroyed?).to be_true
+      end
+    end
+  end
+
+  describe 'ParanoidSingleChildModel(belongs_to)' do
+    before :each do
+      @first  = ParanoidSingleChildModel.create!
+      @parent = ParentModel.create!(child_id: @first.id)
+
+      @hitori = ParanoidSingleChildModel.create!
+    end
+
+    context 'when parent be destroyed' do
+      it 'destroy child who parent has.' do
+        expect{@parent.destroy}.to change(ParanoidSingleChildModel, :count).by(-1)
+        expect(@first.reload.destroyed?).to be_true
+      end
+
+      it 'not destroy child who parent does not have.' do
+        @parent.destroy
+        expect(@hitori.reload.destroyed?).to be_false
+      end
+    end
+
+    context 'when parent be restored' do
+      before :each do
+        @parent.destroy
+        @hitori.destroy
+      end
+
+      it 'restore child who parent has.' do
+        expect{@parent.restore!}.to change(ParanoidSingleChildModel, :count).by(1)
+        expect(@first.reload.destroyed?).to be_false
+      end
+
+      it 'not restore child who parent does not have.' do
+        @parent.restore
+        expect(@hitori.reload.destroyed?).to be_true
+      end
+    end
+
+    context 'when delete child before parent was deleted' do
+      before :each do
+        # First, delete child.
+        delete_at = 1.second.ago
+        Time.stub(:now).and_return(delete_at)
+        @first.destroy
+
+        # Next, delete parent.
+        Time.unstub(:now)
+        @parent.destroy
+      end
+
+      it 'not restore child who deleted before parent was deleted' do
+        expect{@parent.restore!}.to change(ParanoidSingleChildModel, :count).by(0)
+        expect(@first.reload.destroyed?).to be_true
+      end
+    end
+  end
+
+  describe 'ChildModels' do
+    before :each do
+      @parent = ParentModel.create!
+
+      @normal_first    = @parent.normal_child_models.create!
+      @normal_second   = @parent.normal_child_models.create!
+
+      @paranoid_first  = @parent.paranoid_child_models.create!
+      @paranoid_second = @parent.paranoid_child_models.create!
+
+      @single_first    = ParanoidSingleChildModel.create!(parent_model_id: @parent.id)
+
+      @normal_hitori   = NormalChildModel.create!
+      @paranoid_hitori = ParanoidChildModel.create!
+      @single_hitori   = ParanoidSingleChildModel.create!
+    end
+
+    context 'when parent be hard-destroyed' do
+      it 'hard-destroy normal children who parent has.' do
+        expect{@parent.destroy!}.to change(NormalChildModel, :count).by(-2)
+      end
+
+      it 'hard-destroy paranoid children who parent has.' do
+        expect{@parent.destroy!}.to change{ParanoidChildModel.with_deleted.count}.by(-2)
+      end
+
+      it 'hard-destroy paranoid single child who parent has.' do
+        expect{@parent.destroy!}.to change{ParanoidSingleChildModel.with_deleted.count}.by(-1)
+      end
+
+      it 'not destroy child who parent does not have.' do
+        @parent.destroy!
+        expect(@normal_hitori.reload.destroyed?).to   be_false
+        expect(@paranoid_hitori.reload.destroyed?).to be_false
+        expect(@single_hitori.reload.destroyed?).to   be_false
+      end
+    end
+  end
+end

data/spec/kakurenbo/soft_delete_cores/callbacks_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Kakurenbo::SoftDeleteCore::Callbacks do
+  create_temp_table(:paranoid_models){ |t| t.datetime :deleted_at }
+
+  before :each do
+    class ParanoidModel < ActiveRecord::Base; end
+  end
+
+  after :each do
+    Object.class_eval{ remove_const :ParanoidModel }
+  end
+
+  context 'when run callback of restore' do
+    before :each do
+      @callback_model = ParanoidModel.create!
+    end
+
+    after :each do
+      @callback_model.run_callbacks(:restore)
+    end
+
+    it 'call before_restore.' do
+      ParanoidModel.before_restore :before_restore_callback
+      @callback_model.should_receive(:before_restore_callback).once
+    end
+
+    it 'call around_restore.' do
+      ParanoidModel.around_restore :around_restore_callback
+      @callback_model.should_receive(:around_restore_callback).once
+    end
+
+    it 'call after_restore.' do
+      ParanoidModel.after_restore :after_restore_callback
+      @callback_model.should_receive(:after_restore_callback).once
+    end
+  end
+end

data/spec/kakurenbo/soft_delete_cores/core_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe Kakurenbo::SoftDeleteCore do
+  create_temp_table(:paranoid_models){ |t| t.datetime :deleted_at }
+
+  before :each do
+    class ParanoidModel < ActiveRecord::Base; end
+  end
+
+  after :each do
+    Object.class_eval{ remove_const :ParanoidModel }
+  end
+
+  describe 'Instance of paranoid model' 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(class method)' do
+      before :each do
+        @model2 = ParanoidModel.create!
+      end
+
+      it 'with id, destroy model.' do
+        expect{
+          ParanoidModel.destroy(@model.id)
+        }.to change(ParanoidModel, :count).by(-1)
+
+        expect(@model.reload.destroyed?).to be_true
+      end
+
+      it 'with ids, destroy models.' do
+        expect{
+          ParanoidModel.destroy([@model.id, @model2.id])
+        }.to change(ParanoidModel, :count).by(-2)
+
+        expect(@model.reload.destroyed?).to be_true
+        expect(@model2.reload.destroyed?).to be_true
+      end
+    end
+
+    context 'when destroy(instance method)' 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 deleted? to destroyed?' do
+        expect(@model.deleted?).to be_false
+      end
+    end
+
+    context 'when restore(class method)' do
+      before :each do
+        @model.destroy
+
+        @model2 = ParanoidModel.create!
+        @model2.destroy
+      end
+
+      it 'with id, restore model.' do
+        expect{
+          ParanoidModel.restore(@model.id)
+        }.to change(ParanoidModel, :count).by(1)
+
+        expect(@model.reload.destroyed?).to be_false
+      end
+
+      it 'with ids, restore models.' do
+        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
+
+      it 'alias recover to restore!' do
+        expect{
+          @model.restore!
+        }.to change(ParanoidModel, :count).by(1)
+
+        expect(@model.reload.destroyed?).to be_false
+      end
+    end
+  end
+end

data/spec/kakurenbo/soft_delete_cores/scopes_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Kakurenbo::SoftDeleteCore::Scopes do
+  create_temp_table(:paranoid_models){ |t| t.datetime :deleted_at }
+
+  before :each do
+    class ParanoidModel < ActiveRecord::Base; end
+  end
+
+  after :each do
+    Object.class_eval{ remove_const :ParanoidModel }
+  end
+
+  context 'when call scope of' do
+    before :each do
+      @existing_model = ParanoidModel.create!
+      @deleted_model  = ParanoidModel.create!(deleted_at: Time.now)
+    end
+
+    context 'default_scope' do
+      it 'show existing model.' do
+        expect(ParanoidModel.find_by(id: @existing_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 'only_deleted' do
+      it 'hide existing model.' do
+        expect(ParanoidModel.only_deleted.find_by(id: @existing_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 'with_deleted' do
+      it 'show existing model.' do
+        expect(ParanoidModel.with_deleted.find_by(id: @existing_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 'without_deleted' do
+      it 'show existing model.' do
+        expect(ParanoidModel.without_deleted.find_by(id: @existing_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
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kakurenbo
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - alfa-jpn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-27 00:00:00.000000000 Z
+date: 2014-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -119,7 +119,10 @@ files:
 - 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/kakurenbo/soft_delete_cores/associations_spec.rb
+- spec/kakurenbo/soft_delete_cores/callbacks_spec.rb
+- spec/kakurenbo/soft_delete_cores/core_spec.rb
+- spec/kakurenbo/soft_delete_cores/scopes_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/alfa-jpn/kakurenbo
 licenses:
@@ -148,6 +151,9 @@ summary: provides soft delete. Kakurenbo is a re-implementation of paranoia and
   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/kakurenbo/soft_delete_cores/associations_spec.rb
+- spec/kakurenbo/soft_delete_cores/callbacks_spec.rb
+- spec/kakurenbo/soft_delete_cores/core_spec.rb
+- spec/kakurenbo/soft_delete_cores/scopes_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/spec/kakurenbo/soft_delete_core_spec.rb

@@ -1,420 +0,0 @@
-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