console_think_twice 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dccea38c9288544ae02eea01191a0ed7187ed9187f85e90fdfd37387ca656aa6
-  data.tar.gz: 8bfd0ed5ca4daa26412dba1a43bbf9f2cb3090d49fc83aa9a99454771d20598b
+  metadata.gz: 4a6b253a3a4ae99d15459e9c03389d8939e9a9851372c2b7eadab198564ec7f1
+  data.tar.gz: '09efc4fd77651863aff72c3f578dc27ce30074cd96c190bd6a8da882c7b42e58'
 SHA512:
-  metadata.gz: 869e288cb34127645618c7d0326ae421c1836f44c95f12295dbd057be52e178868397200559b544c4cca06fe02ba4dbf3ede34b90690d400585982d9cf172127
-  data.tar.gz: effa7750ad3ba639698a3e37a8ecd4c789a2f3ce2abbe74bfc093150d91cbe6d23bafb37424938a3239720198d14a79611509b20b8d94428ed73fb35389dbd7e
+  metadata.gz: 3071ebb09d7533f2c733b487b94cfba26d895bf39ca9efd5a76718afdb703051f32c6fd34e1b4fdeccc7d171e7401a261315d2919ffde8542eb50a0c2ac9e5be
+  data.tar.gz: 9c2f40efb4837679488438af2f4d46169d75cca4e3410802a349d871f59effdcda4484792c3596f2d776031d2c9ff1a13c03637d2be2312c350bc20dcbc5f49e

data/CHANGELOG.md

@@ -2,7 +2,39 @@
 
 ## [Unreleased]
 
-## [0.1.0]
+## [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 +49,6 @@ 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.2.0...HEAD
+[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,20 @@ 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`.
+
+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 +95,8 @@ 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.affirmative_answers = %w[y yes si]   # default: %w[y yes]
   config.interactive = true                   # default: auto-detected from config.input.tty?
   config.input = $stdin
@@ -86,7 +105,9 @@ end
 ```
 
 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 +118,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

@@ -35,9 +35,11 @@ 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

data/lib/console_think_twice/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConsoleThinkTwice
-  VERSION = "0.1.0"
+  VERSION = "0.2.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,73 @@ 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:)
+    #
+    # `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?
 
-      count = affected_count(target)
-      return yield if count.zero?
+      # 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
 
+    # 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 +164,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 +185,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.2.0
 platform: ruby
 authors:
 - Agustin Gomez
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-26 00:00:00.000000000 Z
+date: 2026-08-27 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