kakurenbo 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d17f226c87b76328e3f11a74e9224af2c25ec7d
-  data.tar.gz: 85ecc8c56e701cf1500416a969733c6bb098c1e6
+  metadata.gz: d0eed74f6f1f4ee3e648f8d23f196b017a3933a0
+  data.tar.gz: 9aba55b5f4d2191702e64feecfc348051fff0ad2
 SHA512:
-  metadata.gz: 28c44c302564b18f8930dac1a90553e83c8bbbf0a3186575eafce1898a75e8902a88c3f0d1a06f02d0064ab3a61e37e1ef6d7bbd1a9ee9bf32a57d3ba7c2f4fa
-  data.tar.gz: 44d3f77630f0872526c21d94761f81e98dbe5e52f43de9e3e7e97fec8ed09f1bc5d8a9b5bfc95096ceebc8b901ef36227316dbfc008d0497db8eb07db48b99f0
+  metadata.gz: dd0dc2d6abe2a70959bb5fdabcdf3b6970d24530208538c19af5e4d38f570f360a593a506f53ea867801f3bbb57a54ac005a45cdd711e973824888c4a2974e72
+  data.tar.gz: a0305a8d5be99ea68c939dbd8a3e279548b8cd39e87ee14fe6c1c017655e4e87a734695b19b6c890cf0efc4b5866a8ff45bf252cca1afb53500c5b63c10572ec

data/.travis.yml

@@ -6,6 +6,5 @@ rvm:
   - 1.9.3
   - 2.1.0
 env:
-  - RAILS=3.2.16
-  - RAILS=4.0.2
-  - RAILS=4.1.0
+  - ACTIVE_RECORD_VERSION='~> 4.0.2'
+  - ACTIVE_RECORD_VERSION='~> 4.1.0'

data/Gemfile

@@ -1,4 +1,8 @@
 source 'https://rubygems.org'
 
+if ENV['ACTIVE_RECORD_VERSION']
+  gem 'activerecord', ENV['ACTIVE_RECORD_VERSION']
+end
+
 # Specify your gem's dependencies in kakurenbo.gemspec
 gemspec

data/README.md

@@ -1,7 +1,7 @@
 # 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.
+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. 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.
@@ -30,38 +30,50 @@ _Kakurenbo provides `acts_as_paranoid` method for compatibility._
 ### soft-delete
 
 ``` ruby
+# if action is cancelled by callbacks, return false.
 model.destroy
 
-# This is usable, too.
-Model.destroy(id)
-Model.destroy([id1,id2,id3])
+# if action is cancelled by callbacks, raise ActiveRecord::RecordNotDestroyed.
+model.destroy!
+
+# selected model will be destroyed.
+Model.where(:foo => 'bar').destroy_all
 ```
 
 when want without callbacks.
 
 ``` ruby
 model.delete
+
+# selected model will be deleted.
+Model.where(:foo => 'bar').delete_all
 ```
 
 ### restore a record
 
 ``` ruby
-model.restore!
+# if action is cancelled by callbacks, return false.
+model.restore
 
-# This is usable, too.
-Model.restore(id)
-Model.restore([id1,id2,id3])
+# if action is cancelled by callbacks, raise ActiveRecord::RecordNotRestored.
+model.restore!
 ```
-
 When restore, call restore callbacks.`before_restore` `after_restore`
 
 
 ### hard-delete
+ Use hard option.
+``` ruby
+model.destroy(hard: true)
 
+# without callbacks.
+model.delete(hard: true)
 
-``` ruby
-model = Model.new
-model.destroy!
+# selected model will be destroyed.
+Model.where(:foo => 'bar').destroy_all(nil, hard: true)
+
+# selected model will be destroyed.
+Model.where(:foo => 'bar').delete_all(nil, hard: true)
 ```
 
 ### check if a record is fotdeleted

data/kakurenbo.gemspec

@@ -34,9 +34,9 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec", ">= 3.0.0"
   spec.add_development_dependency "yard"
   spec.add_development_dependency "sqlite3"
 
-  spec.add_dependency 'activerecord', '>= 3.2.0'
+  spec.add_dependency 'activerecord', '>= 4.0.2'
 end

data/lib/kakurenbo.rb

@@ -5,7 +5,14 @@ require "active_record"
 # require kakurenbo modules.
 require "kakurenbo/version"
 require "kakurenbo/mixin_ar_base"
-require "kakurenbo/soft_delete_core"
+require "kakurenbo/mixin_ar_relation"
+require "kakurenbo/core"
+
+# Kakurenbo Add ActiveRecord::RecordNotRestored to ActiveRecord
+class ActiveRecord::RecordNotRestored < ActiveRecord::RecordNotDestroyed; end
 
 # Kakurenbo Mixin to ActiveRecord::Base.
 ActiveRecord::Base.send :include, Kakurenbo::MixinARBase
+
+# Kakurenbo Mixin to ActiveRecord::Relation.
+ActiveRecord::Relation.send :include, Kakurenbo::MixinARRelation

data/lib/kakurenbo/{soft_delete_core.rb → core.rb}

@@ -1,5 +1,5 @@
 module Kakurenbo
-  module SoftDeleteCore
+  module Core
     # Extend ClassMethods after include.
     def self.included(base_class)
       base_class.extend ClassMethods
@@ -8,28 +8,13 @@ module Kakurenbo
       base_class.extend Aliases
     end
 
-    module ClassMethods
-      def paranoid?
-        true
-      end
-
-      # Destroy model(s).
-      #
-      # @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 = {:recursive => true})
-        transaction do
-          only_deleted.where(:id => id).each{|m| m.restore!(options)}
-        end
+    module Aliases
+      def self.extended(base_class)
+        base_class.instance_eval {
+          alias_method :deleted?, :destroyed?
+          alias_method :recover,  :restore
+          alias_method :recover!, :restore!
+        }
       end
     end
 
@@ -41,51 +26,76 @@ module Kakurenbo
             set_callback(:restore, on, *args, &block)
           end
         end
-        base_class.define_callbacks :restore
+        base_class.define_model_callbacks :restore
       end
     end
 
+    module ClassMethods
+      def paranoid?; true 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) }
+          if ActiveRecord::VERSION::STRING >= "4.1"
+            scope :with_deleted,  ->{ unscope :where => kakurenbo_column }
+          else
+            scope :with_deleted,  ->{ all.tap{ |s| s.default_scoped = false } }
+          end
 
           default_scope ->{ without_deleted }
         }
       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!
-        }
+    # delete record.
+    #
+    # @param options [Hash] options.
+    # @option options [Boolean] hard (false) if hard-delete.
+    def delete(options = {:hard => false})
+      if options[:hard]
+        self.class.delete(self.id, options)
+      else
+        return if new_record? or destroyed?
+        update_column kakurenbo_column, current_time_from_proper_timezone
       end
     end
 
-    def delete
-      return if new_record? or destroyed?
-      update_column kakurenbo_column, current_time_from_proper_timezone
+    # destroy record and run callbacks.
+    #
+    # @param options [Hash] options.
+    # @option options [Boolean] hard (false) if hard-delete.
+    #
+    # @return [Boolean, self] if action is cancelled, return false.
+    def destroy(options = {:hard => false})
+      if options[:hard]
+        with_transaction_returning_status do
+          hard_destroy_associated_records
+          self.reload.hard_destroy
+        end
+      else
+        return true if destroyed?
+        with_transaction_returning_status do
+          destroy_at = current_time_from_proper_timezone
+          run_callbacks(:destroy){ update_column kakurenbo_column, destroy_at; self }
+        end
+      end
     end
 
-    def destroy
-      return if destroyed?
-      with_transaction_returning_status do
-        destroy_at = current_time_from_proper_timezone
-        run_callbacks(:destroy){ update_column kakurenbo_column, destroy_at }
-      end
+    # destroy record and run callbacks.
+    #
+    # @param options [Hash] options.
+    # @option options [Boolean] hard (false) if hard-delete.
+    #
+    # @return [self] self.
+    def destroy!(options = {:hard => false})
+      destroy(options) || raise(ActiveRecord::RecordNotDestroyed)
     end
 
-    def destroy!
-      with_transaction_returning_status do
-        hard_destroy_associated_records
-        self.reload.hard_destroy!
-      end
+    def destroy_row
+      relation_for_destroy.delete_all(nil, :hard => true)
     end
 
     def destroyed?
@@ -103,19 +113,32 @@ module Kakurenbo
     # restore record.
     #
     # @param options [Hash] options.
-    #   defaults: {
-    #     recursive: true
-    #   }
-    def restore!(options = {:recursive => true})
+    # @option options [Boolean] recursive (true) if restore recursive.
+    #
+    # @return [Boolean, self] if action is cancelled, return false.
+    def restore(options = {:recursive => true})
+      return false unless destroyed?
+
       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]
+          update_column kakurenbo_column, nil
+          self
         end
       end
     end
 
+    # restore record.
+    #
+    # @param options [Hash] options.
+    # @option options [Boolean] hard (false) if hard-delete.
+    #
+    # @return [self] self.
+    def restore!(options = {:recursive => true})
+      restore(options) || raise(ActiveRecord::RecordNotRestored)
+    end
+
     private
     # get recoreds of association.
     #
@@ -148,7 +171,7 @@ module Kakurenbo
     # Hard-Destroy associated records.
     def hard_destroy_associated_records
       each_dependent_destroy_records do |record|
-        record.destroy!
+        record.destroy(hard: true)
       end
     end
 

data/lib/kakurenbo/mixin_ar_base.rb

@@ -6,31 +6,60 @@ module Kakurenbo
     end
 
     module ClassMethods
+      delegate :restore, :restore_all, {:to => :with_deleted}
+
       # Initialize Kakurenbo in child class.
       def inherited(child_class)
+        super
+
+        child_class.define_singleton_method :table_name= do |value|
+          super(value)
+          if has_kakurenbo_column?
+            remodel_as_soft_delete
+          else
+            remodel_as_original
+          end
+        end
+
         child_class.instance_eval do
           remodel_as_soft_delete if has_kakurenbo_column?
         end
-        super
+      end
+
+      # Remodel Model as normal.
+      # @note Restore to original model.
+      def remodel_as_original
+        if paranoid?
+          alias_method :delete,   :hard_delete
+          alias_method :destroy,  :hard_destroy
+          alias_method :destroy!, :hard_destroy!
+
+          singleton_class.send(:alias_method, :delete, :hard_delete)
+          singleton_class.send(:alias_method, :delete_all, :hard_delete_all)
+
+          define_singleton_method(:paranoid?) { false }
+        end
       end
 
       # Remodel Model as soft-delete.
       #
-      # @options [Hash] option
-      #   default: {
-      #     :column => :deleted_at
-      #   }
+      # @params option [Hash] option.
+      # @option option [Symbol] column column of kakurenbo.
       def remodel_as_soft_delete(options = {})
         options.reverse_merge!(
           :column => :deleted_at
         )
 
         unless paranoid?
-          alias_method :hard_delete!,  :delete
-          alias_method :hard_destroy!, :destroy
+          alias_method :hard_delete,   :delete
+          alias_method :hard_destroy,  :destroy
+          alias_method :hard_destroy!, :destroy!
+
+          singleton_class.send(:alias_method, :hard_delete, :delete)
+          singleton_class.send(:alias_method, :hard_delete_all, :delete_all)
 
           class_attribute :kakurenbo_column
-          include Kakurenbo::SoftDeleteCore
+          include Kakurenbo::Core
         end
 
         self.kakurenbo_column = options[:column]
@@ -42,19 +71,13 @@ module Kakurenbo
         false
       end
 
-      # When set table name, remodel.
-      def table_name=(value)
-        super
-        remodel_as_soft_delete if has_kakurenbo_column?
-      end
-
       private
       # Check if Model has kakurenbo_column.
       #
       # @return [Boolean] result.
       def has_kakurenbo_column?
         begin
-          column_names.include?('deleted_at')
+          table_exists? and column_names.include?('deleted_at')
         rescue
           false
         end

data/lib/kakurenbo/mixin_ar_relation.rb

@@ -0,0 +1,82 @@
+module Kakurenbo
+  module MixinARRelation
+    # Extend ClassMethods after include.
+    def self.included(base_class)
+      base_class.class_eval do
+        alias_method :hard_delete_all, :delete_all
+
+        # delete selected id or ids.
+        #
+        # @param id      [Integer, Array<Integer>] ID or IDs.
+        # @param options [Hash]                    options.
+        # @option options [Boolean] hard (false) if hard-delete.
+        def delete(id, options = {:hard => false})
+          delete_all({:id => id}, options)
+        end
+
+        # delete all record.
+        #
+        # @param conditions [Object] conditions.
+        # @param options    [Hash] options.
+        # @option options [Boolean] hard (false) if hard-delete.
+        def delete_all(conditions = nil, options = {:hard => false})
+          return hard_delete_all(conditions) unless klass.paranoid?
+
+          if conditions
+            where(conditions).delete_all(nil, options)
+          else
+            if options[:hard]
+              hard_delete_all
+            else
+              update_all({ klass.kakurenbo_column => Time.now })
+            end
+          end
+        end
+
+        # destroy selected id or ids.
+        #
+        # @param id      [Integer, Array<Integer>] ID or IDs.
+        # @param options [Hash]                    options.
+        # @option options [Boolean] hard (false) if hard-delete.
+        def destroy(id,  options = {:hard => false})
+          destroy_all({:id => id}, options)
+        end
+
+        # destroy all record.
+        #
+        # @param conditions [Object] conditions.
+        # @param options    [Hash]   options.
+        # @option options [Boolean] hard (false) if hard-delete.
+        def destroy_all(conditions = nil, options = {:hard => false})
+          if conditions
+            where(conditions).destroy_all(nil, options)
+          else
+            to_a.each {|object| object.destroy(options) }.tap { reset }
+          end
+        end
+
+        # restore selected id or ids.
+        #
+        # @param id      [Integer, Array<Integer>] ID or IDs.
+        # @param options [Hash]                    options.
+        # @option options [Boolean] recursive (true) if restore recursive.
+        def restore(id, options = {:recursive => true})
+          restore_all({:id => id}, options)
+        end
+
+        # restore all record.
+        #
+        # @param conditions [Object] conditions.
+        # @param options    [Hash]   options.
+        # @option options [Boolean] recursive (true) if restore recursive.
+        def restore_all(conditions = nil, options = {:recursive => true})
+          if conditions
+            where(conditions).restore_all(nil, options)
+          else
+            to_a.each {|object| object.restore(options) }.tap { reset }
+          end
+        end
+      end
+    end
+  end
+end