discard 0.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e3d4174c8881bc3bf1fa453aafb3d966d8361292
-  data.tar.gz: 858b1edbe5d9c09144239a13cc3ca662f1485547
+SHA256:
+  metadata.gz: 27523357b203abf0f0928633448c778ec25ca89f36a9ec2e8178149b9a37ab67
+  data.tar.gz: 0650603e1aa80be6727824df9b74486fa8ad7af81f44074bf4c6db7b5b7c88cd
 SHA512:
-  metadata.gz: 1246d6187b35af15ceb8d5e8a1b914e09a45ba0380d833ca638305336d3075e67f60edc67fad55c49e994b0ab9e9f60b3d9a916acc837d3416b3b89ec56e2bcd
-  data.tar.gz: 1d098bf07dcefdd3d338b0a4a73b206dfd96e5c39b8abbabb17cd749970ff9c54efd3d35fe7f6f363f8c35b076b7e54f278f1f3cbb43de7330da0a363671f2f5
+  metadata.gz: e77b001ed871ddee9dcc0de5379b15c13370d5976b050cc1690dfd03d99898c6cde6993660bf379fc9d0c01e489655ec1b7d5d2f12bfd8176b9e68fbacc59841
+  data.tar.gz: d1e59a758e632ff4bfb96ae854e6b79eeb9a6eba76a6d6935f2f6fcad3c7f23fb4ee74e6562dc5055d89ddbc361dcab76440e5d5fa7f3ca6615513c3f763f9c9

data/.github/ISSUE_TEMPLATE/bug-report.md

@@ -0,0 +1,24 @@
+---
+name: Bug Report
+about: Is Discard not working correctly for you? Let us know!
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Additional context**
+Please tells us your Rails and Ruby versions, and anything else that might be helpful about the environment you encountered the issue.

data/.github/ISSUE_TEMPLATE/feature-proposal.md

@@ -0,0 +1,10 @@
+---
+name: Feature Proposal
+about: Discard is feature-complete, but we're happy to hear you out!
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Discard is feature-complete, but if you have an idea for a feature that will benefit all discard users and that won't offer a significant maintenance burden, we're happy to listen. Explain it as best you can and we'll let you know if it's something we'd like to have or if it's something that might be a better off as an extension or fork.**

data/.github/workflows/test.yml

@@ -0,0 +1,32 @@
+name: Test
+
+on:
+  push:
+    branches:
+    - master
+  pull_request:
+    branches:
+    - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Test on Rails ${{ matrix.rails_version }}
+    strategy:
+      matrix:
+        rails_version:
+          - ~> 5.1.0
+          - ~> 5.2.0
+          - ~> 6.0.0
+          - ~> 6.1.0
+          - ~> 7.0.0
+    container: docker://ruby
+    steps:
+    - uses: actions/checkout@v1
+    - name: Build and test
+      run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+        bundle exec rake
+      env:
+        RAILS_VERSION:  ${{ matrix.rails_version }}

data/.travis.yml

@@ -1,12 +1,28 @@
-sudo: false
 language: ruby
+cache: bundler
 rvm:
-  - 2.2.7
-  - 2.3.4
-  - 2.4.1
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+  - 2.7
 env:
   matrix:
-    - RAILS_VERSION='~> 4.2.0'
-    - RAILS_VERSION='~> 5.0.0'
-    - RAILS_VERSION='~> 5.1.x'
-before_install: gem install bundler -v 1.14.6
+    - RAILS_VERSION='~> 4.2.0' SQLITE_VERSION='~> 1.3.6'
+    - RAILS_VERSION='~> 5.0.0' SQLITE_VERSION='~> 1.3.6'
+    - RAILS_VERSION='~> 5.1.0'
+    - RAILS_VERSION='~> 5.2.0'
+    - RAILS_VERSION='~> 6.0.0'
+
+matrix:
+  exclude:
+    - rvm: 2.2
+      env: RAILS_VERSION='~> 6.0.0'
+    - rvm: 2.3
+      env: RAILS_VERSION='~> 6.0.0'
+    - rvm: 2.4
+      env: RAILS_VERSION='~> 6.0.0'
+    # Rails 4.2 uses BigDecimal.new, which Ruby 2.7 removed
+    - rvm: 2.7
+      env: RAILS_VERSION='~> 4.2.0' SQLITE_VERSION='~> 1.3.6'

data/.yardopts

@@ -0,0 +1,8 @@
+--protected
+--no-private
+--embed-mixin ClassMethods
+-
+README.md
+CHANGELOG.md
+CODE_OF_CONDUCT.md
+LICENSE.txt

data/CHANGELOG.md

@@ -0,0 +1,36 @@
+### Unreleased
+
+### Version 1.2.1
+Release date: 2021-12-16
+
+* Support for ActiveRecord 7
+
+### Version 1.2.0
+Release date: 2020-02-17
+
+* Add `discard_all!` and `undiscard_all!`
+* Add `undiscarded?` and `kept?` to match the scopes of the same names
+
+### Version 1.1.0
+Release date: 2019-05-03
+
+* Support for ActiveRecord 6
+* `discard_all` and `undiscard_all` now return affected records
+* Add `discard!` and `undiscard!`
+
+### Version 1.0.0
+Release date: 2018-03-16
+
+* Add undiscard callbacks and `.undiscard_all`
+
+### Version 0.2.0
+Release date: 2017-11-22
+
+* Add `.discard_all`
+* Add `undiscarded` scope
+* Add callbacks
+
+### Version 0.1.0
+Release date: 2017-04-28
+
+* Initial version!

data/Gemfile

@@ -3,5 +3,9 @@ source 'https://rubygems.org'
 rails_version = ENV['RAILS_VERSION']
 gem 'activerecord', rails_version
 
+if sqlite_version = ENV['SQLITE_VERSION']
+  gem 'sqlite3', sqlite_version
+end
+
 # Specify your gem's dependencies in discard.gemspec
 gemspec

data/README.md

@@ -8,42 +8,12 @@ Soft deletes for ActiveRecord done right.
 
 A simple ActiveRecord mixin to add conventions for flagging records as discarded.
 
-## Why should I use this?
-
-I've worked with and have helped maintain
-[paranoia](https://github.com/rubysherpas/paranoia) for a while. I'm convinced
-it does the wrong thing for most cases.
-
-Paranoia and
-[acts_as_paranoid](https://github.com/ActsAsParanoid/acts_as_paranoid) both
-attempt to emulate deletes by setting a column and adding a default scope on the
-model. This requires some ActiveRecord hackery, and leads to some surprising
-and awkward behaviour.
-
-* A default scope is added to hide soft-deleted records, which necessitates
-  adding `.with_deleted` to associations or anywhere soft-deleted records
-  should be found. :disappointed:
-  * Adding `belongs_to :child, -> { with_deleted }` helps, but doesn't work for
-    joins and eager-loading.
-* `delete` is overridden (`really_delete` will actually delete the record) :unamused:
-* `destroy` is overridden (`really_destroy` will actually delete the record) :pensive:
-* `dependent: :destroy` associations are deleted when performing soft-destroys :scream:
-  * requiring any dependent records to also be `acts_as_paranoid` to avoid losing data. :grimacing:
-
-There are some use cases where these behaviours make sense: if you really did
-want to _almost_ delete the record. More often developers are just looking to
-hide some records, or mark them as inactive.
-
-Discard takes a different approach. It doesn't override any ActiveRecord
-methods and instead simply provides convenience methods and scopes for
-discarding (hiding), restoring, and querying records.
-
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'discard'
+gem 'discard', '~> 1.2'
 ```
 
 And then execute:
@@ -62,33 +32,43 @@ class Post < ActiveRecord::Base
 end
 ```
 
+You can either generate a migration using:
+```
+rails generate migration add_discarded_at_to_posts discarded_at:datetime:index
+```
 
+or create one yourself like the one below:
 ``` ruby
 class AddDiscardToPosts < ActiveRecord::Migration[5.0]
-  def up
+  def change
     add_column :posts, :discarded_at, :datetime
+    add_index :posts, :discarded_at
   end
 end
 ```
 
 
-**Discard a record**
-```
+#### Discard a record
+
+```ruby
 Post.all             # => [#<Post id: 1, ...>]
 Post.kept            # => [#<Post id: 1, ...>]
 Post.discarded       # => []
 
-@post = Post.first   # => #<Post id: 1, ...>
-@post.discard!
-@post.discarded?     # => true
-@post.discarded_at   # => 2017-04-18 18:49:49 -0700
+post = Post.first   # => #<Post id: 1, ...>
+post.discard        # => true
+post.discard!       # => Discard::RecordNotDiscarded: Failed to discard the record
+post.discarded?     # => true
+post.undiscarded?   # => false
+post.kept?          # => false
+post.discarded_at   # => 2017-04-18 18:49:49 -0700
 
 Post.all             # => [#<Post id: 1, ...>]
 Post.kept            # => []
 Post.discarded       # => [#<Post id: 1, ...>]
 ```
 
-**From a controller**
+***From a controller***
 
 Controller actions need a small modification to discard records instead of deleting them. Just replace `destroy` with `discard`.
 
@@ -99,7 +79,26 @@ def destroy
 end
 ```
 
-**Working with associations**
+
+#### Undiscard a record
+
+```ruby
+post = Post.first   # => #<Post id: 1, ...>
+post.undiscard      # => true
+post.undiscard!     # => Discard::RecordNotUndiscarded: Failed to undiscard the record
+post.discarded_at   # => nil
+```
+
+***From a controller***
+
+```ruby
+def update
+  @post.undiscard
+  redirect_to users_url, notice: "Post undiscarded"
+end
+```
+
+#### Working with associations
 
 Under paranoia, soft deleting a record will destroy any `dependent: :destroy`
 associations. Probably not what you want! This leads to all dependent records
@@ -125,10 +124,14 @@ discarded. Just override the `kept` scope on the Comment model.
 
 ``` ruby
 class Comment < ActiveRecord::Base
-  has_many :posts
+  belongs_to :post
 
   include Discard::Model
-  scope :kept, -> { undiscarded.joins(:posts).merge(Post.kept) }
+  scope :kept, -> { undiscarded.joins(:post).merge(Post.kept) }
+
+  def kept?
+    undiscarded? && post.kept?
+  end
 end
 
 Comment.kept
@@ -144,7 +147,7 @@ SQL databases are very good at this, and performance should not be an issue.
 In both of these cases restoring either of these records will do right thing!
 
 
-**Default scope**
+#### Default scope
 
 It's usually undesirable to add a default scope. It will take more effort to
 work around and will cause more headaches. If you know you need a default scope, it's easy to add yourself ❤.
@@ -160,7 +163,7 @@ Post.with_discarded            # All Posts
 Post.with_discarded.discarded  # Only discarded posts
 ```
 
-**Custom column**
+#### Custom column
 
 If you're migrating from paranoia, you might want to continue using the same
 column.
@@ -172,12 +175,95 @@ class Post < ActiveRecord::Base
 end
 ```
 
+#### Callbacks
+
+Callbacks can be run before, after, or around the discard and undiscard operations.
+A likely use is discarding or deleting associated records (but see "Working with associations" for an alternative).
+
+``` ruby
+class Comment < ActiveRecord::Base
+  include Discard::Model
+end
+
+class Post < ActiveRecord::Base
+  include Discard::Model
+
+  has_many :comments
+
+  after_discard do
+    comments.discard_all
+  end
+
+  after_undiscard do
+    comments.undiscard_all
+  end
+end
+```
+
+*Warning:* Please note that callbacks for save and update are run when discarding/undiscarding a record
+
+
+#### Performance tuning
+`discard_all` and `undiscard_all` is intended to behave like `destroy_all` which has callbacks, validations, and does one query per record. If performance is a big concern, you may consider replacing it with:
+
+`scope.update_all(discarded_at: Time.current)`
+or
+`scope.update_all(discarded_at: nil)`
+
+#### Working with Devise
+
+A common use case is to apply discard to a User record. Even though a user has been discarded they can still login and continue their session.
+If you are using Devise and wish for discarded users to be unable to login and stop their session you can override Devise's method.
+
+```ruby
+class User < ActiveRecord::Base
+  def active_for_authentication?
+    super && !discarded?
+  end
+end
+```
+
 ## Non-features
 
-* Restoring records (this will probably be added)
-* Discarding dependent records (this will likely be added)
-* Callbacks (this will probably be added)
 * Special handling of AR counter cache columns - The counter cache counts the total number of records, both kept and discarded.
+* Recursive discards (like AR's dependent: destroy) - This can be avoided using queries (See "Working with associations") or emulated using callbacks.
+* Recursive restores - This concept is fundamentally broken, but not necessary if the recursive discards are avoided.
+
+## Extensions
+
+Discard provides the smallest subset of soft-deletion features that we think are useful to all users of the gem. We welcome the addition of gems that work with Discard to provide additional features.
+
+- [discard-rails-observers](https://github.com/pelargir/discard-rails-observers) integrates discard with the [rails-observers gem](https://github.com/rails/rails-observers)
+
+## Why not paranoia or acts_as_paranoid?
+
+I've worked with and have helped maintain
+[paranoia](https://github.com/rubysherpas/paranoia) for a while. I'm convinced
+it does the wrong thing for most cases.
+
+Paranoia and
+[acts_as_paranoid](https://github.com/ActsAsParanoid/acts_as_paranoid) both
+attempt to emulate deletes by setting a column and adding a default scope on the
+model. This requires some ActiveRecord hackery, and leads to some surprising
+and awkward behaviour.
+
+* A default scope is added to hide soft-deleted records, which necessitates
+  adding `.with_deleted` to associations or anywhere soft-deleted records
+  should be found. :disappointed:
+  * Adding `belongs_to :child, -> { with_deleted }` helps, but doesn't work for
+    joins and eager-loading [before Rails 5.2](https://github.com/rubysherpas/paranoia/issues/355)
+* `delete` is overridden (`really_delete` will actually delete the record) :unamused:
+* `destroy` is overridden (`really_destroy` will actually delete the record) :pensive:
+* `dependent: :destroy` associations are deleted when performing soft-destroys :scream:
+  * requiring any dependent records to also be `acts_as_paranoid` to avoid losing data. :grimacing:
+
+There are some use cases where these behaviours make sense: if you really did
+want to _almost_ delete the record. More often developers are just looking to
+hide some records, or mark them as inactive.
+
+Discard takes a different approach. It doesn't override any ActiveRecord
+methods and instead simply provides convenience methods and scopes for
+discarding (hiding), restoring, and querying records.
 
 ## Development
 
@@ -185,7 +271,11 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/jhawthorn/discard.
+Please consider filing an issue with the details of any features you'd like to see before implementing them. Discard is feature-complete and we are only interested in adding additional features that won't require substantial maintenance burden and that will benefit all users of the gem. We encourage anyone that needs additional or different behaviour to either create their own gem that builds off of discard or implement a new package with the different behaviour.
+
+Discard is very simple and we like it that way. Creating your own clone or fork with slightly different behaviour may not be that much work!
+
+If you find a bug in discard, please report it! We try to keep up with any issues and keep the gem running smoothly for everyone! You can report issues [here](https://github.com/jhawthorn/discard/issues).
 
 ## License
 

data/Rakefile

@@ -1,9 +1,8 @@
-require "bundler/gem_tasks"
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
-begin
-  require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec)
-rescue LoadError
-end
+RSpec::Core::RakeTask.new(:rspec)
 
-task :default => :spec
+desc 'Run the test suite'
+task default: :rspec

data/discard.gemspec

@@ -1,4 +1,5 @@
-# coding: utf-8
+# frozen_string_literal: true
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'discard/version'
@@ -21,8 +22,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activerecord", '>= 4.2', '< 6'
-  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_dependency "activerecord", ">= 4.2", "< 8"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.5.0"
   spec.add_development_dependency "database_cleaner", "~> 1.5"

data/lib/discard/errors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Discard
+  # = Discard Errors
+  #
+  # Generic exception class.
+  class DiscardError < StandardError
+  end
+
+  # Raised by {Discard::Model#discard!}
+  class RecordNotDiscarded < DiscardError
+    attr_reader :record
+
+    def initialize(message = nil, record = nil)
+      @record = record
+      super(message)
+    end
+  end
+
+  # Raised by {Discard::Model#undiscard!}
+  class RecordNotUndiscarded < DiscardError
+    attr_reader :record
+
+    def initialize(message = nil, record = nil)
+      @record = record
+      super(message)
+    end
+  end
+end

data/lib/discard/model.rb

@@ -1,4 +1,11 @@
+# frozen_string_literal: true
+
 module Discard
+  # Handles soft deletes of records.
+  #
+  # Options:
+  #
+  # - :discard_column - The columns used to track soft delete, defaults to `:discarded_at`.
   module Model
     extend ActiveSupport::Concern
 
@@ -12,32 +19,151 @@ module Discard
       scope :with_discarded, ->{ unscope(where: discard_column) }
 
       define_model_callbacks :discard
+      define_model_callbacks :undiscard
     end
 
-    class_methods do
+    # :nodoc:
+    module ClassMethods
+      # Discards the records by instantiating each
+      # record and calling its {#discard} method.
+      # Each object's callbacks are executed.
+      # Returns the collection of objects that were discarded.
+      #
+      # Note: Instantiation, callback execution, and update of each
+      # record can be time consuming when you're discarding many records at
+      # once. It generates at least one SQL +UPDATE+ query per record (or
+      # possibly more, to enforce your callbacks). If you want to discard many
+      # rows quickly, without concern for their associations or callbacks, use
+      # #update_all(discarded_at: Time.current) instead.
+      #
+      # ==== Examples
+      #
+      #   Person.where(age: 0..18).discard_all
       def discard_all
-        all.each(&:discard)
+        kept.each(&:discard)
+      end
+
+      # Discards the records by instantiating each
+      # record and calling its {#discard!} method.
+      # Each object's callbacks are executed.
+      # Returns the collection of objects that were discarded.
+      #
+      # Note: Instantiation, callback execution, and update of each
+      # record can be time consuming when you're discarding many records at
+      # once. It generates at least one SQL +UPDATE+ query per record (or
+      # possibly more, to enforce your callbacks). If you want to discard many
+      # rows quickly, without concern for their associations or callbacks, use
+      # #update_all!(discarded_at: Time.current) instead.
+      #
+      # ==== Examples
+      #
+      #   Person.where(age: 0..18).discard_all!
+      def discard_all!
+        kept.each(&:discard!)
+      end
+
+      # Undiscards the records by instantiating each
+      # record and calling its {#undiscard} method.
+      # Each object's callbacks are executed.
+      # Returns the collection of objects that were undiscarded.
+      #
+      # Note: Instantiation, callback execution, and update of each
+      # record can be time consuming when you're undiscarding many records at
+      # once. It generates at least one SQL +UPDATE+ query per record (or
+      # possibly more, to enforce your callbacks). If you want to undiscard many
+      # rows quickly, without concern for their associations or callbacks, use
+      # #update_all(discarded_at: nil) instead.
+      #
+      # ==== Examples
+      #
+      #   Person.where(age: 0..18).undiscard_all
+      def undiscard_all
+        discarded.each(&:undiscard)
+      end
+
+      # Undiscards the records by instantiating each
+      # record and calling its {#undiscard!} method.
+      # Each object's callbacks are executed.
+      # Returns the collection of objects that were undiscarded.
+      #
+      # Note: Instantiation, callback execution, and update of each
+      # record can be time consuming when you're undiscarding many records at
+      # once. It generates at least one SQL +UPDATE+ query per record (or
+      # possibly more, to enforce your callbacks). If you want to undiscard many
+      # rows quickly, without concern for their associations or callbacks, use
+      # #update_all!(discarded_at: nil) instead.
+      #
+      # ==== Examples
+      #
+      #   Person.where(age: 0..18).undiscard_all!
+      def undiscard_all!
+        discarded.each(&:undiscard!)
       end
     end
 
+    # @return [Boolean] true if this record has been discarded, otherwise false
     def discarded?
-      !!self[self.class.discard_column]
+      self[self.class.discard_column].present?
     end
 
+    # @return [Boolean] false if this record has been discarded, otherwise true
+    def undiscarded?
+      !discarded?
+    end
+    alias kept? undiscarded?
+
+    # Discard the record in the database
+    #
+    # @return [Boolean] true if successful, otherwise false
     def discard
-      unless discarded?
-        with_transaction_returning_status do
-          run_callbacks(:discard) do
-            self[self.class.discard_column] = Time.current
-            save
-          end
-        end
+      return false if discarded?
+      run_callbacks(:discard) do
+        update_attribute(self.class.discard_column, Time.current)
       end
     end
 
+    # Discard the record in the database
+    #
+    # There's a series of callbacks associated with #discard!. If the
+    # <tt>before_discard</tt> callback throws +:abort+ the action is cancelled
+    # and #discard! raises {Discard::RecordNotDiscarded}.
+    #
+    # @return [Boolean] true if successful
+    # @raise {Discard::RecordNotDiscarded}
+    def discard!
+      discard || _raise_record_not_discarded
+    end
+
+    # Undiscard the record in the database
+    #
+    # @return [Boolean] true if successful, otherwise false
     def undiscard
-      self[self.class.discard_column] = nil
-      save
+      return unless discarded?
+      run_callbacks(:undiscard) do
+        update_attribute(self.class.discard_column, nil)
+      end
+    end
+
+    # Discard the record in the database
+    #
+    # There's a series of callbacks associated with #undiscard!. If the
+    # <tt>before_undiscard</tt> callback throws +:abort+ the action is cancelled
+    # and #undiscard! raises {Discard::RecordNotUndiscarded}.
+    #
+    # @return [Boolean] true if successful
+    # @raise {Discard::RecordNotUndiscarded}
+    def undiscard!
+      undiscard || _raise_record_not_undiscarded
+    end
+
+    private
+
+    def _raise_record_not_discarded
+      raise ::Discard::RecordNotDiscarded.new("Failed to discard the record", self)
+    end
+
+    def _raise_record_not_undiscarded
+      raise ::Discard::RecordNotUndiscarded.new("Failed to undiscard the record", self)
     end
   end
 end

data/lib/discard/version.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 module Discard
-  VERSION = "0.2.0"
+  # Discard version
+  VERSION = "1.2.1".freeze
 end

data/lib/discard.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "active_record"
 
 require "discard/version"
+require "discard/errors"
 require "discard/model"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: discard
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - John Hawthorn
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2017-11-22 00:00:00.000000000 Z
+date: 2021-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,7 +19,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,21 +29,21 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '8'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -122,9 +122,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/ISSUE_TEMPLATE/bug-report.md"
+- ".github/ISSUE_TEMPLATE/feature-proposal.md"
+- ".github/workflows/test.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- ".yardopts"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -134,13 +139,14 @@ files:
 - bin/setup
 - discard.gemspec
 - lib/discard.rb
+- lib/discard/errors.rb
 - lib/discard/model.rb
 - lib/discard/version.rb
 homepage: https://github.com/jhawthorn/discard
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -155,9 +161,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: ActiveRecord soft-deletes done right
 test_files: []