deleted_at 0.3.0 → 0.4.0rc1

data/lib/deleted_at/active_record/connection_adapters/abstract/schema_definition.rb

@@ -0,0 +1,17 @@
+module DeletedAt
+  module ActiveRecord
+    module ConnectionAdapters #:nodoc:
+      module TableDefinition
+
+        def timestamps(**options)
+          options[:null] = false if options[:null].nil?
+
+          column(:created_at, :datetime, options)
+          column(:updated_at, :datetime, options)
+          column(:deleted_at, :datetime, options.merge(null: true)) if options[:deleted_at]
+        end
+
+      end
+    end
+  end
+end

data/lib/deleted_at/active_record/relation.rb

@@ -4,11 +4,6 @@ module DeletedAt
     # = Active Record Relation
     module Relation
 
-      def deleted_at_attributes
-        # We _do_ have klass at this point
-        { klass.deleted_at_column => Time.now.utc }
-      end
-
       # Deletes the records matching +conditions+ without instantiating the records
       # first, and hence not calling the +destroy+ method nor invoking callbacks. This
       # is a single SQL DELETE statement that goes straight to the database, much more
@@ -28,63 +23,21 @@ module DeletedAt
       #
       #   Post.limit(100).delete_all
       #   # => ActiveRecord::ActiveRecordError: delete_all doesn't support limit
-      def delete_all(conditions = nil)
+      def delete_all(*args)
+        conditions = args.pop
         if archive_with_deleted_at?
-          where(conditions).update_all(deleted_at_attributes)
+          if conditions
+            ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
+              Passing conditions to delete_all is not supported in DeletedAt
+              To achieve the same use where(conditions).delete_all.
+            MESSAGE
+          end
+          update_all(klass.deleted_at_attributes)
         else
-          super
+          super() # Specifically drop args
         end
       end
 
-      # Deletes the row with a primary key matching the +id+ argument, using a
-      # SQL +DELETE+ statement, and returns the number of rows deleted. Active
-      # Record objects are not instantiated, so the object's callbacks are not
-      # executed, including any <tt>:dependent</tt> association options.
-      #
-      # You can delete multiple rows at once by passing an Array of <tt>id</tt>s.
-      #
-      # Note: Although it is often much faster than the alternative,
-      # <tt>#destroy</tt>, skipping callbacks might bypass business logic in
-      # your application that ensures referential integrity or performs other
-      # essential jobs.
-      #
-      # ==== Examples
-      #
-      #   # Delete a single row
-      #   Todo.delete(1)
-      #
-      #   # Delete multiple rows
-      #   Todo.delete([2,3,4])
-      def delete(id_or_array)
-        where(primary_key => id_or_array).delete_all
-      end
-
-      # Destroy an object (or multiple objects) that has the given id. The object is instantiated first,
-      # therefore all callbacks and filters are fired off before the object is deleted. This method is
-      # less efficient than ActiveRecord#delete but allows cleanup methods and other actions to be run.
-      #
-      # This essentially finds the object (or multiple objects) with the given id, creates a new object
-      # from the attributes, and then calls destroy on it.
-      #
-      # ==== Parameters
-      #
-      # * +id+ - Can be either an Integer or an Array of Integers.
-      #
-      # ==== Examples
-      #
-      #   # Destroy a single object
-      #   Todo.destroy(1)
-      #
-      #   # Destroy multiple objects
-      #   todos = [1,2,3]
-      #   Todo.destroy(todos)
-      def destroy(id)
-        if id.is_a?(Array)
-          id.map { |one_id| destroy(one_id) }
-        else
-          find(id).destroy
-        end
-      end
     end
   end
 end

data/lib/deleted_at/version.rb

@@ -1,3 +1,3 @@
 module DeletedAt
-  VERSION = "0.3.0"
+  VERSION = "0.4.0rc1"
 end

data/lib/deleted_at/views.rb

@@ -3,23 +3,27 @@ module DeletedAt
 
     def self.install_present_view(model)
       uninstall_present_view(model)
-      all_table_name = all_table(model)
       present_table_name = present_view(model)
 
-      model.connection.execute("ALTER TABLE \"#{present_table_name}\" RENAME TO \"#{all_table_name}\"")
-      model.connection.execute <<-SQL
-        CREATE OR REPLACE VIEW "#{present_table_name}"
-        AS SELECT * FROM "#{all_table_name}" WHERE #{model.deleted_at_column} IS NULL;
-      SQL
+      while_spoofing_table_name(model, all_table(model)) do
+        model.connection.execute("ALTER TABLE \"#{present_table_name}\" RENAME TO \"#{model.table_name}\"")
+        model.connection.execute <<-SQL
+          CREATE OR REPLACE VIEW "#{present_table_name}"
+          AS #{ model.where(model.deleted_at_column => nil).to_sql }
+        SQL
+      end
     end
 
     def self.install_deleted_view(model)
-      return warn("You must install the all/present tables/views first!") unless all_table_exists?(model)
+      return DeletedAt.logger.warn("You must install the all/present tables/views first!") unless all_table_exists?(model)
       table_name = deleted_view(model)
-      model.connection.execute <<-SQL
-        CREATE OR REPLACE VIEW "#{table_name}"
-        AS SELECT * FROM "#{all_table(model)}" WHERE #{model.deleted_at_column} IS NOT NULL;
-      SQL
+
+      while_spoofing_table_name(model, all_table(model)) do
+        model.connection.execute <<-SQL
+          CREATE OR REPLACE VIEW "#{table_name}"
+          AS #{ model.where.not(model.deleted_at_column => nil).to_sql }
+        SQL
+      end
     end
 
     def self.all_table_exists?(model)
@@ -28,9 +32,9 @@ module DeletedAt
           SELECT 1
           FROM   information_schema.tables
           WHERE  table_name = '#{all_table(model)}'
-        );
+        ) AS exists;
       SQL
-      get_truthy_value_from_psql(query)
+      DeletedAt.testify(query.first['exists'])
     end
 
     def self.deleted_view_exists?(model)
@@ -39,9 +43,9 @@ module DeletedAt
           SELECT 1
           FROM   information_schema.tables
           WHERE  table_name = '#{deleted_view(model)}'
-        );
+        ) AS exists;
       SQL
-      get_truthy_value_from_psql(query)
+      DeletedAt.testify(query.first['exists'])
     end
 
     def self.present_view(model)
@@ -71,11 +75,11 @@ module DeletedAt
 
     private
 
-    def self.get_truthy_value_from_psql(result)
-      # Some versions of PSQL return {"?column?"=>"t"}
-      # instead of {"first"=>"t"}, so we're saying screw it,
-      # just give me the first value of whatever is returned
-      result.try(:first).try(:values).try(:first) == 't'
+    def self.while_spoofing_table_name(model, new_name, &block)
+      old_name = model.table_name
+      model.table_name = new_name
+      yield
+      model.table_name = old_name
     end
 
   end

data/spec/deleted_at/active_record/base_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe DeletedAt::ActiveRecord::Base do
+
+  context "model missing deleted_at column" do
+
+    it "fails when trying to install" do
+      expect(DeletedAt.install(Comment)).to eq(false)
+      expect(DeletedAt.uninstall(Comment)).to eq(false)
+    end
+
+    it "warns 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(DeletedAt.logger).to receive(:warn).with(expected_stderr)
+      Comment.with_deleted_at
+    end
+
+  end
+
+end

data/spec/deleted_at/active_record/relation_spec.rb

@@ -0,0 +1,166 @@
+require "spec_helper"
+
+describe DeletedAt::ActiveRecord::Relation do
+
+  context "models using deleted_at" do
+
+    it "#destroy should set deleted_at" do
+      DeletedAt.install(User)
+      User.create(name: 'bob')
+      User.create(name: 'john')
+      User.create(name: 'sally')
+
+      User.first.destroy
+
+      expect(User.count).to eq(2)
+      expect(User::All.count).to eq(3)
+      expect(User::Deleted.count).to eq(1)
+      DeletedAt.uninstall(User)
+    end
+
+    it "#delete should set deleted_at" do
+      DeletedAt.install(User)
+      User.create(name: 'bob')
+      User.create(name: 'john')
+      User.create(name: 'sally')
+
+      User.first.delete
+
+      expect(User.count).to eq(2)
+      expect(User::All.count).to eq(3)
+      expect(User::Deleted.count).to eq(1)
+      DeletedAt.uninstall(User)
+    end
+
+    context '#destroy_all' do
+      it "should set deleted_at" do
+        DeletedAt.install(User)
+        User.create(name: 'bob')
+        User.create(name: 'john')
+        User.create(name: 'sally')
+
+        User.all.destroy_all
+
+        expect(User.count).to eq(0)
+        expect(User::All.count).to eq(3)
+        expect(User::Deleted.count).to eq(3)
+        DeletedAt.uninstall(User)
+      end
+
+      it "with conditions should set deleted_at" do
+        DeletedAt.install(User)
+        User.create(name: 'bob')
+        User.create(name: 'john')
+        User.create(name: 'sally')
+
+        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)
+        DeletedAt.uninstall(User)
+      end
+    end
+
+    context '#delete_all' do
+      it "should set deleted_at" do
+        DeletedAt.install(Animals::Dog)
+        Animals::Dog.create(name: 'bob')
+        Animals::Dog.create(name: 'john')
+        Animals::Dog.create(name: 'sally')
+
+        # conditions should not matter
+        Animals::Dog.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)
+        DeletedAt.uninstall(Animals::Dog)
+      end
+
+      it "with conditions should set deleted_at" do
+        DeletedAt.install(Animals::Dog)
+        Animals::Dog.create(name: 'bob')
+        Animals::Dog.create(name: 'john')
+        Animals::Dog.create(name: 'sally')
+
+        Animals::Dog.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)
+        DeletedAt.uninstall(Animals::Dog)
+      end
+    end
+
+  end
+
+  context "models not using deleted_at" do
+
+    it "#destroy should actually delete the record" do
+      Comment.create(title: 'Agree')
+      Comment.create(title: 'Disagree')
+      Comment.create(title: 'Defer')
+
+      Comment.first.destroy
+
+      expect(Comment.count).to eq(2)
+    end
+
+    it "#delete should actually delete the record" do
+      Comment.create(title: 'Agree')
+      Comment.create(title: 'Disagree')
+      Comment.create(title: 'Defer')
+
+      Comment.first.delete
+
+      expect(Comment.count).to eq(2)
+    end
+
+    context '#destroy_all' do
+      it "should actually delete records" do
+        Comment.create(title: 'Agree')
+        Comment.create(title: 'Disagree')
+        Comment.create(title: 'Defer')
+
+        Comment.all.destroy_all
+
+        expect(Comment.count).to eq(0)
+      end
+
+      it "with conditions should actually delete records" do
+        Comment.create(title: 'Agree')
+        Comment.create(title: 'Disagree')
+        Comment.create(title: 'Defer')
+
+        Comment.where(title: 'Disagree').destroy_all
+
+        expect(Comment.count).to eq(2)
+      end
+    end
+
+    context '#delete_all' do
+      it "should actually delete records" do
+        Comment.create(title: 'Agree')
+        Comment.create(title: 'Disagree')
+        Comment.create(title: 'Defer')
+
+        Comment.all.delete_all
+
+        expect(Comment.count).to eq(0)
+      end
+
+      it "with conditions should actually delete records" do
+        Comment.create(title: 'Agree')
+        Comment.create(title: 'Disagree')
+        Comment.create(title: 'Defer')
+
+        Comment.where(title: 'Agree').delete_all
+
+        expect(Comment.count).to eq(2)
+      end
+    end
+
+  end
+
+end

data/spec/deleted_at/views_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+
+describe DeletedAt::Views do
+  {
+    User => "simple model",
+    Post => "model with customized table_name",
+    Animals::Dog => "namespaced model"
+  }.each do |model, description|
+
+    plural = model.name.pluralize
+    table_name = model.table_name
+
+    describe "#install for #{description}" do
+      after(:each) do
+        DeletedAt.uninstall(model)
+      end
+
+      it 'should not raise error' do
+        expect{ DeletedAt.install(model) }.to_not raise_error()
+      end
+
+      it 'should rename the models table' do
+        DeletedAt.install(model)
+        expect(ActiveRecord::Base.connection.table_exists?("#{table_name}/all")).to be_truthy
+      end
+
+      it "should have a view for all non-deleted #{plural}" do
+        DeletedAt.install(model)
+        if Gem::Version.new(Rails.version) < Gem::Version.new("5.0")
+          expect(ActiveRecord::Base.connection.table_exists?(table_name)).to be_truthy
+        else
+          expect(ActiveRecord::Base.connection.view_exists?(table_name)).to be_truthy
+        end
+      end
+
+      it "should have a view for all deleted #{plural}" do
+        DeletedAt.install(model)
+        if Gem::Version.new(Rails.version) < Gem::Version.new("5.0")
+          expect(ActiveRecord::Base.connection.table_exists?("#{table_name}/deleted")).to be_truthy
+        else
+          expect(ActiveRecord::Base.connection.view_exists?("#{table_name}/deleted")).to be_truthy
+        end
+      end
+
+      it 'creates the DeletedAt class extensions' do
+        DeletedAt.install(model)
+        expect(model.const_defined?(:All)).to be_truthy
+        expect(model.const_defined?(:Deleted)).to be_truthy
+      end
+
+      it 'sets the correct table name for modified class' do
+        DeletedAt.install(model)
+        expect(model.table_name).to eql(table_name)
+        expect(model::All.table_name).to eql("#{table_name}/all")
+        expect(model::Deleted.table_name).to eql("#{table_name}/deleted")
+      end
+    end
+
+    describe "#uninstall for #{description}" do
+      before(:each) do
+        DeletedAt.install(model)
+      end
+
+      it 'should not raise error' do
+        expect{ DeletedAt.uninstall(model) }.to_not raise_error()
+      end
+
+      it 'should remove model extensions' do
+        DeletedAt.uninstall(model)
+        expect(model.const_defined?(:All)).to be_falsy
+        expect(model.const_defined?(:Deleted)).to be_falsy
+      end
+    end
+  end
+
+end