rubocop-dev_doc 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d7cebd4d2c1b85850d5a704dc26319f49526040c26d2573824f68461d42ae8c
-  data.tar.gz: 5fede674c17c29dd330e9499a1367c3f1174902b0a76c44d94c7f6683a35d130
+  metadata.gz: 7d3924b0184e741e19b3f29854b6f472a9bd54667ddfef1e59ccc1aa000e5073
+  data.tar.gz: d59338919f825edec8ed8bbc717d26f19782fbc88411d90e1a8e0c110d07235d
 SHA512:
-  metadata.gz: 7b3666259413a6d37a6d13765c095005fd8395f1033a6d33de9539616b75d0e3d5091b26ab27ade88069ecd9c678231bd3126f116eb60a36db4e1220c50fefde
-  data.tar.gz: 2fcbae3b394369ab9e969a0edc7f1b7ba2379b4572f73e3311228fe265ab29285ebe34a7635d43f7bf02c9ab8e56921454b94817323c723a473fc37e20999726
+  metadata.gz: 606dad217da6a65ddc8eb66040f2f8747be5fed37aa27764f2ae74a2fa2266158e848d780b2ee10a7d690f20832b0c36b3a5b3b16d766c433c99088226b78c8e
+  data.tar.gz: 49cac436e0dfef59326c94b89187c5d6001578972d0faa76f2fca683cfd93b9dc1e5866093351884a49e0ad58cb0f6f768a4711275f57e6bf85d24efc913137f

data/config/default.yml

@@ -31,6 +31,10 @@ DevDoc/Test:
   DocumentationBaseURL: https://github.com/hgani/dev-doc/blob/main/docs/cops
   DocumentationExtension: ".md"
 
+DevDoc/View:
+  DocumentationBaseURL: https://github.com/hgani/dev-doc/blob/main/docs/cops
+  DocumentationExtension: ".md"
+
 DevDoc/Migration/AvoidJsonColumn:
   Description: "Use `jsonb` instead of `json` for column types."
   Enabled: true
@@ -83,11 +87,22 @@ DevDoc/Migration/BooleanColumnNotNull:
 # Intentionally global (no Include) — these patterns are risky in any file, not only migrations.
 # Add project-specific Exclude entries (e.g. db/seeds.rb, lib/tasks/**/*.rb) in your .rubocop.yml
 # for places where bulk operations are intentional and performance-critical.
+#
+# Strict SUPERSET of Rails/SkipsModelValidations: covers all 18 methods that
+# cop flags, plus `delete_all` and `save(validate: false)`, with per-method
+# actionable messages. When enabling this cop, DISABLE the stock one —
+# otherwise every offense needs a disable comment naming both cops:
+#   Rails/SkipsModelValidations:
+#     Enabled: false
+# Use AllowedMethods for skips that are by-design in your project (touch,
+# counter caches) instead of per-site disables.
 DevDoc/Migration/AvoidBypassingValidation:
-  Description: "Avoid methods that bypass validations and callbacks (`update_column`, `update_all`, `insert_all`, etc.)."
+  Description: "Avoid methods that bypass validations and callbacks (`update_column`, `update_all`, `insert_all`, `touch`, etc.). Superset of Rails/SkipsModelValidations — disable that cop when enabling this one."
   Enabled: false
+  AllowedMethods: []
   Exclude:
     - "spec/**/*"
+    - "test/**/*"
 
 DevDoc/Migration/DateColumnNaming:
   Description: "Date columns should end with `_on`; datetime columns should end with `_at`."
@@ -299,6 +314,51 @@ DevDoc/Style/StringSymbolComparison:
   Description: "Comparing a known-string source (params, request.headers, ENV) to a symbol literal is always false."
   Enabled: true
 
+DevDoc/Style/LiteralOrInWhenClause:
+  Description: "`||`/`&&` between literals in a `when` clause folds to one value — the other literal silently never matches; use comma-separated alternatives."
+  Enabled: true
+  # Autocorrect (|| chains of truthy literals -> comma list) deliberately changes
+  # behavior: the dead alternative starts matching. That is the fix, but re-verify
+  # any code that depended on the buggy match — hence unsafe.
+  SafeAutoCorrect: false
+
+DevDoc/Style/RedundantGuardAfterBang:
+  Description: "A nil/presence guard right after assigning from a bang method is dead code — bang methods raise on failure instead of returning nil."
+  Enabled: true
+  # Ruby-core mutator bangs legitimately return nil when nothing changed, so
+  # guarding them is real logic, not a dead guard. Extend this list for any
+  # app-specific bang with deliberate nil-on-no-op semantics (or better, rename
+  # such a method — a nil-returning `!` is itself misleading).
+  AllowedMethods:
+    - gsub!
+    - sub!
+    - strip!
+    - lstrip!
+    - rstrip!
+    - chomp!
+    - chop!
+    - squeeze!
+    - tr!
+    - tr_s!
+    - delete!
+    - delete_prefix!
+    - delete_suffix!
+    - capitalize!
+    - downcase!
+    - upcase!
+    - swapcase!
+    - slice!
+    - uniq!
+    - compact!
+    - flatten!
+    - reject!
+    - select!
+    - filter!
+
+DevDoc/Style/LiteralOperatorInCondition:
+  Description: "`||` between literals in a boolean condition (if/unless/while/until/ternary) folds to one operand, making the condition constant. Flag only — the fix depends on intent. `&&` is left to Lint/LiteralAsCondition."
+  Enabled: true
+
 DevDoc/Test/ResponseAssertEqual:
   Description: "Controller tests that assert on `response.body` should also snapshot the full response with `response_assert_equal`."
   # Enabled by default. A project adopting the gem with an existing backlog will
@@ -377,6 +437,19 @@ DevDoc/Test/AvoidGlibTravelFreeze:
     - "test/**/*.rb"
     - "spec/**/*.rb"
 
+DevDoc/Test/RequireGlibTravelBlock:
+  Description: "`glib_travel` must be called with a block — the bare anchor form leaks frozen time past the test. A bare duration argument (`glib_travel(61.seconds)`) that advances the clock is the accepted non-block form."
+  Enabled: true
+  Include:
+    - "test/**/*.rb"
+    - "spec/**/*.rb"
+
+DevDoc/Test/RequireGlibTravel:
+  Description: "Controller tests must freeze time inside a `glib_travel` (or `glib_travel_freeze`) block — they integrate HTTP, DB, and the clock, so deterministic time is required."
+  Enabled: true
+  Include:
+    - "test/controllers/**/*_test.rb"
+
 DevDoc/Test/AvoidUnitTest:
   Description: "Prefer controller tests; unit tests (`< ActiveSupport::TestCase`) are a rare, justified exception."
   Enabled: true
@@ -384,6 +457,53 @@ DevDoc/Test/AvoidUnitTest:
     - "test/**/*.rb"
     - "spec/**/*.rb"
 
+DevDoc/Test/RequireGlibIntegrationBase:
+  Description: "Integration tests in HTTP-driven directories must subclass the project base (Glib::IntegrationTest) — the raw framework base sidesteps the runtime HTTP lint and the glib plumbing."
+  Enabled: true
+  RequiredBase: Glib::IntegrationTest
+  LegacyBases:
+    - ActionDispatch::IntegrationTest
+  Include:
+    - "test/controllers/**/*_test.rb"
+    - "test/integration/**/*_test.rb"
+
+DevDoc/Test/RequireUnitTestJustification:
+  Description: "Every test file must live in a recognized directory; unit-test directories additionally require a justification header (marker phrase: 'deliberate exception')."
+  Enabled: true
+  MarkerPhrase: "deliberate exception"
+  # Total classification — Include deliberately covers ALL test files so a test
+  # can't dodge enforcement by being placed in an invented directory. Note
+  # AvoidUnitTest's base-class heuristic is evadable when a project's universal
+  # test base already descends from ActionDispatch::IntegrationTest — this cop
+  # plus the runtime lint DevDoc::Test::Lints::HttpDrivenControllerTests (which
+  # guarantees everything under test/controllers/ actually drives HTTP) close
+  # that hole from both sides:
+  #   - ExemptDirectories: otherwise-enforced or accepted integration-shaped
+  #     homes. Inheriting a unit base (UnitBaseClasses) there is still an
+  #     offense — a unit test parked in an exempt directory would dodge both the
+  #     header rule and the runtime lint (which only reaches integration-base
+  #     descendants).
+  #   - UnitTestDirectories: allowed only with the justification header.
+  #   - Anything else (including test/ root): flagged as unrecognized — adding a
+  #     new test home is a reviewed config change, not an implicit act.
+  UnitBaseClasses:
+    - Glib::LastResortUnitTest
+  UnitTestDirectories:
+    - models
+    - services
+    - helpers
+  ExemptDirectories:
+    - controllers
+    - integration
+    - jobs
+    - mailers
+    - channels
+    - system
+    - linters
+    - tasks
+  Include:
+    - "test/**/*_test.rb"
+
 Naming/PredicatePrefix:
   Enabled: false
 
@@ -425,11 +545,28 @@ DevDoc/I18n/AvoidTitleizeHumanize:
   Severity: warning
   Methods:
     - titleize
+    - titlecase # ActiveSupport's documented alias of titleize — not a dodge
     - humanize
   Include:
     - "app/views/**/*.jbuilder"
     - "app/views/**/*.rb"
 
+DevDoc/View/PreferPropOverName:
+  Description: "Bind form fields to model attributes with `prop:` (i18n-resolved label/placeholder) instead of a raw `name: 'model[attr]'` with hardcoded text."
+  # Disabled by default (new department) — enable per consumer .rubocop.yml.
+  # fields_hidden is exempt out of the box: no label/placeholder to hardcode,
+  # and hidden fields (echoed tokens, dynamic-group indexes, forced values)
+  # are the dominant legitimate raw-`name:` users. Autocorrect is unsafe: it
+  # drops the `model` segment (prop: binds to the FORM's model) and leaves
+  # sibling label:/placeholder: for manual removal.
+  Enabled: false
+  SafeAutoCorrect: false
+  ExemptFieldMethods:
+    - fields_hidden
+  Include:
+    - "app/views/**/*.jbuilder"
+    - "app/views/**/*.rb"
+
 DevDoc/I18n/RequireTranslation:
   Description: "Localize user-facing strings in glib JSON-UI props; pass `t(...)` instead of a hardcoded string."
   Enabled: false

data/lib/dev_doc/test/lints/duplicate_snapshot.rb

@@ -17,6 +17,10 @@ module DevDoc
         # duplicate group: `# allow_duplicate_snapshot: <reason>`.
         MARKER = 'allow_duplicate_snapshot'.freeze
 
+        # A bare marker with no reason is mechanics without policy — the
+        # reason is the reviewable part, so it is mandatory.
+        MARKER_WITH_REASON = /#{MARKER}\s*:\s*\S/
+
         # Matches a minitest `test '...' do` declaration; captures the quote
         # (1), the name (2), and the trailing content after `do` (3).
         TEST_DEFINITION = /^\s*test\s+(["'])(.+?)\1\s+do\b(.*)$/
@@ -86,10 +90,12 @@ module DevDoc
         end
 
         # A test is marked if the opt-out token appears on its `do` line's
-        # trailing comment, or on the comment line directly above it.
+        # trailing comment, or on the comment line directly above it. The
+        # token only counts WITH a reason (`allow_duplicate_snapshot: <why>`)
+        # — a bare marker still fails, so the opt-out cannot be cargo-culted.
         def marked?(trailing, lines, index)
           context = trailing.to_s + (index.positive? ? lines[index - 1] : '')
-          context.include?(MARKER)
+          context.match?(MARKER_WITH_REASON)
         end
 
         # Resolve the test file for a `*_results` dir. Usually it's the

data/lib/dev_doc/test/lints/http_driven_controller_tests.rb

@@ -0,0 +1,92 @@
+module DevDoc
+  module Test
+    module Lints
+      # Runtime guarantee that every test under `test/controllers/` actually
+      # drives the app through HTTP. Include into the project's base
+      # integration test class (a descendant of ActionDispatch::IntegrationTest):
+      #
+      #   Glib::IntegrationTest.include DevDoc::Test::Lints::HttpDrivenControllerTests
+      #
+      # ## Rationale
+      # Best practice (see AvoidUnitTest) prefers controller tests because they
+      # exercise the wiring a user actually hits. Static enforcement keyed on
+      # base class or file name is trivially evaded — and observed evasions by
+      # AI agents include: naming files ambiguously, mixing unit tests into
+      # controller test files, and inheriting the integration base class so the
+      # `< ActiveSupport::TestCase` heuristic never fires.
+      #
+      # This lint closes those holes by keying on *observed behavior*:
+      # `ActionDispatch::Integration::Runner#process` is the single choke point
+      # every request helper funnels through (`get`/`post`/... — no matter how
+      # deeply wrapped in `log_user_in`-style helpers), so "issued at least one
+      # request" is checked per test, not per file. A unit test cannot pass it
+      # by renaming, relocating within the file, or subclassing anything.
+      #
+      # There is deliberately NO opt-out flag: a test that never issues a
+      # request does not belong under `test/controllers/`. Move it to the
+      # matching directory (`test/models/`, `test/jobs/`, ...) with the
+      # justification header your project's conventions require
+      # (see DevDoc/Test/RequireUnitTestJustification).
+      module HttpDrivenControllerTests
+        CONTROLLER_TEST_PATH = %r{(\A|/)test/controllers/}
+
+        MESSAGE = <<~MSG.freeze
+          %<location>s lives under test/controllers/ but never issued an HTTP request —
+          it is a unit test in controller-test clothing. Convert it to drive the app
+          through a request (the bugs live in the wiring), or move it to the directory
+          matching what it exercises (test/models/, test/jobs/, ...) with a documented
+          justification header.
+        MSG
+
+        def before_setup
+          @__dev_doc_http_request_count = 0
+          super
+        end
+
+        # ActionDispatch::Integration::Runner defines the verb helpers on the
+        # test case; each delegates to integration_session.process. Overriding
+        # the verbs here (the module sits ahead of Runner in the MRO) sees every
+        # request no matter how deeply wrapped in project helpers —
+        # `follow_redirect!` also funnels through these.
+        %i[get post patch put delete head options].each do |verb|
+          define_method(verb) do |*args, **kwargs, &block|
+            @__dev_doc_http_request_count = @__dev_doc_http_request_count.to_i + 1
+            super(*args, **kwargs, &block)
+          end
+        end
+
+        def after_teardown
+          super
+        ensure
+          __dev_doc_check_http_driven
+        end
+
+        private
+
+        def __dev_doc_check_http_driven
+          return unless __dev_doc_controller_test?
+          return if skipped? || !passed? # don't mask the test's own failure
+          return if @__dev_doc_http_request_count.to_i.positive?
+
+          raise Minitest::Assertion, format(MESSAGE, location: __dev_doc_test_location)
+        end
+
+        def __dev_doc_controller_test?
+          (__dev_doc_source_file || '') =~ CONTROLLER_TEST_PATH
+        end
+
+        # The file the test method is defined in — robust against shared helpers
+        # because `test '...'` macros define the method at their call site.
+        def __dev_doc_source_file
+          method(name).source_location&.first
+        rescue NameError
+          nil
+        end
+
+        def __dev_doc_test_location
+          "#{self.class}##{name} (#{__dev_doc_source_file})"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dev_doc/i18n/avoid_titleize_humanize.rb

@@ -35,7 +35,9 @@ module RuboCop
           MSG = 'Avoid `.%<method>s` for display text: the result is ' \
                 'English-only and bypasses I18n. Use `t(...)` instead.'.freeze
 
-          DEFAULT_METHODS = %w[titleize humanize].freeze
+          # titlecase is ActiveSupport's documented alias of titleize — same
+          # English-only output, so it must not be an alias-shaped dodge.
+          DEFAULT_METHODS = %w[titleize titlecase humanize].freeze
 
           def on_send(node)
             return unless forbidden_methods.include?(node.method_name.to_s)

data/lib/rubocop/cop/dev_doc/i18n/translation_key_prefix.rb

@@ -45,7 +45,9 @@ module RuboCop
           MSG = 'Translation key `%<key>s` must start with an allowed ' \
                 'prefix: %<prefixes>s.'.freeze
 
-          RESTRICT_ON_SEND = %i[t translate].freeze
+          # t!/translate! are public I18n API (raise instead of returning the
+          # missing-translation marker) — same lookup, same prefix rule.
+          RESTRICT_ON_SEND = %i[t translate t! translate!].freeze
 
           def on_send(node)
             prefixes = allowed_prefixes

data/lib/rubocop/cop/dev_doc/migration/avoid_bypassing_validation.rb

@@ -14,6 +14,17 @@ module RuboCop
         # reason why existing records may be invalid. If there is, fix those
         # records first rather than bypassing validation.
         #
+        # ## Relationship with Rails/SkipsModelValidations
+        # This cop is a strict SUPERSET of the stock `Rails/SkipsModelValidations`
+        # (it covers every method that cop flags, plus `delete_all` and
+        # `save(validate: false)`), with per-method actionable messages instead
+        # of a generic one. Consumer projects should enable THIS cop and disable
+        # `Rails/SkipsModelValidations` — running both forces every disable
+        # comment to name two cops for the same offense. Methods that skip
+        # validations BY DESIGN in your domain (e.g. `touch`, counter-cache
+        # maintenance) can be permitted wholesale via `AllowedMethods` rather
+        # than disabled per site.
+        #
         #   ❌ Bypasses validation — hides data integrity issues
         #   Faq.where(purpose: nil).update_all(purpose: :intro)
         #
@@ -45,31 +56,88 @@ module RuboCop
           MESSAGES = {
             update_column: 'Avoid `update_column`; it bypasses validations. Use `save!` instead.',
             update_columns: 'Avoid `update_columns`; it bypasses validations. Use `save!` instead.',
+            update_attribute: 'Avoid `update_attribute`; it bypasses validations (the singular is not ' \
+                              'a validating `update`). Use `update!` instead.',
             update_all: 'Avoid `update_all`; it bypasses validations. Use `save!` in a loop instead.',
+            insert: 'Avoid `insert`; it bypasses validations. Use `create!` instead, ' \
+                    'or `# rubocop:disable` with a reason if a raw insert is intentional.',
+            insert!: 'Avoid `insert!`; it bypasses validations (the bang is about duplicate keys, ' \
+                     'not validity). Use `create!` instead.',
             insert_all: 'Avoid `insert_all`; it bypasses validations. Use `create!` in a loop, ' \
                         'or `# rubocop:disable` with a reason if bulk-insert is intentional.',
+            upsert: 'Avoid `upsert`; it bypasses validations. Use `create!`/`update!` instead, ' \
+                    'or `# rubocop:disable` with a reason if a raw upsert is intentional.',
             upsert_all: 'Avoid `upsert_all`; it bypasses validations. Use `create!`/`update!` in a loop, ' \
                         'or `# rubocop:disable` with a reason if bulk-upsert is intentional.',
+            toggle!: 'Avoid `toggle!`; it saves without validations. Use `toggle(...).save!` instead.',
+            increment!: 'Avoid `increment!`; it writes without validations. Use `increment(...).save!` instead.',
+            decrement!: 'Avoid `decrement!`; it writes without validations. Use `decrement(...).save!` instead.',
+            increment_counter: 'Avoid `increment_counter`; it issues a direct UPDATE that bypasses validations ' \
+                               'and callbacks. Use the record with `save!`, or `AllowedMethods` for deliberate ' \
+                               'counter-cache maintenance.',
+            decrement_counter: 'Avoid `decrement_counter`; it issues a direct UPDATE that bypasses validations ' \
+                               'and callbacks. Use the record with `save!`, or `AllowedMethods` for deliberate ' \
+                               'counter-cache maintenance.',
+            update_counters: 'Avoid `update_counters`; it issues a direct UPDATE that bypasses validations ' \
+                             'and callbacks. Use the record with `save!`, or `AllowedMethods` for deliberate ' \
+                             'counter-cache maintenance.',
+            touch: 'Avoid `touch`; it writes timestamps without validations or save callbacks. Use `save!` ' \
+                   '(`updated_at` updates automatically), or `AllowedMethods` if bare timestamp bumps are ' \
+                   'accepted in this project.',
+            touch_all: 'Avoid `touch_all`; it issues a bulk UPDATE that bypasses validations and callbacks. ' \
+                       'Iterate with `save!`, or `# rubocop:disable` with a reason if a bulk timestamp bump ' \
+                       'is intentional.',
+            insert_all!: 'Avoid `insert_all!`; it bypasses validations (the bang is about duplicate keys, ' \
+                         'not validity). Use `create!` in a loop, or `# rubocop:disable` with a reason if ' \
+                         'bulk-insert is intentional.',
             delete_all: 'Avoid `delete_all`; it bypasses callbacks. Use `destroy_all` to run callbacks, ' \
                         'or `# rubocop:disable` with a reason if bulk-delete is intentional.'
           }.freeze
 
           SAVE_MSG = 'Avoid `save(validate: false)`; it bypasses validations. Use `save!` instead.'.freeze
 
-          RESTRICT_ON_SEND = %i[update_column update_columns update_all insert_all upsert_all delete_all save].freeze
+          RESTRICT_ON_SEND = (MESSAGES.keys + %i[save]).freeze
+
+          # insert/insert!/upsert are AR *class-level* APIs (User.insert(...)),
+          # while `insert` on a non-const receiver is everyday Array#insert —
+          # flag only the const-receiver form to avoid false positives.
+          CONST_RECEIVER_ONLY = %i[insert insert! upsert].freeze
+
+          # The inverse for touch: the AR form is instance-level
+          # (`record.touch`), while a const receiver is `FileUtils.touch` or
+          # similar — not an ActiveRecord write at all.
+          NON_CONST_RECEIVER_ONLY = %i[touch].freeze
 
           def on_send(node)
+            return if allowed_methods.include?(node.method_name.to_s)
+
             if node.method?(:save)
               return unless save_with_validate_false?(node)
 
               add_offense(node.loc.selector, message: SAVE_MSG)
             else
+              return unless receiver_shape_matches?(node)
+
               add_offense(node.loc.selector, message: MESSAGES[node.method_name])
             end
           end
 
           private
 
+          def receiver_shape_matches?(node)
+            return node.receiver&.const_type? if CONST_RECEIVER_ONLY.include?(node.method_name)
+            return !node.receiver&.const_type? if NON_CONST_RECEIVER_ONLY.include?(node.method_name)
+
+            true
+          end
+
+          # Methods a project accepts wholesale as by-design validation skips
+          # (e.g. `touch`, counter-cache maintenance) — configure in
+          # .rubocop.yml instead of scattering per-site disables.
+          def allowed_methods
+            cop_config.fetch('AllowedMethods', []).map(&:to_s)
+          end
+
           def save_with_validate_false?(node)
             node.arguments.any? do |arg|
               next unless arg.hash_type?

data/lib/rubocop/cop/dev_doc/rails/application_record_transaction.rb

@@ -34,7 +34,10 @@ module RuboCop
         class ApplicationRecordTransaction < Base
           extend AutoCorrector
 
-          ALLOWED_RECEIVERS = %w[ApplicationRecord ActiveRecord::Base].freeze
+          # Source-string comparison, so the cbase-qualified spellings must be
+          # listed too — `::ApplicationRecord.transaction` was a false positive.
+          ALLOWED_RECEIVERS = %w[ApplicationRecord ::ApplicationRecord
+                                 ActiveRecord::Base ::ActiveRecord::Base].freeze
 
           MSG = 'Use `ApplicationRecord.transaction` instead of `%<receiver>s.transaction` outside model files.'.freeze
           RESTRICT_ON_SEND = %i[transaction].freeze

data/lib/rubocop/cop/dev_doc/rails/avoid_rails_callbacks.rb

@@ -115,12 +115,17 @@ module RuboCop
         #     send_confirmation if saved
         #   end
         class AvoidRailsCallbacks < Base
+          # Includes every *_commit shorthand and the underlying set_callback
+          # API — omitting any of them (after_update_commit was missed for a
+          # while) leaves a zero-effort spelling of the same callback.
           CALLBACKS = %i[
-            after_create after_create_commit after_save after_update
-            after_destroy after_commit after_rollback after_initialize
+            after_create after_create_commit after_save after_save_commit
+            after_update after_update_commit after_destroy after_destroy_commit
+            after_commit before_commit after_rollback after_initialize
             after_find after_touch before_create before_save before_update
             before_destroy before_validation after_validation
             around_create around_save around_update around_destroy
+            set_callback
           ].freeze
 
           MSG = 'Avoid `%<method>s` — extract an explicit method (e.g. `save_with_*`) ' \

data/lib/rubocop/cop/dev_doc/rails/bang_save_in_transaction.rb

@@ -64,7 +64,10 @@ module RuboCop
           MSG = 'Use `%<bang>s` inside a `transaction` block, or check its return value. ' \
                 'A non-bang call whose return value is discarded does not roll back the transaction on failure.'.freeze
 
-          FLAGGED_METHODS = %i[save update create].freeze
+          # destroy has the same failure mode: it returns false when a
+          # before_destroy callback aborts, and a discarded false does not
+          # roll the transaction back.
+          FLAGGED_METHODS = %i[save update create destroy].freeze
 
           # Node types whose parent always means the return value is consumed.
           CONSUMING_PARENT_TYPES = %i[
@@ -87,9 +90,11 @@ module RuboCop
 
           private
 
+          # with_lock opens a transaction too, so a discarded non-bang save
+          # inside it fails just as silently.
           def inside_transaction?(node)
             node.each_ancestor(:block).any? do |ancestor|
-              ancestor.method_name == :transaction
+              %i[transaction with_lock].include?(ancestor.method_name)
             end
           end
 

data/lib/rubocop/cop/dev_doc/rails/enum_must_be_symbolized.rb

@@ -32,6 +32,16 @@ module RuboCop
         #   ✔
         #   enum_symbolize :payment_status, :finalize_intent
         #
+        # Enums declared inside a concern's `included do` block are checked the
+        # same way — the pairing must live in the same `included do` block,
+        # which is also where it belongs so every includer gets both:
+        #
+        #   ✔
+        #   included do
+        #     enum :discount_type, DISCOUNT_TYPES
+        #     enum_symbolize :discount_type
+        #   end
+        #
         # @example
         #   # bad
         #   enum :status, { active: 0, archived: 1 }
@@ -51,24 +61,29 @@ module RuboCop
             (send nil? :enum_symbolize $...)
           PATTERN
 
+          def_node_matcher :included_block?, <<~PATTERN
+            (block (send nil? :included) (args) _)
+          PATTERN
+
           def on_class(node)
-            body = node.body
-            return unless body
+            check_body(node.body)
+          end
 
-            statements = body.begin_type? ? body.children : [body]
+          # Concern-declared enums: `included do ... end` runs in the including
+          # class's context, so its statements are checked like a class body.
+          def on_block(node)
+            return unless included_block?(node)
 
-            enum_decls = []
-            symbolized = []
+            check_body(node.body)
+          end
 
-            statements.each do |stmt|
-              next unless stmt.respond_to?(:send_type?) && stmt.send_type?
+          private
 
-              if (name = enum_call(stmt))
-                enum_decls << [name, stmt]
-              elsif (args = enum_symbolize_call(stmt))
-                symbolized.concat(args.select(&:sym_type?).map(&:value))
-              end
-            end
+          def check_body(body)
+            return unless body
+
+            statements = body.begin_type? ? body.children : [body]
+            enum_decls, symbolized = scan(statements)
 
             enum_decls.each do |name, decl|
               next if symbolized.include?(name)
@@ -76,6 +91,20 @@ module RuboCop
               add_offense(decl, message: format(MSG, name: name))
             end
           end
+
+          def scan(statements)
+            sends = statements.select { |stmt| stmt.respond_to?(:send_type?) && stmt.send_type? }
+            enum_decls = sends.filter_map { |stmt| (name = enum_call(stmt)) && [name, stmt] }
+            symbolized = sends.flat_map { |stmt| symbolized_names(stmt) }
+            [enum_decls, symbolized]
+          end
+
+          def symbolized_names(stmt)
+            args = enum_symbolize_call(stmt)
+            return [] unless args
+
+            args.select(&:sym_type?).map(&:value)
+          end
         end
       end
     end

data/lib/rubocop/cop/dev_doc/rails/no_block_predicate_on_relation.rb

@@ -104,7 +104,9 @@ module RuboCop
           MSG = '`%<method>s` with a block loads every row into Ruby. ' \
                 'Push the predicate into SQL with `.where(...)` or a model scope.'.freeze
 
-          RESTRICT_ON_SEND = %i[count reject select find any?].freeze
+          # filter/detect are the Ruby aliases of select/find — leaving them
+          # out would make the alias a zero-cost dodge.
+          RESTRICT_ON_SEND = %i[count reject select filter find detect any?].freeze
 
           # Methods whose return value is known to be a non-Relation collection
           # (Array, Hash, or Enumerator). When a `.select`/`.reject`/etc. with a
@@ -129,7 +131,7 @@ module RuboCop
           ].freeze
 
           def on_send(node)
-            return unless node.block_literal?
+            return unless node.block_literal? || symbol_block_pass?(node)
             return if node.receiver.nil?
             return if excluded_receiver?(node.receiver)
             return if excluded_block?(node)
@@ -139,6 +141,13 @@ module RuboCop
 
           private
 
+          # `reject(&:archived?)` loads every row exactly like the literal
+          # block form — one character shorter, so it must not be a dodge.
+          def symbol_block_pass?(node)
+            last = node.last_argument
+            last&.block_pass_type? && last.children.first&.sym_type?
+          end
+
           def excluded_receiver?(receiver)
             return true if receiver.array_type? || receiver.hash_type?
             return true if receiver.const_type? && screaming_case_const?(receiver)

data/lib/rubocop/cop/dev_doc/rails/no_deliver_later_in_transaction.rb

@@ -55,7 +55,10 @@ module RuboCop
         class NoDeliverLaterInTransaction < Base
           MSG = '`%<method>s` inside a `transaction` block may use stale data. Move it outside the transaction.'.freeze
 
-          CORE_METHODS = %i[deliver_later perform_later].freeze
+          # Also the bang form, the bulk API, and the enqueue primitive that
+          # perform_later wraps — each is an equally easy spelling of the same
+          # premature enqueue.
+          CORE_METHODS = %i[deliver_later deliver_later! perform_later perform_all_later enqueue].freeze
 
           def on_send(node)
             return unless inside_transaction?(node)
@@ -74,9 +77,11 @@ module RuboCop
             cop_config.fetch('KnownAsyncWrappers', [])
           end
 
+          # with_lock opens a transaction too (lock! inside a transaction
+          # block), so an enqueue inside it has the identical hazard.
           def inside_transaction?(node)
             node.each_ancestor(:block).any? do |ancestor|
-              ancestor.method_name == :transaction
+              %i[transaction with_lock].include?(ancestor.method_name)
             end
           end
         end