Replace core functionality with ActiveRecord::Frames

Author: voltechs

README.md

@@ -102,10 +102,9 @@ class IndexDeletedAtColumns < ActiveRecord::Migration
 end
 ```
 
-
 ## [Upgrading](#upgrading)
 
-If you've used `deleted_at` prior to v0.5.0, you'll need to migrate your schema. The new version of `deleted_at` no longer uses views, instead constructing a subselect on the relations. This significantly reduces code polution and monkey patching, as well as reducing the runtime memory usage for rails. Your Database will look (and be) a lot cleaner with no `deleted_at` views and your ERDs will be much cleaner as well.
+If you've used `deleted_at` prior to v0.5.0, you'll need to migrate your schema. The new version of `deleted_at` no longer uses views, instead constructing a common table expression (CTE) on the relations. This significantly reduces code polution and monkey patching, as well as reducing the runtime memory usage for rails. Your Database will look (and be) a lot cleaner with no `deleted_at` views (and your ERDs will be much cleaner as well).
 
 Here is an example of a migration for upgrading
 ```ruby

deleted_at.gemspec

@@ -28,6 +28,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.3'
 
   spec.add_runtime_dependency 'activerecord', rails_versions
+  spec.add_runtime_dependency 'active_record-framing', '~> 0.1.0-6'
+
   spec.add_development_dependency 'pg'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rspec'

lib/deleted_at.rb

@@ -1,9 +1,14 @@
+require 'active_record/framing'
+
 require 'deleted_at/version'
+require 'deleted_at/relation'
+require 'deleted_at/core'
+require 'deleted_at/table_definition'
 require 'deleted_at/railtie' if defined?(Rails::Railtie)
 
 module DeletedAt
 
-  MissingColumn = Class.new(StandardError)
+  MissingColumnError = Class.new(StandardError)
 
   DEFAULT_OPTIONS = {
     column: :deleted_at,

lib/deleted_at/active_record.rb

@@ -1,50 +1,73 @@
-require 'active_record'
-require 'deleted_at/relation'
-
 module DeletedAt
   module ActiveRecord
 
     def self.prepended(subclass)
-      subclass.init_deleted_at_relations
       subclass.extend(ClassMethods)
+
+      subclass.class_eval do
+        init_deleted_at_relations
+        default_frame { where(deleted_at[:column] => nil) }
+        frame :all, -> {}
+        frame :deleted, -> { where.not(deleted_at[:column] => nil) }
+      end
     end
 
     def initialize(*args)
-      super
-      @destroyed = !deleted_at.nil?
+      super.tap do
+        @destroyed = deleted_at_nil?
+      end
     end
 
     def destroy
-      soft_delete
-      super
+      run_callbacks(:destroy) do
+        soft_delete
+      end
     end
 
     def delete
       soft_delete
-      super
+    end
+
+    def destroy!
+      run_callbacks(:destroy) do
+        soft_delete
+      end
+    end
+
+    def delete!
+      soft_delete
     end
 
     private
 
     def soft_delete
+      return if destroyed?
       update_columns(self.class.deleted_at_attributes)
       @destroyed = true
+      freeze
+      self
+    end
+
+    def deleted_at_nil?
+      !read_attribute(self.class.deleted_at[:column]).nil?
     end
 
     module ClassMethods
 
       def inherited(subclass)
         super
-        subclass.init_deleted_at_relations
+        # subclass.init_deleted_at_relations if deleted_at[:inherit]
+      end
+
+      def deleted_at_attributes
+        attributes = {
+          deleted_at[:column] => deleted_at[:proc].call
+        }
       end
 
-      def const_missing(const)
-        case const
-        when :All, :Deleted
-          all.tap do |_query|
-            _query.deleted_at_scope = const
-          end
-        else super
+      def init_deleted_at_relations
+        instance_variable_get(:@relation_delegate_cache).each do |base, klass|
+          klass.send(:prepend, DeletedAt::Relation)
         end
       end
 

lib/deleted_at/core.rb

@@ -1,5 +1,4 @@
 require 'deleted_at/active_record'
-
 module DeletedAt
 
   module Core
@@ -15,39 +14,33 @@ class << subclass
 
     def self.raise_missing(klass)
       message = "Missing `#{klass.deleted_at[:column]}` in `#{klass.name}` when trying to employ `deleted_at`"
-      raise(DeletedAt::MissingColumn, message)
+      raise(DeletedAt::MissingColumnError, message)
     end
 
     def self.has_deleted_at_column?(klass)
       klass.columns.map(&:name).include?(klass.deleted_at.dig(:column).to_s)
     end
 
+    def self.deleted_at_ready?(klass)
+      !::DeletedAt.disabled? &&
+      klass != ::ActiveRecord::Base &&
+      !klass.abstract_class? &&
+      klass.connected? &&
+      klass.table_exists? &&
+      !(klass < DeletedAt::ActiveRecord)
+    end
+
     module ClassMethods
 
       def with_deleted_at(options={}, &block)
         self.deleted_at = DeletedAt::DEFAULT_OPTIONS.merge(options)
         self.deleted_at[:proc] = block if block_given?
 
-        return if ::DeletedAt.disabled?
-
+        return unless Core.deleted_at_ready?(self)
         DeletedAt::Core.raise_missing(self) unless Core.has_deleted_at_column?(self)
 
         self.prepend(DeletedAt::ActiveRecord)
-
       end
-
-      def deleted_at_attributes
-        attributes = {
-          deleted_at[:column] => deleted_at[:proc].call
-        }
-      end
-
-      def init_deleted_at_relations
-        instance_variable_get(:@relation_delegate_cache).each do |base, klass|
-          klass.send(:prepend, DeletedAt::Relation)
-        end
-      end
-
     end # End ClassMethods
 
   end

lib/deleted_at/railtie.rb

@@ -1,6 +1,4 @@
 require 'rails/railtie'
-require 'deleted_at/core'
-require 'deleted_at/table_definition'
 
 module DeletedAt
   class Railtie < Rails::Railtie

lib/deleted_at/version.rb

@@ -1,3 +1,3 @@
 module DeletedAt
-  VERSION = "0.6.0-2"
+  VERSION = "0.6.0-4"
 end

spec/deleted_at/active_record_spec.rb

@@ -7,7 +7,7 @@
     it "raises exception when using with_deleted_at" do
       expected_stderr = "Missing `deleted_at` in `Comment` when trying to employ `deleted_at`"
       allow(Comment).to receive(:has_deleted_at_views?).and_return(true)
-      expect{ Comment.with_deleted_at }.to raise_exception(DeletedAt::MissingColumn)
+      expect{ Comment.with_deleted_at }.to raise_exception(DeletedAt::MissingColumnError)
     end
 
   end
@@ -25,11 +25,21 @@
     User.create(name: 'john')
     User.create(name: 'sally')
 
-    User.first.destroy
+    u = User.first
+    u.destroy
 
     expect(User::Deleted.first.class).to eq(User)
   end
 
+  it "doesn't obstruct destroy callbacks" do
+    User.create(name: 'sally')
+
+    u = User.first
+    expect_any_instance_of(User).to receive(:say_something)
+
+    u.destroy
+  end
+
   it 'works with complex eager loading' do
     bob = User.create(name: 'bob')
     (1..5).each do |i|
@@ -42,19 +52,4 @@
     expect(User.eager_load(posts: :comments).find_by(name: 'bob')).to eq(bob)
   end
 
-  context 'with default_scope' do
-    it 'should have the default scope in the subquery' do
-      Admin.create(name: 'bob', kind: 1)
-      Admin.create(name: 'john', kind: 1)
-      Admin.create(name: 'sally', kind: 0)
-
-      Admin.first.destroy
-
-      User.first
-
-      # SELECT "users".* FROM (SELECT "users".* FROM "users" WHERE "users"."kind" = $1 AND "users"."deleted_at" IS NULL) "users" WHERE "users"."kind" = 1
-      expect(Admin::Deleted.first.class).to eq(Admin)
-    end
-  end
-
 end

spec/deleted_at/core_spec.rb

@@ -2,6 +2,18 @@
 
 describe DeletedAt::Core do
 
+  context 'models with dependent: :destroy' do
+    it 'should also destroy dependents' do
+      user = User.create(name: 'bob')
+
+      4.times do
+        Post.create(user: user)
+      end
+
+      expect{user.destroy}.to_not raise_exception
+    end
+  end
+
   context "models using deleted_at" do
 
     it "#destroy should set deleted_at" do
@@ -28,21 +40,18 @@
       expect(User::Deleted.count).to eq(1)
     end
 
-    context 'associations' do
-
-      it 'should scope properly' do
-
-        user = User.create(name: 'bob')
-        (1..4).each do
-          Post.create(user: user)
-        end
-
-        post = user.posts.first.delete
-
-        expect(user.posts.count).to eq(3)
+    it "#destroy twice should set deleted_at and not fail" do
+      User.create(name: 'bob')
+      User.create(name: 'john')
+      User.create(name: 'sally')
 
-      end
+      u = User.first
+      u.destroy!
+      u.destroy!
 
+      expect(User.count).to eq(2)
+      expect(User::All.count).to eq(3)
+      expect(User::Deleted.count).to eq(1)
     end
 
     context '#destroy_all' do
@@ -65,6 +74,7 @@
 
         User.where(name: 'bob').destroy_all
 
+
         expect(User.count).to eq(2)
         expect(User::All.count).to eq(3)
         expect(User::Deleted.count).to eq(1)
@@ -73,28 +83,28 @@
 
     context '#delete_all' do
       it "should set deleted_at" do
-        Animals::Dog.create(name: 'bob')
-        Animals::Dog.create(name: 'john')
-        Animals::Dog.create(name: 'sally')
+        User.create(name: 'bob')
+        User.create(name: 'john')
+        User.create(name: 'sally')
 
         # conditions should not matter
-        Animals::Dog.all.delete_all(name: 'bob')
+        User.all.delete_all(name: 'bob')
 
-        expect(Animals::Dog.count).to eq(0)
-        expect(Animals::Dog::All.count).to eq(3)
-        expect(Animals::Dog::Deleted.count).to eq(3)
+        expect(User.count).to eq(0)
+        expect(User::All.count).to eq(3)
+        expect(User::Deleted.count).to eq(3)
       end
 
       it "with conditions should set deleted_at" do
-        Animals::Dog.create(name: 'bob')
-        Animals::Dog.create(name: 'john')
-        Animals::Dog.create(name: 'sally')
+        User.create(name: 'bob')
+        User.create(name: 'john')
+        User.create(name: 'sally')
 
-        Animals::Dog.where(name: 'bob').delete_all
+        User.where(name: 'bob').delete_all
 
-        expect(Animals::Dog.count).to eq(2)
-        expect(Animals::Dog::All.count).to eq(3)
-        expect(Animals::Dog::Deleted.count).to eq(1)
+        expect(User.count).to eq(2)
+        expect(User::All.count).to eq(3)
+        expect(User::Deleted.count).to eq(1)
       end
     end