sequel-soft-deletes 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2b90ce7450ab370ffd9fb26653e35597ebd462bdaf660a4572a9b8ff63cfae9a
+  data.tar.gz: 6513ffde924e7dbfac20b26ad37aab7d1ebf08bf453c1adc279053984362334e
+SHA512:
+  metadata.gz: c6db370861d3c3430df66538c5c7270829c0c5a60c95f201436ce90b59272697e0d4cad07829b32fab1405ce9776b5428138272d17ebb1a1b77e8f86056a47fe
+  data.tar.gz: 0d5020c98215beb773b5f14fb781a15a78a5820294216622da6e701bb74a48c4e3eaf6510371579bc77c6a0b9f8d1ae0421b8c64fb495385e0de43eefeb1de51

data/lib/sequel/plugins/soft_deletes.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "sequel"
+require "sequel/model"
+
+# Plugin for adding soft-delete to a model.
+#
+# == Example
+#
+# Defining a model class with a timestamp as the deletion flag:
+#
+#   class ACME::Customer < Sequel::Model(:customers)
+#       plugin :soft_deletes, column: :deleted_at
+#
+# And in the schema:
+#   create_table( :customers ) do
+#       primary_key :id
+#       timestamptz :deleted_at
+#   end
+#
+module Sequel::Plugins::SoftDeletes
+  VERSION = "0.1.2"
+
+  # Default plugin options
+  DEFAULT_OPTIONS = {
+    column: :soft_deleted_at,
+    omit_by_default: false,
+  }.freeze
+
+  def self.configure(model, opts=DEFAULT_OPTIONS)
+    opts = DEFAULT_OPTIONS.merge(opts)
+    column = opts[:column]
+    model.soft_delete_column = column
+    model.set_dataset(model.where(column => nil)) if opts[:omit_by_default]
+  end
+
+  module DatasetMethods
+    def soft_deleted
+      column = self.model.soft_delete_column
+      exclude(column => nil)
+    end
+
+    def not_soft_deleted
+      column = self.model.soft_delete_column
+      where(column => nil)
+    end
+  end
+
+  # Methods to extend Model classes with.
+  module ClassMethods
+    ##
+    # The Array of field which are images, as Symbols
+    attr_accessor :soft_delete_column
+  end
+
+  # Methods to extend Model instances with.
+  module InstanceMethods
+    ### Returns +true+ if this object should be considered deleted.
+    def soft_deleted?
+      column = self.class.soft_delete_column
+      return self[column] ? true : false
+    end
+
+    alias is_soft_deleted? soft_deleted?
+
+    ### Returns +true+ if the object is soft-deletable. By default, an
+    ### object is soft-deletable if it has no +soft_deletion_blockers+.
+    def soft_deletable?
+      return self.soft_deletion_blockers.empty?
+    end
+
+    ### Soft-delete this instance.
+    def soft_delete
+      column = self.class.soft_delete_column
+
+      self.db.transaction do
+        supered_from_around = false
+        self.around_soft_delete do
+          supered_from_around = true
+          raise_hook_failure(:before_soft_delete) unless self.before_soft_delete
+
+          self.update(column => Time.now)
+
+          self.after_soft_delete
+        end
+        raise_hook_failure(:around_soft_delete) unless supered_from_around
+      end
+    end
+
+    ### Returns an array of conditions preventing soft-deletion. Default is an empty array.
+    def soft_deletion_blockers
+      return []
+    end
+
+    ### Remove soft-deletion blockers. Default soft-deletion raises NotImplementedError.
+    def remove_soft_deletion_blockers
+      raise NotImplementedError
+    end
+
+    ### Default 'before' soft-delete hook checks if object is soft-deletable.
+    ### Aborts soft-deletion if it returns false.
+    def before_soft_delete
+      return self.soft_deletable?
+    end
+
+    ### Default (empty) 'around' soft-delete model hook.
+    def around_soft_delete
+      yield
+    end
+
+    ### Default (empty) 'after' soft-delete hook.
+    def after_soft_delete; end
+
+    ### Return the information for the soft-deletes column.
+    def soft_delete_column
+      return self.class.schema.columns.find do |col|
+        col[:name] == self.class.soft_delete_column
+      end
+    end
+  end
+end

data/spec/sequel/plugins/soft_deletes_spec.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/integer/time"
+require "sequel/plugins/soft_deletes"
+require "sequel"
+require "sqlite3"
+
+RSpec.describe Sequel::Plugins::SoftDeletes, :db do
+  before(:each) do
+    @db = Sequel.sqlite
+  end
+  after(:each) do
+    @db.disconnect
+  end
+
+  let(:table_name) { :soft_deletes_test }
+
+  it "sets the soft-delete column to :soft_deleted_at if none is specified" do
+    @db.create_table(:soft_deletes_test) do
+      primary_key :id
+      time :deleted_at
+    end
+    mc = Class.new(Sequel::Model(@db[:soft_deletes_test]))
+    mc.plugin(:soft_deletes)
+    expect(mc.soft_delete_column).to eq(:soft_deleted_at)
+  end
+
+  it "allows the class to override the soft-delete column" do
+    @db.create_table(:soft_deletes_test) do
+      primary_key :id
+      time :deleted_at
+    end
+    mc = Class.new(Sequel::Model(@db[:soft_deletes_test]))
+    mc.plugin(:soft_deletes, column: :deleted_at)
+    expect(mc.soft_delete_column).to eq(:deleted_at)
+  end
+
+  it "defines a #soft_delete method on extended model instances" do
+    @db.create_table(:soft_deletes_test) do
+      primary_key :id
+      time :deleted_at
+    end
+    mc = Class.new(Sequel::Model(@db[:soft_deletes_test]))
+    mc.plugin(:soft_deletes)
+    @m = mc.new
+
+    expect(@m).to respond_to(:soft_delete)
+  end
+
+  context "extended model classes with a timestamp soft-delete column" do
+    before do
+      @db.create_table(:soft_deletes_test) do
+        primary_key :id
+        time :deleted_at
+      end
+      @c = Class.new(Sequel::Model(@db[:soft_deletes_test]))
+      @c.plugin(:soft_deletes, column: :deleted_at)
+      @m = @c.create
+    end
+
+    it "sets its column to 'now' when soft-deleted" do
+      @m.soft_delete
+      expect(@m.deleted_at).to be_a(Time)
+      expect(@m.deleted_at).to be_within(5.seconds).of(Time.now)
+    end
+
+    it "sets up a subset for selecting (or de-selecting) soft-deleted rows" do
+      expect(@c.dataset.soft_deleted).to be_a(Sequel::Dataset)
+      expect(@c.dataset.not_soft_deleted).to be_a(Sequel::Dataset)
+
+      expect(@c.dataset.soft_deleted.all).not_to include(@m)
+      expect(@c.dataset.not_soft_deleted.all).to include(@m)
+
+      @m.soft_delete
+      expect(@c.dataset.soft_deleted.all).to include(@m)
+      expect(@c.dataset.not_soft_deleted.all).not_to include(@m)
+    end
+  end
+
+  context "extended model classes with a 'before' soft-delete hook" do
+    before do
+      @db.create_table(:soft_deletes_test) do
+        primary_key :id
+        time :deleted_at
+      end
+      mc = Class.new(Sequel::Model(@db[:soft_deletes_test]))
+      mc.class_eval do
+        attr_accessor :hook_body
+
+        def before_soft_delete
+          self.hook_body.call
+        end
+      end
+      mc.plugin(:soft_deletes, column: :deleted_at)
+      @m = mc.new
+    end
+
+    it "has its hook called whenever an instance is soft-deleted" do
+      called = false
+      @m.hook_body = lambda do
+        called = true
+      end
+      @m.soft_delete
+
+      expect(@m).to be_is_soft_deleted
+      expect(called).to eq(true)
+    end
+
+    it "is not soft-deleted if its hook returns false" do
+      @m.hook_body = lambda do
+        false
+      end
+
+      expect do
+        @m.soft_delete
+      end.to raise_error(Sequel::HookFailed, /before_soft_delete hook failed/i)
+
+      expect(@m).not_to be_soft_deleted
+    end
+  end
+
+  context "extended model classes with an 'after' soft-delete hook" do
+    before do
+      @db.create_table(:soft_deletes_test) do
+        primary_key :id
+        time :deleted_at
+      end
+      mc = Class.new(Sequel::Model(@db[:soft_deletes_test]))
+      mc.class_eval do
+        attr_accessor :hook_body
+
+        def after_soft_delete
+          self.hook_body.call
+        end
+      end
+      mc.plugin(:soft_deletes, column: :deleted_at)
+      @m = mc.new
+    end
+
+    it "has its hook called whenever an instance is soft-deleted" do
+      called = false
+      @m.hook_body = lambda do
+        called = true
+      end
+      @m.soft_delete
+
+      expect(@m).to be_is_soft_deleted
+      expect(called).to eq(true)
+    end
+
+    it "is still soft-deleted even if its hook returns false" do
+      @m.hook_body = lambda do
+        false
+      end
+
+      expect { @m.soft_delete }.not_to raise_error
+
+      expect(@m).to be_is_soft_deleted
+    end
+  end
+
+  context "extended model classes with an 'around' soft-delete hook" do
+    before do
+      @db.create_table(:soft_deletes_test) do
+        primary_key :id
+        time :deleted_at
+      end
+      mc = Class.new(Sequel::Model(@db[:soft_deletes_test]))
+      mc.class_eval do
+        attr_accessor :hook_body
+
+        def around_soft_delete
+          super if self.hook_body.call
+        end
+      end
+      mc.plugin(:soft_deletes, column: :deleted_at)
+      @m = mc.new
+    end
+
+    it "has its hook called whenever an instance is soft-deleted" do
+      called = false
+      @m.hook_body = lambda do
+        called = true
+      end
+      @m.soft_delete
+      expect(@m).to be_is_soft_deleted
+      expect(called).to eq(true)
+    end
+
+    it "is not soft-deleted if its hook doesn't super" do
+      @m.hook_body = lambda do
+        false
+      end
+
+      expect do
+        @m.soft_delete
+      end.to raise_error(Sequel::HookFailed, /around_soft_delete hook failed/i)
+
+      expect(@m).not_to be_soft_deleted
+    end
+  end
+
+  context "extended model classes with deletion blockers" do
+    before do
+      @db.create_table(:soft_deletes_test) do
+        primary_key :id
+        time :deleted_at
+      end
+      mc = Class.new(Sequel::Model(@db[:soft_deletes_test]))
+      mc.class_eval do
+        attr_reader :stub_soft_deletion_blockers
+
+        def initialize(*)
+          @stub_soft_deletion_blockers = []
+          super
+        end
+
+        def soft_deletion_blockers
+          return self.stub_soft_deletion_blockers
+        end
+      end
+      mc.plugin(:soft_deletes, column: :deleted_at)
+      @m = mc.new
+    end
+
+    it "is not soft-deleted if it has deletion blockers" do
+      @m.stub_soft_deletion_blockers << "A BLOCKER"
+
+      expect do
+        @m.soft_delete
+      end.to raise_error(Sequel::HookFailed, /before_soft_delete hook failed/i)
+
+      expect(@m).not_to be_soft_deleted
+    end
+
+    it "raises an error if remove_soft_deletion_blockers hasn't been implemented" do
+      expect do
+        @m.remove_soft_deletion_blockers
+      end.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "sequel/plugins/soft_deletes"
+
+RSpec.configure do |config|
+  # config.full_backtrace = true
+
+  # RSpec::Support::ObjectFormatter.default_instance.max_formatted_output_length = 600
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+  config.disable_monkey_patching!
+  config.default_formatter = "doc" if config.files_to_run.one?
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: sequel-soft-deletes
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Lithic Tech
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: 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: rspec
+  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: rubocop
+  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: rubocop-performance
+  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: rubocop-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: rubocop-rspec
+  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: rubocop-sequel
+  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: sequel
+  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: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- hello@lithic.tech
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sequel/plugins/soft_deletes.rb
+- spec/sequel/plugins/soft_deletes_spec.rb
+- spec/spec_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: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Gem for enabling soft-deletion in tables
+test_files: []