rails_soft_deletable 0.0.3 → 0.0.4

data/README.md

@@ -1,24 +1,24 @@
 # RailsSoftDeletable
 
-TODO: Write a gem description
+This gem provides soft delete behavior to ActiveRecord 3.2.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'rails_soft_deletable'
+    gem "rails_soft_deletable"
 
 And then execute:
 
     $ bundle
 
-Or install it yourself as:
-
-    $ gem install rails_soft_deletable
-
 ## Usage
 
-TODO: Write usage instructions here
+```ruby
+class Company < ActiveRecord::Base
+  soft_deletable
+end
+```
 
 ## Contributing
 

data/lib/rails_soft_deletable.rb

@@ -1,4 +1,5 @@
 require "rails_soft_deletable/version"
+require "active_record"
 
 module RailsSoftDeletable
   def self.included(base)
@@ -47,17 +48,34 @@ module RailsSoftDeletable
     end
   end
 
-  def destroy
-    if destroyed?
-      delete_or_soft_delete(true)
+  def deleted_at
+    val = super
+    if val.zero? || val.nil?
+      nil
+    else
+      Time.at(val).in_time_zone
+    end
+  end
+
+  def destroy(destroy_mode = :soft)
+    if destroy_mode == :hard
+      _original_destroy
     else
-      run_callbacks(:destroy) { delete_or_soft_delete(true) }
+      if destroyed?
+        delete_or_soft_delete(true)
+      else
+        run_callbacks(:destroy) { delete_or_soft_delete(true) }
+      end
     end
   end
 
-  def delete
-    return if new_record?
-    delete_or_soft_delete
+  def delete(delete_mode = :soft)
+    if delete_mode == :hard
+      _original_delete
+    else
+      return if new_record?
+      delete_or_soft_delete
+    end
   end
 
   def restore!
@@ -77,16 +95,25 @@ module RailsSoftDeletable
   alias :restore :restore!
 
   def destroyed?
-    value = send(soft_deletable_column)
-    value && value != 0
+    !!send(soft_deletable_column)
+  end
+
+  def persisted?
+    @_pretend_persistence || super
   end
-  alias :deleted? :destroyed?
 
   private
 
+  def _prepare_for_hard_delete(&block)
+    @_pretend_persistence = true
+    self.class.unscoped(&block)
+  ensure
+    @_pretend_persistence = false
+  end
+
   def delete_or_soft_delete(with_transaction = false)
     if destroyed?
-      self.class.unscoped { hard_delete! }
+      _prepare_for_hard_delete { _original_delete }
     else
       touch_soft_deletable_column(with_transaction)
     end
@@ -103,7 +130,7 @@ module RailsSoftDeletable
   def touch_column
     raise ActiveRecordError, "can not touch on a new record object" unless persisted?
 
-    current_time = current_time_from_proper_timezone.to_i
+    current_time = ("%0.6f" % current_time_from_proper_timezone).to_f
     changes = {}
 
     changes[soft_deletable_column.to_s] = write_attribute(soft_deletable_column.to_s, current_time)
@@ -117,9 +144,13 @@ module RailsSoftDeletable
 end
 
 class ActiveRecord::Base
-  def self.acts_as_soft_deletable(options={})
-    alias :hard_destroy! :destroy
-    alias :hard_delete! :delete
+  def self.soft_deletable(options={})
+    alias :_original_destroy :destroy
+    alias :_original_delete  :delete
+
+    private :_original_destroy
+    private :_original_delete
+
     include RailsSoftDeletable
     class_attribute :soft_deletable_column
 
@@ -135,13 +166,6 @@ class ActiveRecord::Base
     self.class.soft_deletable?
   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?
-    soft_deletable? ? !new_record? : super
-  end
-
   private
 
   def soft_deletable_column

data/lib/rails_soft_deletable/version.rb

@@ -1,3 +1,3 @@
 module RailsSoftDeletable
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/models.rb

@@ -0,0 +1,75 @@
+require "active_record"
+
+module Spec
+  module Models
+    module SoftDeletableCallbacks
+      def self.included(base)
+        base.class_eval do
+          attr_reader :before_destroy_called
+          attr_reader :around_destroy_called
+          attr_reader :after_destroy_called
+
+          attr_reader :before_restore_called
+          attr_reader :around_restore_called
+          attr_reader :after_restore_called
+
+          before_destroy :call_before_destroy
+          around_destroy :call_around_destroy
+          after_destroy  :call_after_destroy
+
+          before_restore :call_before_restore
+          around_restore :call_around_restore
+          after_restore  :call_after_restore
+
+          def call_before_destroy
+            @before_destroy_called = true
+          end
+
+          def call_around_destroy
+            yield
+            @around_destroy_called = true
+          end
+
+          def call_after_destroy
+            @after_destroy_called = true
+          end
+
+          def call_before_restore
+            @before_restore_called = true
+          end
+
+          def call_around_restore
+            yield
+            @around_restore_called = true
+          end
+
+          def call_after_restore
+            @after_restore_called = true
+          end
+
+          def reset_callback_flags!
+            @before_destroy_called = nil
+            @around_destroy_called = nil
+            @after_destroy_called  = nil
+
+            @before_restore_called = nil
+            @around_restore_called = nil
+            @after_restore_called  = nil
+          end
+        end
+      end
+    end
+  end
+end
+
+class DecimalModel< ActiveRecord::Base
+  soft_deletable
+
+  include Spec::Models::SoftDeletableCallbacks
+end
+
+class IntegerModel < ActiveRecord::Base
+  soft_deletable
+
+  include Spec::Models::SoftDeletableCallbacks
+end

data/spec/rails_soft_deletable_spec.rb

@@ -0,0 +1,253 @@
+require "spec_helper"
+
+describe RailsSoftDeletable do
+  let (:model) { IntegerModel.create! }
+  let (:decimal_model) { DecimalModel.create! }
+  let (:integer_model) { IntegerModel.create! }
+
+  context "#destroy" do
+    it "marks deleted_at column" do
+      Timecop.freeze(Time.now) do
+        decimal_model.destroy
+        integer_model.destroy
+
+        decimal_deleted_at = DecimalModel.connection.select_value("SELECT deleted_at FROM #{DecimalModel.quoted_table_name} WHERE #{DecimalModel.primary_key} = #{decimal_model.id}")
+        integer_deleted_at = IntegerModel.connection.select_value("SELECT deleted_at FROM #{IntegerModel.quoted_table_name} WHERE #{IntegerModel.primary_key} = #{integer_model.id}")
+
+        expect(decimal_deleted_at).to eq(("%0.6f" % Time.now.to_f).to_f)
+        expect(integer_deleted_at.to_i).to eq(Time.now.to_i)
+      end
+    end
+
+    it "soft deletes the record" do
+      Timecop.freeze(Time.now) do
+        decimal_model.destroy
+        integer_model.destroy
+
+        expect(decimal_model.deleted_at).to eq(Time.now)
+        expect(integer_model.deleted_at.to_i).to eq(Time.now.to_i)
+      end
+    end
+
+    it "does not mark the deleted_at attribute as changed" do
+      model.destroy
+
+      expect(model).to_not be_deleted_at_changed
+    end
+
+    it "marks the record as destroyed" do
+      model.destroy
+
+      expect(model).to be_destroyed
+    end
+
+    it "marks the record as not persisted" do
+      model.destroy
+
+      expect(model).to_not be_persisted
+    end
+
+    it "does not freeze the record" do
+      model.destroy
+
+      expect(decimal_model).to_not be_frozen
+    end
+
+    it "performs destroy callbacks" do
+      model.destroy
+
+      expect(model.before_destroy_called).to eq(true)
+      expect(model.around_destroy_called).to eq(true)
+      expect(model.after_destroy_called).to eq(true)
+    end
+
+    context "when record has already been soft deleted" do
+      before do
+        model.destroy
+        model.reset_callback_flags!
+      end
+
+      it "does not perform destroy callbacks" do
+        model.destroy
+
+        expect(model.before_destroy_called).to be_nil
+        expect(model.around_destroy_called).to be_nil
+        expect(model.after_destroy_called).to be_nil
+      end
+
+      it "hard deletes the record from the database" do
+        model.destroy
+
+        count = model.class.connection.select_value("SELECT COUNT(*) FROM #{model.class.quoted_table_name} WHERE #{model.class.primary_key} = #{model.id}")
+        expect(count).to eq(0)
+      end
+    end
+
+    context "with hard destroy mode" do
+      it "hard deletes the record from the database" do
+        model.destroy(:hard)
+
+        count = model.class.connection.select_value("SELECT COUNT(*) FROM #{model.class.quoted_table_name} WHERE #{model.class.primary_key} = #{model.id}")
+        expect(count).to eq(0)
+      end
+
+      it "performs destroy callbacks" do
+        model.destroy(:hard)
+
+        expect(model.before_destroy_called).to eq(true)
+        expect(model.around_destroy_called).to eq(true)
+        expect(model.after_destroy_called).to eq(true)
+      end
+    end
+  end
+
+  context "#delete" do
+    it "marks deleted_at column" do
+      Timecop.freeze(Time.now) do
+        decimal_model.delete
+        integer_model.delete
+
+        decimal_deleted_at = DecimalModel.connection.select_value("SELECT deleted_at FROM #{DecimalModel.quoted_table_name} WHERE #{DecimalModel.primary_key} = #{decimal_model.id}")
+        integer_deleted_at = IntegerModel.connection.select_value("SELECT deleted_at FROM #{IntegerModel.quoted_table_name} WHERE #{IntegerModel.primary_key} = #{integer_model.id}")
+
+        expect(decimal_deleted_at).to eq(("%0.6f" % Time.now.to_f).to_f)
+        expect(integer_deleted_at.to_i).to eq(Time.now.to_i)
+      end
+    end
+
+    it "soft deletes the record" do
+      Timecop.freeze(Time.now) do
+        decimal_model.delete
+        integer_model.delete
+
+        expect(decimal_model.deleted_at).to eq(Time.now)
+        expect(integer_model.deleted_at.to_i).to eq(Time.now.to_i)
+      end
+    end
+
+    it "does not mark the deleted_at attribute as changed" do
+      model.delete
+
+      expect(model).to_not be_deleted_at_changed
+    end
+
+    it "marks the record as destroyed" do
+      model.delete
+
+      expect(model).to be_destroyed
+    end
+
+    it "marks the record as not persisted" do
+      model.delete
+
+      expect(model).to_not be_persisted
+    end
+
+    it "does not freeze the record" do
+      model.delete
+
+      expect(decimal_model).to_not be_frozen
+    end
+
+    it "does not perform destroy callbacks" do
+      model.delete
+
+      expect(model.before_destroy_called).to be_nil
+      expect(model.around_destroy_called).to be_nil
+      expect(model.after_destroy_called).to be_nil
+    end
+
+    context "when record has already been soft deleted" do
+      before do
+        model.delete
+      end
+
+      it "does not perform destroy callbacks" do
+        model.delete
+
+        expect(model.before_destroy_called).to be_nil
+        expect(model.around_destroy_called).to be_nil
+        expect(model.after_destroy_called).to be_nil
+      end
+
+      it "hard deletes the record from the database" do
+        model.delete
+
+        count = model.class.connection.select_value("SELECT COUNT(*) FROM #{model.class.quoted_table_name} WHERE #{model.class.primary_key} = #{model.id}")
+        expect(count).to eq(0)
+      end
+    end
+
+    context "with hard delete mode" do
+      it "hard deletes the record from the database" do
+        model.delete(:hard)
+
+        count = model.class.connection.select_value("SELECT COUNT(*) FROM #{model.class.quoted_table_name} WHERE #{model.class.primary_key} = #{model.id}")
+        expect(count).to eq(0)
+      end
+
+      it "performs destroy callbacks" do
+        model.delete(:hard)
+
+        expect(model.before_destroy_called).to be_nil
+        expect(model.around_destroy_called).to be_nil
+        expect(model.after_destroy_called).to be_nil
+      end
+    end
+  end
+
+  context "#restore!" do
+    before do
+      model.destroy
+      model.reset_callback_flags!
+    end
+
+    it "restores the record" do
+      model.restore!
+
+      expect(model).to be_persisted
+      expect(model.deleted_at).to be_nil
+      expect(model).to_not be_deleted_at_changed
+      expect(model).to_not be_destroyed
+      expect(model).to_not be_new_record
+      expect(model).to_not be_frozen
+    end
+
+    it "resets deleted_at in the database" do
+      model.restore!
+
+      model_deleted_at = model.class.connection.select_value("SELECT deleted_at FROM #{model.class.quoted_table_name} WHERE #{model.class.primary_key} = #{model.id}")
+      expect(model_deleted_at).to eq(0)
+    end
+
+    it "performs restore callbacks" do
+      model.restore!
+
+      expect(model.before_restore_called).to eq(true)
+      expect(model.around_restore_called).to eq(true)
+      expect(model.after_restore_called).to eq(true)
+    end
+
+    it "returns true" do
+      expect(model.restore!).to eq(true)
+    end
+  end
+
+  context "#deleted_at" do
+    context "when record has not been soft deleted" do
+      it "returns nil" do
+        expect(model.deleted_at).to be_nil
+      end
+    end
+
+    context "when record has been soft deleted" do
+      before do
+        model.destroy
+      end
+
+      it "returns a Time object" do
+        expect(model.deleted_at).to be_kind_of(Time)
+      end
+    end
+  end
+end

data/spec/schema.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+ActiveRecord::Schema.define(version: Time.now.strftime("%Y%m%d%H%M%S")) do
+  create_table "decimal_models", force: true do |t|
+    t.decimal "deleted_at", default: 0
+  end
+
+  create_table "integer_models", force: true do |t|
+    t.integer "deleted_at", default: 0
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,15 @@
 require "pathname"
 ROOT_PATH = Pathname.new(__FILE__).join("../..").expand_path
-$LOAD_PATH.unshift(ROOT_PATH.join("lib"))
+$LOAD_PATH.unshift(ROOT_PATH.join("lib").to_s)
+
+require "rails_soft_deletable"
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[ROOT_PATH.join("spec/support/**/*.rb")].each { |f| require f }
+
+# Require all models.
+require "models"
 
 RSpec.configure do |config|
   # Run specs in random order to surface order dependencies. If you find an

data/spec/support/environment.rb

@@ -0,0 +1,27 @@
+require "active_record"
+
+module Spec
+  module Support
+    class Environment
+      DATABASE_FILE = ROOT_PATH.join("tmp/test.sqlite3")
+      SCHEMA_FILE   = ROOT_PATH.join("spec/schema.rb")
+
+      def self.setup
+        DATABASE_FILE.dirname.mkpath
+        DATABASE_FILE.delete if DATABASE_FILE.exist?
+
+        ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: DATABASE_FILE.to_s)
+
+        silence_stream(STDOUT) do
+          load(SCHEMA_FILE)
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    Spec::Support::Environment.setup
+  end
+end

data/spec/support/timecop.rb

@@ -0,0 +1,7 @@
+require "timecop"
+
+RSpec.configure do |config|
+  config.after do
+    Timecop.return
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_soft_deletable
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-21 00:00:00.000000000 Z
+date: 2013-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -92,6 +92,38 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Soft deletable for ActiveRecord on Rails 3+.
 email:
 - quan@listia.com
@@ -102,7 +134,12 @@ extra_rdoc_files: []
 files:
 - lib/rails_soft_deletable/version.rb
 - lib/rails_soft_deletable.rb
+- spec/models.rb
+- spec/rails_soft_deletable_spec.rb
+- spec/schema.rb
 - spec/spec_helper.rb
+- spec/support/environment.rb
+- spec/support/timecop.rb
 - LICENSE.txt
 - Rakefile
 - README.md
@@ -119,12 +156,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -741598862832616831
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -741598862832616831
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -132,4 +175,9 @@ signing_key:
 specification_version: 3
 summary: Soft deletable for ActiveRecord on Rails 3+
 test_files:
+- spec/models.rb
+- spec/rails_soft_deletable_spec.rb
+- spec/schema.rb
 - spec/spec_helper.rb
+- spec/support/environment.rb
+- spec/support/timecop.rb