soft_deletion 0.1.0

data/.travis.yml

@@ -0,0 +1,5 @@
+script: "bundle exec rake"
+rvm:
+  - ree
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,14 @@
+source :rubygems
+gemspec
+
+version = '2.3.14' # hardcoded for now...
+
+group :development do
+  gem 'activerecord', version
+  gem 'activesupport', version
+  gem 'rake'
+  gem 'shoulda'
+  gem 'mocha'
+  gem 'sqlite3'
+  gem 'mynyml-redgreen'
+end

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    soft_deletion (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activerecord (2.3.14)
+      activesupport (= 2.3.14)
+    activesupport (2.3.14)
+    mocha (0.9.12)
+    mynyml-redgreen (0.7.1)
+      term-ansicolor (>= 1.0.4)
+    rake (0.9.2)
+    shoulda (2.10.3)
+    sqlite3 (1.3.6)
+    term-ansicolor (1.0.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (= 2.3.14)
+  activesupport (= 2.3.14)
+  mocha
+  mynyml-redgreen
+  rake
+  shoulda
+  soft_deletion!
+  sqlite3

data/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler/gem_tasks'
+
+task :default do
+  sh "ruby -Itest test/soft_deletion_test.rb"
+end
+
+# extracted from https://github.com/grosser/project_template
+rule /^version:bump:.*/ do |t|
+  sh "git status | grep 'nothing to commit'" # ensure we are not dirty
+  index = ['major', 'minor','patch'].index(t.name.split(':').last)
+  file = 'lib/soft_deletion/version.rb'
+
+  version_file = File.read(file)
+  old_version, *version_parts = version_file.match(/(\d+)\.(\d+)\.(\d+)/).to_a
+  version_parts[index] = version_parts[index].to_i + 1
+  version_parts[2] = 0 if index < 2 # remove patch for minor
+  version_parts[1] = 0 if index < 1 # remove minor for major
+  new_version = version_parts * '.'
+  File.open(file,'w'){|f| f.write(version_file.sub(old_version, new_version)) }
+
+  sh "bundle && git add #{file} Gemfile.lock && git commit -m 'bump version to #{new_version}'"
+end

data/Readme.md

@@ -0,0 +1,48 @@
+Explicit soft deletion for ActiveRecord via deleted_at and default scope + callbacks.<br/>
+Not overwriting destroy or delete.
+
+Install
+=======
+    gem install soft_deletion
+Or
+
+    rails plugin install git://github.com/grosser/soft_deletion.git
+
+
+Usage
+=====
+    # mix into any model ...
+    class User < ActiveRecord::Base
+      include SoftDeletion
+      has_many :products
+    end
+
+    # soft delete them including all dependencies that are marked as :destroy, :delete_all, :nullify
+    user = User.first
+    user.products.count == 10
+    user.soft_delete!
+    user.deleted? # true
+
+    # use special with_deleted scope to find them ...
+    user.reload # ActiveRecord::RecordNotFound
+    User.with_deleted do
+      user.reload # there it is ...
+      user.products.count == 0
+    end
+
+    # soft undelete them all
+    user.soft_undelete!
+    user.products.count == 10
+
+TODO
+====
+ - Rails 3 from with inspiration from https://github.com/JackDanger/permanent_records/blob/master/lib/permanent_records.rb
+ - maybe stuff from https://github.com/smoku/soft_delete
+
+
+Author
+======
+[ZenDesk](http://zendesk.com)<br/>
+michael@grosser.it<br/>
+License: MIT<br/>
+[![Build Status](https://secure.travis-ci.org/grosser/soft_deletion.png)](http://travis-ci.org/grosser/soft_deletion)

data/lib/soft_deletion/dependency.rb

@@ -0,0 +1,56 @@
+module SoftDeletion
+  class Dependency
+    attr_reader :record, :association_name
+
+    def initialize(record, association_name)
+      @record = record
+      @association_name = association_name
+    end
+
+    def soft_delete!
+      return unless can_soft_delete?
+
+      if nullify?
+        nullify_dependencies
+      else
+        dependencies.each(&:soft_delete!)
+      end
+    end
+
+    def soft_undelete!
+      return unless can_soft_delete?
+
+      klass.with_deleted do
+        dependencies.each(&:soft_undelete!)
+      end
+    end
+
+    protected
+
+    def nullify?
+      association.options[:dependent] == :nullify
+    end
+
+    def nullify_dependencies
+      dependencies.each do |dependency|
+        dependency.update_attribute(association.primary_key_name, nil)
+      end
+    end
+
+    def can_soft_delete?
+      klass.instance_methods.map(&:to_sym).include?(:soft_delete!)
+    end
+
+    def klass
+      association.klass
+    end
+
+    def association
+      record.class.reflect_on_association(association_name.to_sym)
+    end
+
+    def dependencies
+      Array.wrap(record.send(association_name.to_sym))
+    end
+  end
+end

data/lib/soft_deletion/version.rb

@@ -0,0 +1,3 @@
+module SoftDeletion
+  VERSION = '0.1.0'
+end

data/lib/soft_deletion.rb

@@ -0,0 +1,67 @@
+require 'active_record'
+require 'soft_deletion/version'
+require 'soft_deletion/dependency'
+
+module SoftDeletion
+  def self.included(base)
+    unless base.ancestors.include?(ActiveRecord::Base)
+      raise "You can only include this if #{base} extends ActiveRecord::Base"
+    end
+    base.extend(ClassMethods)
+    base.send(:default_scope, :conditions => base.soft_delete_default_scope_conditions)
+    base.define_callbacks :after_soft_delete
+  end
+
+  module ClassMethods
+    def soft_delete_default_scope_conditions
+      {:deleted_at => nil}
+    end
+
+    def soft_delete_dependents
+      self.reflect_on_all_associations.
+        select { |a| [:destroy, :delete_all, :nullify].include?(a.options[:dependent]) }.
+        map(&:name)
+    end
+
+    def with_deleted
+      with_exclusive_scope do
+        yield self
+      end
+    end
+  end
+
+  def deleted?
+    deleted_at.present?
+  end
+
+  def mark_as_deleted
+    self.deleted_at = Time.now
+  end
+
+  def mark_as_undeleted
+    self.deleted_at = nil
+  end
+
+  def soft_delete!
+    self.class.transaction do
+      mark_as_deleted
+      soft_delete_dependencies.each(&:soft_delete!)
+      save!
+      run_callbacks(:after_soft_delete)
+    end
+  end
+
+  def soft_undelete!
+    self.class.transaction do
+      mark_as_undeleted
+      soft_delete_dependencies.each(&:soft_undelete!)
+      save!
+    end
+  end
+
+  protected
+
+  def soft_delete_dependencies
+    self.class.soft_delete_dependents.map { |dependent| Dependency.new(self, dependent) }
+  end
+end

data/soft_deletion.gemspec

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+name = "soft_deletion"
+require "#{name}/version"
+
+Gem::Specification.new name, SoftDeletion::VERSION do |s|
+  s.summary = "Explicit soft deletion for ActiveRecord via deleted_at and default scope."
+  s.authors = ["ZenDesk"]
+  s.email = "michael@grosser.it"
+  s.homepage = "http://github.com/grosser/#{name}"
+  s.files = `git ls-files`.split("\n")
+  s.license = 'MIT'
+end

data/test/soft_deletion_test.rb

@@ -0,0 +1,171 @@
+require 'soft_deletion'
+
+require 'active_support/test_case'
+require 'shoulda'
+require 'redgreen'
+
+# connect
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database => ":memory:"
+)
+
+# create tables
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :forums do |t|
+    t.integer :category_id
+    t.timestamp :deleted_at
+  end
+
+  create_table :categories do |t|
+    t.timestamp :deleted_at
+  end
+end
+
+# setup models
+class Forum < ActiveRecord::Base
+  include SoftDeletion
+  belongs_to :category
+end
+
+class Category < ActiveRecord::Base
+  include SoftDeletion
+  has_many :forums, :dependent => :destroy
+end
+
+class NoAssociationCategory < ActiveRecord::Base
+  include SoftDeletion
+  set_table_name 'categories'
+end
+
+# Independent association
+class IDACategory < ActiveRecord::Base
+  include SoftDeletion
+  set_table_name 'categories'
+  has_many :forums, :dependent => :destroy, :foreign_key => :category_id
+end
+
+# Nullified dependent association
+class NDACategory < ActiveRecord::Base
+  include SoftDeletion
+  set_table_name 'categories'
+  has_many :forums, :dependent => :destroy, :foreign_key => :category_id
+end
+
+class SoftDeletionTest < ActiveSupport::TestCase
+  def assert_deleted(resource)
+    resource.class.with_deleted do
+      resource.reload
+      assert resource.deleted?
+    end
+  end
+
+  def assert_not_deleted(resource)
+    resource.reload
+    assert !resource.deleted?
+  end
+
+  setup do
+    # clear callbacks
+    Category.class_eval{ @after_soft_delete_callbacks = nil }
+  end
+
+  context ".after_soft_delete" do
+    should "be called after soft-deletion" do
+      Category.after_soft_delete :foo
+      category = Category.create!
+      category.expects(:foo)
+      category.soft_delete!
+    end
+
+    should "not be called after normal destroy" do
+      # TODO clear all callbacks
+      Category.after_soft_delete :foo
+      category = Category.create!
+      category.expects(:foo).never
+      category.destroy
+    end
+  end
+
+  context 'without dependent associations' do
+    should 'only soft-delete itself' do
+      category = NoAssociationCategory.create!
+      category.soft_delete!
+      assert_deleted category
+    end
+  end
+
+  context 'with independent associations' do
+    should 'not delete associations' do
+      category = IDACategory.create!
+      forum = category.forums.create!
+      category.soft_delete!
+      assert_deleted forum
+    end
+  end
+
+  context 'with dependent associations' do
+    setup do
+      @category = Category.create!
+      @forum = @category.forums.create!
+    end
+
+    context 'failing to soft delete' do
+      setup do
+        @category.stubs(:valid?).returns(false)
+        assert_raise(ActiveRecord::RecordInvalid) { @category.soft_delete! }
+      end
+
+      should 'not mark itself as deleted' do
+        assert_not_deleted @category
+      end
+
+      should 'not soft delete its dependent associations' do
+        assert_not_deleted @forum
+      end
+    end
+
+    context 'successfully soft deleted' do
+      setup do
+        @category.soft_delete!
+      end
+
+      should 'mark itself as deleted' do
+        assert_deleted @category
+      end
+
+      should 'soft delete its dependent associations' do
+        assert_deleted @forum
+      end
+    end
+
+    context 'being restored from soft deletion' do
+      setup do
+        @category.soft_delete!
+        Category.with_deleted do
+          @category.reload
+          @category.soft_undelete!
+          @category.reload
+        end
+      end
+
+      should 'not mark itself as deleted' do
+        assert_not_deleted @category
+      end
+
+      should 'restore its dependent associations' do
+        assert_not_deleted @forum
+      end
+    end
+  end
+
+  context 'a soft-deleted has-many category that nullifies forum references on delete' do
+    should 'nullify those references' do
+      category = NDACategory.create!
+      forum = category.forums.create!
+      category.soft_delete!
+      assert_deleted forum
+      #assert_nil forum.category_id # TODO
+    end
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: soft_deletion
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- ZenDesk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-02 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: michael@grosser.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- Readme.md
+- lib/soft_deletion.rb
+- lib/soft_deletion/dependency.rb
+- lib/soft_deletion/version.rb
+- soft_deletion.gemspec
+- test/soft_deletion_test.rb
+homepage: http://github.com/grosser/soft_deletion
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1139909322211905394
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1139909322211905394
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Explicit soft deletion for ActiveRecord via deleted_at and default scope.
+test_files: []