console_think_twice 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dccea38c9288544ae02eea01191a0ed7187ed9187f85e90fdfd37387ca656aa6
-  data.tar.gz: 8bfd0ed5ca4daa26412dba1a43bbf9f2cb3090d49fc83aa9a99454771d20598b
+  metadata.gz: 236302689b1695ddb978506ea4a90c043c8cf03edb179b35ff053655c275297a
+  data.tar.gz: 84aab44ed6323c6fbbaa6cc1b2ef6872320335cd4cb8dbf6e86efb03f509a879
 SHA512:
-  metadata.gz: 869e288cb34127645618c7d0326ae421c1836f44c95f12295dbd057be52e178868397200559b544c4cca06fe02ba4dbf3ede34b90690d400585982d9cf172127
-  data.tar.gz: effa7750ad3ba639698a3e37a8ecd4c789a2f3ce2abbe74bfc093150d91cbe6d23bafb37424938a3239720198d14a79611509b20b8d94428ed73fb35389dbd7e
+  metadata.gz: 979ca9fbfa8533b0945653fc1207de763b4a80ddaac372acf37201d2ed0f4074c3686040d670d6b67ac3873ee408bf954935772e9b17e389e6a832a8cdd46817
+  data.tar.gz: 0e8e48c246db11faf5ab091e623789ef4b06253ddcf8e77bc8555df0e96310cb3e0835a79f849f8a565f73a65950617546e46f8ee91bec37e1ca29ad0e458580

data/CHANGELOG.md

@@ -2,7 +2,48 @@
 
 ## [Unreleased]
 
-## [0.1.0]
+## [0.3.0] - 2026-09-01
+
+### Added
+
+- `config.ignored_classes` leaves the classes you name unguarded, for tables that are
+  cleared as a matter of routine — `SolidCache::Entry`, say. Takes names or classes,
+  covers subclasses, and compares names rather than resolving them, so a class that is not
+  loaded, or not in this app at all, can be listed.
+
+## [0.2.0] - 2026-08-26
+
+### Fixed
+
+- Active Record's own destroys no longer prompt. A record marked `_destroy` by
+  `accepts_nested_attributes_for`, and the record a `has_one` assignment discards, were
+  asked about as though they had been typed — and asked from inside the enclosing call's
+  transaction, holding it and its locks open until somebody answered. Calls you type are
+  still guarded, including inside `transaction { ... }` and in a `--sandbox` console.
+- `collection.destroy(record, other)` asks once for the whole call rather than once per
+  record, and asks before the transaction is opened rather than inside it.
+- A blank `config.label` is left out of the prompt instead of printed. `false` rendered as
+  `"... Author #1false."`, and there was no way to turn the label off under Rails, where an
+  unset label falls back to `Rails.env`.
+- `config.enabled` takes effect when it changes, rather than only at `install!` time.
+- A forced call no longer counts the records it was told not to ask about, so
+  `destroy_all(force: true)` on a large table skips a needless `SELECT COUNT(*)`.
+- A confirmed call stays confirmed inside a fiber. Suppression used `Thread.current[]`,
+  which is fiber-local, so a destroy reached through an Enumerator prompted again.
+
+### Changed
+
+- `collection.delete(record)` is no longer guarded. It was only ever caught in passing, by
+  the guard on the record destroy underneath it, and what it means depends on the
+  association: without `dependent: :destroy` it unlinks the record rather than destroying
+  it, so the prompt could describe a permanent delete that was not one.
+
+### Added
+
+- `ConsoleThinkTwice.enable!`, the counterpart to `disable!`.
+- CI runs the suite against every supported Active Record, not only the newest.
+
+## [0.1.0] - 2026-08-26
 
 Initial release.
 
@@ -17,5 +58,7 @@ Initial release.
 - Non-interactive input refuses rather than assuming yes.
 - Configurable via `ConsoleThinkTwice.configure`, or turned off with `CONSOLE_THINK_TWICE=0`.
 
-[Unreleased]: https://github.com/agomezcampero/console-think-twice/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/agomezcampero/console-think-twice/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/agomezcampero/console-think-twice/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/agomezcampero/console-think-twice/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/agomezcampero/console-think-twice/releases/tag/v0.1.0

data/README.md

@@ -1,5 +1,6 @@
 # console_think_twice
 
+[![Gem Version](https://badge.fury.io/rb/console_think_twice.svg)](https://rubygems.org/gems/console_think_twice)
 [![CI](https://github.com/agomezcampero/console-think-twice/actions/workflows/ci.yml/badge.svg)](https://github.com/agomezcampero/console-think-twice/actions/workflows/ci.yml)
 
 Confirm before you destroy. `console_think_twice` intercepts destructive Active Record
@@ -27,14 +28,16 @@ Confirm? (y/N) y
 
 ## Installation
 
+Add it to your Gemfile:
+
 ```ruby
 gem "console_think_twice"
 ```
 
-Not on RubyGems yet — until it is, point at the repository:
+Then `bundle install`. Or:
 
-```ruby
-gem "console_think_twice", github: "agomezcampero/console-think-twice"
+```bash
+bundle add console_think_twice
 ```
 
 In a Rails app that is all — a railtie installs the guard from the `console` hook, which
@@ -51,6 +54,7 @@ Outside Rails, call `ConsoleThinkTwice.install!` once your models are loaded.
 | `record.delete` | `This will permanently delete, skipping callbacks, User #1.` |
 | `Model.destroy_all`, `relation.destroy_all`, `company.users.destroy_all` | `This will permanently destroy 200 Users.` |
 | `Model.delete_all`, `relation.delete_all` | `This will permanently delete, skipping callbacks, 200 Users.` |
+| `company.users.destroy(user, other)` | `This will permanently destroy 2 Users.` |
 
 `Model.destroy(id)`, `destroy_by` and `delete_by` route through those methods, so they are
 covered too.
@@ -66,6 +70,22 @@ A `dependent: :destroy` cascade destroys child records, and `destroy_all` destro
 records one at a time — both would otherwise prompt again for every record. Nested prompts
 are suppressed for the duration of a confirmed call, so you are asked exactly once.
 
+### What is not guarded
+
+`update_all`, `upsert_all` and anything run through `connection.execute` are untouched, as is
+`collection.delete(record)` — which unlinks the record rather than destroying it, unless the
+association says `dependent: :destroy`.
+
+Classes listed in `config.ignored_classes` are not guarded either — see below.
+
+Active Record also destroys records itself, as one step of a call that is about something
+else: a record marked `_destroy` by `accepts_nested_attributes_for`, or the old record a
+`has_one` assignment discards. Those do not prompt. They are already covered by whatever you
+typed to set them off, and they run inside that call's transaction — stopping to ask there
+would hold the transaction, and its locks, open until somebody answered. A destroy you type
+yourself is always asked about, including inside `transaction { ... }` and in a
+`rails console --sandbox`.
+
 ### Nobody to ask
 
 When the input stream is not a terminal — piped input, a script fed to `rails console` —
@@ -77,7 +97,9 @@ there is no one to answer, so the guard refuses the call instead of assuming yes
 ```ruby
 ConsoleThinkTwice.configure do |config|
   config.enabled = Rails.env.production?      # default: true, unless CONSOLE_THINK_TWICE is 0/false/no/off
-  config.label = "production (europe)"        # shown in the prompt; defaults to Rails.env
+  config.label = "production (europe)"        # shown in the prompt; defaults to Rails.env,
+                                              # set nil or false to leave it out
+  config.ignored_classes = %w[SolidCache::Entry]  # left unguarded; default: none
   config.affirmative_answers = %w[y yes si]   # default: %w[y yes]
   config.interactive = true                   # default: auto-detected from config.input.tty?
   config.input = $stdin
@@ -85,8 +107,24 @@ ConsoleThinkTwice.configure do |config|
 end
 ```
 
+### Classes to leave alone
+
+Some tables are cleared as a matter of routine — job records, cache entries, whatever your
+app treats as scratch. Being asked about those is noise, and noise teaches you to answer `y`
+without reading. List them and the guard stays out of the way:
+
+```ruby
+config.ignored_classes = %w[SolidCache::Entry SolidQueue::Job]
+```
+
+Classes work as well as names, and a subclass of a listed class is ignored too. Names are
+compared rather than resolved, so listing a class that this app does not have, or has not
+autoloaded yet, is fine.
+
 Set `CONSOLE_THINK_TWICE=0` in the environment to turn the guard off without touching
-code. `ConsoleThinkTwice.disable!` turns it off for the rest of the current session.
+code. `ConsoleThinkTwice.disable!` turns it off for the rest of the current session and
+`ConsoleThinkTwice.enable!` turns it back on; setting `config.enabled` takes effect straight
+away too, without reinstalling.
 
 ## Development
 
@@ -97,6 +135,13 @@ bundle exec rspec
 bundle exec standardrb
 ```
 
+The guard reads Active Record's own call stack to tell your calls from its, so the suite is
+run against every supported Active Record, not just the newest. Delete `Gemfile.lock`, then:
+
+```bash
+ACTIVERECORD_VERSION=7.0 bundle install && ACTIVERECORD_VERSION=7.0 bundle exec rspec
+```
+
 ## License
 
 MIT. See [LICENSE](LICENSE).

data/lib/console_think_twice/collection_guard.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ConsoleThinkTwice
+  # Guards the collection methods that name their records, rather than describing them with a
+  # scope. Prepended to CollectionProxy only: ActiveRecord::Relation has a `destroy` of its own
+  # that takes an id and means something different.
+  module CollectionGuard
+    # `books.destroy(a, b)` destroys the records it is handed one at a time. Asking here rather
+    # than once per record keeps it to a single prompt, and keeps the prompt outside the
+    # transaction Active Record opens to do the work.
+    def destroy(*records, force: false)
+      ConsoleThinkTwice.guard(self, action: :destroy, force: force, count: records.size) do
+        super(*records)
+      end
+    end
+  end
+end

data/lib/console_think_twice/configuration.rb

@@ -21,6 +21,27 @@ module ConsoleThinkTwice
       @output || $stdout
     end
 
+    # Classes the guard leaves alone. Bookkeeping tables that are cleared as a matter of
+    # routine — `SolidCache::Entry`, say — are noise to be asked about, and being asked
+    # about them teaches you to answer y without reading. Takes names or classes, and a
+    # subclass of a listed class is ignored too.
+    #
+    # Names are compared rather than resolved, so a class can be listed before it is
+    # autoloaded, or listed in an initializer shared by apps that do not all have it.
+    def ignored_classes=(classes)
+      @ignored_classes = Array(classes).map(&:to_s)
+    end
+
+    def ignored_classes
+      @ignored_classes ||= []
+    end
+
+    def ignores?(model)
+      return false if ignored_classes.empty?
+
+      inheritance_chain(model).any? { |name| ignored_classes.include?(name) }
+    end
+
     def enabled?
       return @enabled unless @enabled.nil?
 
@@ -35,11 +56,23 @@ module ConsoleThinkTwice
       input.respond_to?(:tty?) && input.tty?
     end
 
-    # Shown in the prompt to make the stakes obvious, e.g. "in production".
+    # Shown in the prompt to make the stakes obvious, e.g. "in production". Defaults to the
+    # Rails environment; assigning any value at all — nil and false included — wins over that,
+    # so the label can be turned off as well as changed.
     def label
-      return @label unless @label.nil?
+      return @label if defined?(@label)
 
       ::Rails.env.to_s if defined?(::Rails) && ::Rails.respond_to?(:env)
     end
+
+    private
+
+    # The model's own name and the names of the models it inherits from, so that ignoring a
+    # class ignores its subclasses. Stops at Active Record itself, which every model shares.
+    def inheritance_chain(model)
+      Enumerator.produce(model, &:superclass)
+        .take_while { |klass| klass && klass != ::ActiveRecord::Base }
+        .map(&:name)
+    end
   end
 end

data/lib/console_think_twice/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConsoleThinkTwice
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/console_think_twice.rb

@@ -7,6 +7,7 @@ require_relative "console_think_twice/version"
 require_relative "console_think_twice/configuration"
 require_relative "console_think_twice/record_guard"
 require_relative "console_think_twice/relation_guard"
+require_relative "console_think_twice/collection_guard"
 
 # Confirmation prompts for destructive Active Record calls typed into a console.
 #
@@ -24,6 +25,17 @@ module ConsoleThinkTwice
   CASCADING_STRATEGIES = %i[destroy destroy_async delete_all].freeze
   SUPPRESSION_KEY = :console_think_twice_suppressed
 
+  # Source files belonging to Rails itself. Matched on the path rather than resolved from
+  # Gem.loaded_specs so that a vendored or git-checkout Rails is recognised too.
+  RAILS_SOURCE = %r{/active_(?:record|support|model)/}
+
+  # The Active Record internals that destroy a record as one step of a larger operation:
+  # association bookkeeping, autosave, and nested attributes.
+  RAILS_INTERNAL_WORK = %r{/active_record/(?:associations/|autosave_association\.rb|nested_attributes\.rb)}
+
+  # This gem's own frames, skipped when looking for the caller of a guarded method.
+  GEM_SOURCE = __dir__
+
   class << self
     def configuration
       @configuration ||= Configuration.new
@@ -38,8 +50,11 @@ module ConsoleThinkTwice
 
       unless @installed
         ActiveRecord::Base.prepend(RecordGuard)
+        # CollectionProxy overrides destroy_all and delete_all rather than inheriting them,
+        # so guarding Relation alone would miss every has_many collection.
         ActiveRecord::Relation.prepend(RelationGuard)
         ActiveRecord::Associations::CollectionProxy.prepend(RelationGuard)
+        ActiveRecord::Associations::CollectionProxy.prepend(CollectionGuard)
         @installed = true
       end
 
@@ -52,24 +67,77 @@ module ConsoleThinkTwice
       @active = false
     end
 
+    def enable!
+      @active = true
+    end
+
     def active?
-      !!@active
+      !!@active && configuration.enabled?
     end
 
     # Confirms the call, then runs it with nested prompts suppressed so that a `dependent:`
     # cascade, or a relation destroying its records one by one, only ever asks once.
-    def guard(target, action:, force:)
-      return yield if !active? || suppressed?
-
-      count = affected_count(target)
-      return yield if count.zero?
+    #
+    # `count` is passed when the caller already knows how many records are involved, which
+    # saves a COUNT and is the only way to size a call like `books.destroy(a, b)` that names
+    # its records rather than describing them.
+    def guard(target, action:, force:, count: nil)
+      return yield if !active? || suppressed? || ignored?(target)
+
+      # Active Record's own work is confirmed by whatever the user typed to set it off, so it
+      # runs suppressed rather than merely unguarded: `destroy!` re-enters as `destroy`, and
+      # that second hop is dispatched from persistence.rb, where nothing marks it as internal.
+      return suppressed { yield } if nested_in_active_record?(target)
+
+      unless force
+        count ||= affected_count(target)
+        return yield if count.zero?
+
+        confirm!(target, action, count)
+      end
 
-      confirm!(target, action, count) unless force
       suppressed { yield }
     end
 
     private
 
+    def ignored?(target)
+      configuration.ignores?(model_of(target))
+    end
+
+    # True when Active Record itself made this call as one step of an operation already under
+    # way: a record being removed by `accepts_nested_attributes_for`, a `has_one` being
+    # replaced, a collection destroying the records it was handed. Those run inside the
+    # enclosing call's transaction, so prompting would hold that transaction — and its locks —
+    # open until somebody answers, and would ask about a record the user never named.
+    #
+    # Both conditions are required, because neither separates the two cases alone. A destroy
+    # typed inside `transaction { ... }`, or into a `--sandbox` console, has a transaction open
+    # but is still the user's own call; and `Model.destroy_all` is dispatched from inside
+    # Active Record, but only through the delegation in querying.rb rather than through the
+    # association and autosave code that does this work.
+    def nested_in_active_record?(target)
+      return false unless open_transaction?(target)
+
+      dispatch_chain.any? { |path| RAILS_INTERNAL_WORK.match?(path) }
+    end
+
+    # The frames Active Record itself put between the caller and us: everything above the first
+    # frame that belongs to neither this gem nor Rails, which is the code that made the call.
+    # An unrecognisable frame ends the chain, so anything we cannot read is treated as the
+    # caller's own and asked about rather than skipped.
+    def dispatch_chain
+      frames = (caller_locations(1, 50) || []).map { |location| location.path.to_s }
+      frames.drop_while { |path| path.start_with?(GEM_SOURCE) }
+        .take_while { |path| RAILS_SOURCE.match?(path) }
+    end
+
+    def open_transaction?(target)
+      model_of(target).connection.open_transactions > 0
+    rescue
+      false
+    end
+
     def confirm!(target, action, count)
       summary = summarize(target, action, count)
       unless configuration.interactive?
@@ -100,7 +168,9 @@ module ConsoleThinkTwice
         "#{count} #{(count == 1) ? model : model.pluralize}"
       end
 
-      ["This will #{verb} #{subject}", configuration.label && " in #{configuration.label}", "."].compact.join
+      label = configuration.label
+      where = (label && !label.to_s.empty?) ? " in #{label}" : ""
+      "This will #{verb} #{subject}#{where}."
     end
 
     def affected_count(target)
@@ -119,16 +189,18 @@ module ConsoleThinkTwice
         .map(&:name)
     end
 
+    # Thread-local rather than fiber-local (which is what Thread.current[] gives), so that a
+    # confirmed call still counts as confirmed inside an Enumerator or any other fiber.
     def suppressed?
-      Thread.current[SUPPRESSION_KEY]
+      Thread.current.thread_variable_get(SUPPRESSION_KEY)
     end
 
     def suppressed
-      previous = Thread.current[SUPPRESSION_KEY]
-      Thread.current[SUPPRESSION_KEY] = true
+      previous = Thread.current.thread_variable_get(SUPPRESSION_KEY)
+      Thread.current.thread_variable_set(SUPPRESSION_KEY, true)
       yield
     ensure
-      Thread.current[SUPPRESSION_KEY] = previous
+      Thread.current.thread_variable_set(SUPPRESSION_KEY, previous)
     end
 
     def announce

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: console_think_twice
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Agustin Gomez
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-26 00:00:00.000000000 Z
+date: 2026-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -51,6 +51,7 @@ files:
 - LICENSE
 - README.md
 - lib/console_think_twice.rb
+- lib/console_think_twice/collection_guard.rb
 - lib/console_think_twice/configuration.rb
 - lib/console_think_twice/railtie.rb
 - lib/console_think_twice/record_guard.rb