soft_delete_rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c328fc357734d05ff5f8d6221db439a5e5c35eba
+  data.tar.gz: ad34b111cb04d338eab528086a7a732f73f4f53b
+SHA512:
+  metadata.gz: f6e92a7f9b4b50939a56e3c77e1904d335e871208eafc237ec66fc0d9ff3dbc70cc9d79e506d7e984683f422c4d1e651e426a4d528df3774841ae4a0273d4ff4
+  data.tar.gz: d51f40ea74aed36ffa06e4cdb1bdb66d3a5db9644bd9d4c901a0135e9aaf70fa92500c20bbc4fe9cfa9b9dfbf65f6324784173a96d5f58b799cf03132e77224e

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea

data/.ruby-gemset

@@ -0,0 +1 @@
+soft_delete_rails

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.1

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in soft_delete_rails.gemspec
+gemspec
+
+group :test do
+  gem 'activesupport', '4.1.0'
+  gem 'minitest'
+  gem 'minitest-reporters'
+  gem 'sqlite3'
+  gem 'database_cleaner'
+  gem 'shoulda'
+  gem 'turn'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Andrew Medeiros
+
+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,107 @@
+# Soft Delete Rails
+
+Soft deletion for rails. Includes default scoping and skipping validations. Features soft deletion of dependent records as well as reviving of dependent records.
+Supports ActiveRecord >= 4.1.0
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'soft_delete_rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install soft_delete_rails
+
+## Requierments
+Datetime column deleted_at
+    
+    class CreateUsers < ActiveRecord::Migration
+      def up
+        create_table :users, do |t|
+          t.datetime :deleted_at
+          t.timestamps
+        end
+      end
+    end
+
+## Scopes
+Default scope (optional)
+
+    where(deleted_at: nil)
+Deleted scope (non-optional)
+
+    unscope(where: :deleted_at).where.not(deleted_at: nil)
+
+## Options    
+Default usage includes the default scope and running model validations
+
+    class User < ActiveRecord::Base
+      has_soft_delete
+    end
+    
+Without default scope
+    
+    class User < ActiveRecord::Base
+      has_soft_delete default_scope: false
+    end
+    
+Without validations. Will not run the model validations on soft delete or revive
+
+    class User < ActiveRecord::Base
+      has_soft_delete validate: false
+    end
+
+Without default scope and validations
+    
+    class User < ActiveRecord::Base
+      has_soft_delete default_scope: false, validate: false
+    end
+        
+## Dependent
+Requires both models to have has_soft_delete and deleted_at column
+
+    class User < ActiveRecord::Base
+      belongs_to :group
+      has_soft_delete
+    end
+    
+    # Will soft delete and revive the user records
+    class Group < ActiveRecord::Base
+      has_many :users, dependent: :destroy
+      has_soft_delete
+    end
+    
+## Destroy
+
+    group = Group.last
+
+    # Will soft delete the record and any dependent records with has_soft_delete
+    group.destroy
+
+    # Will hard delete the record from the database and any dependent records
+    group.destroy(:force)
+   
+
+## Revive
+
+    group = Group.deleted.last
+
+    # Will revive the record and any dependent records with has_soft_delete
+    group.revive
+
+
+## Author
+Andrew Medeiros, amedeiros0920@gmail.com, @_AndrewMedeiros
+    
+## Contributing
+
+1. Fork it ( https://github.com/amedeiros/soft_delete_rails/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |task|
+  task.libs << 'test'
+  task.test_files = FileList['test/*_test.rb']
+end
+
+task :default => [:test]
+

data/lib/soft_delete_rails/has_soft_delete.rb

@@ -0,0 +1,91 @@
+module SoftDeleteRails
+  module Model
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def has_soft_delete(options = {})
+        # Lazy load the instance methods
+        send :include, InstanceMethods
+
+        class_attribute :delete_options
+        self.delete_options = options
+
+        # Set scopes
+        SoftDeleteRails::Scopes.default(self) unless options[:default_scope] == false
+        SoftDeleteRails::Scopes.deleted(self)
+      end
+    end
+
+    module InstanceMethods
+      def destroy(force=nil)
+        if force == :force
+          if super()
+            hard_destroy_dependent_records
+          end
+        else
+          run_callbacks(:destroy) do
+            soft_deleted? || new_record? ? save : update_deleted_at(Time.current)
+          end
+        end
+      end
+
+      def revive
+        if soft_deleted?
+          update_deleted_at(nil)
+          revive_dependent_records
+          return self.reload # return self reloaded
+        end
+      end
+
+      def soft_deleted?
+        deleted_at.present?
+      end
+
+      private
+
+      def update_deleted_at(value)
+        self.deleted_at = value
+        if self.class.delete_options[:validate] == false
+          save(validate: false)
+        else
+          save!
+        end
+      end
+
+      def revive_dependent_records
+        reflections.each do |key, relation|
+          if relation.options[:dependent] == :destroy
+            records = Array.wrap(send(key).try(:deleted)) if key.to_s.singularize.camelize.constantize.column_names.include?('deleted_at')
+            records = Array.wrap(send(key)) if records.blank?
+            records.to_a.each do |record|
+              record.revive if record.respond_to?(:revive)
+            end
+          end
+        end
+      end
+
+      # Perform a hard destroy on the dependent records
+      def hard_destroy_dependent_records
+        reflections.each do |key, relation|
+          if relation.options[:dependent] == :destroy
+            records = send(key).try(:unscope, where: :deleted_at) if key.to_s.singularize.camelize.constantize.column_names.include?('deleted_at')
+            records = Array.wrap(send(key)) if records.blank?
+            records.each do |record|
+              if record.respond_to?(:soft_deleted?)
+                record.destroy(:force)
+              else
+                record.destroy
+              end
+            end
+          end
+        end
+      end
+
+      def reflections
+        self.class.reflections
+      end
+    end
+  end
+end

data/lib/soft_delete_rails/scopes.rb

@@ -0,0 +1,11 @@
+module SoftDeleteRails
+  class Scopes
+    def self.default(model)
+      model.class_eval { default_scope { where(deleted_at: nil) } }
+    end
+
+    def self.deleted(model)
+      model.class_eval { scope :deleted, -> { unscope(where: :deleted_at).where.not(deleted_at: nil) } }
+    end
+  end
+end

data/lib/soft_delete_rails/version.rb

@@ -0,0 +1,3 @@
+module SoftDeleteRails
+  VERSION = '0.0.1'
+end

data/lib/soft_delete_rails.rb

@@ -0,0 +1,6 @@
+require 'soft_delete_rails/version'
+require 'soft_delete_rails/scopes'
+require 'soft_delete_rails/has_soft_delete'
+
+# Include our model mixin
+ActiveRecord::Base.send(:include, SoftDeleteRails::Model)

data/soft_delete_rails.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'soft_delete_rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'soft_delete_rails'
+  spec.version       = SoftDeleteRails::VERSION
+  spec.authors       = ['Andrew Medeiros']
+  spec.email         = ['amedeiros0920@gmail.com']
+  spec.summary       = %q{Soft delete records within rails}
+  spec.description   = %q{Soft delete records within rails}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'activerecord', '4.1.0'
+end

data/test/configuration/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: soft_delete_test

data/test/configuration/schema.rb

@@ -0,0 +1,30 @@
+ActiveRecord::Schema.define do
+  create_table :groups, force: true do |t|
+    t.datetime  :deleted_at
+    t.string    :name
+    t.timestamps
+  end
+
+  create_table :accounts, force: true do |t|
+    t.datetime :deleted_at
+    t.string   :name
+    t.timestamps
+  end
+
+  create_table :users, force: true do |t|
+    t.datetime   :deleted_at
+    t.belongs_to :group
+    t.timestamps
+  end
+
+  create_table :phone_numbers, force: true do |t|
+    t.belongs_to :user
+    t.timestamps
+  end
+
+  create_table :addresses, force: true do |t|
+    t.belongs_to :user
+    t.datetime :deleted_at
+    t.timestamps
+  end
+end

data/test/models/account.rb

@@ -0,0 +1,4 @@
+class Account < ActiveRecord::Base
+  validates :name, presence: true
+  has_soft_delete default_scope: false, validate: false
+end

data/test/models/address.rb

@@ -0,0 +1,4 @@
+class Address < ActiveRecord::Base
+  belongs_to :user
+  has_soft_delete
+end

data/test/models/group.rb

@@ -0,0 +1,5 @@
+class Group < ActiveRecord::Base
+  has_many :users, dependent: :destroy
+  validates :name, presence: :true
+  has_soft_delete
+end

data/test/models/phone_number.rb

@@ -0,0 +1,3 @@
+class PhoneNumber < ActiveRecord::Base
+  belongs_to :user
+end

data/test/models/user.rb

@@ -0,0 +1,6 @@
+class User < ActiveRecord::Base
+  belongs_to :group
+  has_one :phone_number, dependent: :destroy
+  has_one :address, dependent: :destroy
+  has_soft_delete
+end

data/test/soft_delete_rails_test.rb

@@ -0,0 +1,221 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+class SoftDeleteRailsTest < ActiveSupport::TestCase
+  context SoftDeleteRails do
+    setup do
+      DatabaseCleaner.strategy = :truncation
+      DatabaseCleaner.start
+    end
+
+    teardown do
+      DatabaseCleaner.clean
+    end
+
+    context 'soft deletion' do
+      should 'should set the deleted_at' do
+        user = User.create
+        assert_difference 'User.count', -1 do
+          user.destroy
+          assert user.deleted_at.present?
+          assert user.soft_deleted?
+        end
+      end
+
+      context 'dependents' do
+        setup do
+          @group = Group.create(name: 'test')
+          @user  = User.create(group: @group)
+        end
+
+        should 'soft delete dependent records' do
+          assert_difference ['Group.count', 'User.count'], -1 do
+            assert @group.destroy
+            assert @group.soft_deleted?
+            assert @user.reload.soft_deleted?
+          end
+        end
+
+        should 'not soft destroy other non related records' do
+          # The scoping should not delete these records
+          group1 = Group.create(name: 'testing')
+          user1  = User.create(group: group1)
+
+          assert_difference ['Group.count', 'User.count'], -1 do
+            assert @group.destroy
+            assert @group.soft_deleted?
+            assert @user.reload.soft_deleted?
+            refute group1.reload.soft_deleted?
+            refute user1.reload.soft_deleted?
+          end
+        end
+
+        should 'hard delete a dependent record that does not have has_soft_delete' do
+          PhoneNumber.create(user: @user)
+          assert_difference ['User.count', 'PhoneNumber.count'], -1 do
+            assert @user.destroy
+          end
+        end
+
+        context 'has_one' do
+          should 'soft delete a has_one relation' do
+            # A User has one address
+            address = Address.create(user: @user)
+            assert_difference ['User.count', 'Address.count'], -1 do
+              assert @user.destroy
+              assert address.reload.soft_deleted?
+            end
+          end
+        end
+      end
+    end
+
+    context 'revive' do
+      should 'revive a record' do
+        user = User.create
+        # Soft destroy the record
+        assert user.destroy
+        assert user.soft_deleted?
+
+        # Revive the record
+        assert user.revive
+        refute user.soft_deleted?
+      end
+
+      context 'dependents' do
+        setup do
+          @group = Group.create(name: 'test', deleted_at: Time.current)
+          @user  = User.create(group: @group, deleted_at: Time.current)
+        end
+
+        should 'revive dependent records' do
+          # Revive the group and its relations
+          assert @group.revive
+          refute @group.soft_deleted?
+          refute @group.reload.soft_deleted?
+        end
+
+        should 'not revive non related records' do
+          group = Group.create(name: 'testing', deleted_at: Time.current)
+          user  = User.create(group: group, deleted_at: Time.current)
+          # Revive the group and its relations
+          assert @group.revive
+          refute @group.soft_deleted?
+          refute @group.reload.soft_deleted?
+
+          # Should not be revived
+          assert group.soft_deleted?
+          assert user.soft_deleted?
+        end
+
+        context 'has_one' do
+          should 'revive a has_one relation' do
+            address = Address.create(user: @user)
+            assert @user.destroy
+            assert address.reload.soft_deleted?
+
+            # Revive the user
+            assert @user.revive
+            # Should of revived the has one relation
+            refute address.reload.soft_deleted?
+          end
+        end
+      end
+    end
+
+    context 'hard deletion' do
+      should 'hard delete a record' do
+        user = User.create
+        assert_difference 'User.unscoped.count', -1 do
+          assert user.destroy(:force)
+        end
+      end
+
+      context 'dependents' do
+        setup do
+          @group = Group.create(name: 'test')
+          @user  = User.create(group: @group)
+        end
+
+        should 'hard delete dependent records' do
+          assert_difference ['Group.unscoped.count', 'User.unscoped.count'], -1 do
+            assert @group.destroy(:force)
+          end
+        end
+
+        should 'hard delete dependent records that have been soft deleted' do
+          @user.destroy
+          assert @user.soft_deleted?
+          assert_difference ['Group.unscoped.count', 'User.unscoped.count'], -1 do
+            assert @group.destroy(:force)
+          end
+        end
+
+        should 'not hard delete other non related records' do
+          # The scoping should not delete these records
+          group = Group.create(name: 'testing')
+          user  = User.create(group: group)
+
+          assert_difference ['Group.count', 'User.count'], -1 do
+            assert @group.destroy(:force)
+            refute group.reload.soft_deleted?
+            refute user.reload.soft_deleted?
+          end
+        end
+
+        should 'hard delete a dependent record that does not have has_soft_delete' do
+          PhoneNumber.create(user: @user)
+          assert_difference ['User.count', 'PhoneNumber.count'], -1 do
+            assert @user.destroy
+          end
+        end
+
+        context 'has_one' do
+          should 'hard delete a has_one relation' do
+            # A User has one address
+            Address.create(user: @user)
+            assert_difference ['User.unscoped.count', 'Address.unscoped.count'], -1 do
+              assert @user.destroy(:force)
+            end
+          end
+        end
+      end
+    end
+
+    context 'scopes' do
+      context 'default' do
+        should 'have the default scope' do
+          assert_equal User.all.to_sql, User.where(deleted_at: nil).to_sql
+        end
+
+        should 'not have the default scope' do
+          assert_not_equal Account.all.to_sql, Account.where(deleted_at: nil).to_sql
+        end
+      end
+
+      context 'deleted' do
+        should 'have the deleted scope' do
+          assert_equal User.deleted.to_sql, User.unscoped.where.not(deleted_at: nil).to_sql
+        end
+      end
+    end
+
+    context 'validations' do
+      should 'raise ActiveRecord::RecordInvalid for an invalid record' do
+        group = Group.create(name: 'test')
+        error = assert_raises ActiveRecord::RecordInvalid do
+          group.name = nil
+          group.destroy
+        end
+        assert_equal 'Validation failed: Name can\'t be blank', error.message, error.message.inspect
+      end
+
+      should 'not raise ActiveRecord::RecordInvalid for an invalid record' do
+        account = Account.create(name: 'test')
+        assert_nothing_raised do
+          account.name = nil
+          assert account.destroy
+        end
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,28 @@
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'pathname'
+require 'active_record'
+require 'active_support'
+require 'database_cleaner'
+require 'soft_delete_rails'
+require 'shoulda'
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+module Rails
+  def self.env
+    'test'
+  end
+end
+
+configuration = Pathname.new File.expand_path('configuration', File.dirname(__FILE__))
+models        = Pathname.new File.expand_path('models', File.dirname(__FILE__))
+Dir.glob(models.join('*.rb')).each do |file|
+  autoload File.basename(file).chomp('.rb').camelcase.intern, file
+end.each do |file|
+  require file
+end
+
+# Setup ActiveRecord
+ActiveRecord::Base.configurations = YAML.load_file configuration.join('database.yml')
+ActiveRecord::Base.establish_connection
+load configuration.join('schema.rb')

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: soft_delete_rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrew Medeiros
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+description: Soft delete records within rails
+email:
+- amedeiros0920@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/soft_delete_rails.rb
+- lib/soft_delete_rails/has_soft_delete.rb
+- lib/soft_delete_rails/scopes.rb
+- lib/soft_delete_rails/version.rb
+- soft_delete_rails.gemspec
+- soft_delete_test
+- test/configuration/database.yml
+- test/configuration/schema.rb
+- test/models/account.rb
+- test/models/address.rb
+- test/models/group.rb
+- test/models/phone_number.rb
+- test/models/user.rb
+- test/soft_delete_rails_test.rb
+- test/soft_delete_test
+- test/test_helper.rb
+homepage: ''
+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.2
+signing_key: 
+specification_version: 4
+summary: Soft delete records within rails
+test_files:
+- test/configuration/database.yml
+- test/configuration/schema.rb
+- test/models/account.rb
+- test/models/address.rb
+- test/models/group.rb
+- test/models/phone_number.rb
+- test/models/user.rb
+- test/soft_delete_rails_test.rb
+- test/soft_delete_test
+- test/test_helper.rb