rubocop-dev_doc 0.7.0 → 0.8.0

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

@@ -47,12 +47,16 @@ module RuboCop
         #     OrderJob.perform_later(self)
         #   end
         class NoPerformLaterInModel < Base
-          MSG = 'Avoid `perform_later` in model files. Call it from the controller, ' \
-                'or use an explicit method name to signal the side effect.'.freeze
-          RESTRICT_ON_SEND = %i[perform_later].freeze
+          MSG = 'Avoid `%<method>s` in model files — it enqueues an ActiveJob (mailer deliveries ' \
+                'included), with the same transaction/stale-data hazard as `perform_later`. Call it ' \
+                'from the controller, or use an explicit method name to signal the side effect.'.freeze
+          # deliver_later is ActiveJob under the hood (MailDeliveryJob) and
+          # enqueue is the primitive perform_later wraps — omitting either
+          # would leave an everyday spelling of the same async enqueue.
+          RESTRICT_ON_SEND = %i[perform_later perform_all_later deliver_later deliver_later! enqueue].freeze
 
           def on_send(node)
-            add_offense(node.loc.selector)
+            add_offense(node.loc.selector, message: format(MSG, method: node.method_name))
           end
         end
       end

data/lib/rubocop/cop/dev_doc/style/avoid_head_response.rb

@@ -60,7 +60,9 @@ module RuboCop
           ].freeze
 
           def on_send(node)
-            return unless node.receiver.nil?
+            # `self.head(...)` is the same controller call — a bare receiver
+            # check would make explicit-self a one-token dodge.
+            return unless node.receiver.nil? || node.receiver.self_type?
 
             status_node = node.arguments.first
             return unless status_node

data/lib/rubocop/cop/dev_doc/style/avoid_send.rb

@@ -62,7 +62,9 @@ module RuboCop
         class AvoidSend < Base
           MSG = "Avoid dynamic `%<method>s` — use bracket notation for model attributes, " \
                 "or a prefix (`obj.send(\"export_\#{x}\")`) to restrict callable methods.".freeze
-          RESTRICT_ON_SEND = %i[send public_send].freeze
+          # `__send__` is the canonical alias — omitting it would leave a
+          # zero-cost dodge for the exact dynamic dispatch this cop restricts.
+          RESTRICT_ON_SEND = %i[send public_send __send__].freeze
 
           def on_send(node)
             return if node.receiver.nil?

data/lib/rubocop/cop/dev_doc/style/literal_operator_in_condition.rb

@@ -0,0 +1,103 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Style
+        # Flag `||` between literals in a boolean condition (`if`, `unless`,
+        # `while`, `until`, and ternary). The operator folds to one operand
+        # immediately (`:a || :b` is just `:a`), so the condition is constant —
+        # the branch (or loop body) always runs the same way, and the other
+        # literal is dead.
+        #
+        # ## Rationale
+        # `if :billing || :payments` reads like "either is truthy" but compiles
+        # to `if :billing` — always truthy. The author almost certainly meant a
+        # real comparison (`==`) or a variable, not two literal alternatives.
+        # Unlike `DevDoc/Style/LiteralOrInWhenClause`, a condition has no
+        # comma-form alternative, so the right fix depends on intent and is NOT
+        # autocorrected — the cop only flags.
+        #
+        # Scoped to `||` only: core `Lint/LiteralAsCondition` already catches
+        # literal `&&` chains and single literals, but misses `||` chains and
+        # ternaries — this cop fills exactly that gap with no overlap.
+        #
+        #   ❌ always truthy — :payments is dead
+        #   if :billing || :payments
+        #     charge
+        #   end
+        #
+        #   ✔️ a real comparison
+        #   if status == :billing || status == :payments
+        #     charge
+        #   end
+        #
+        # @example
+        #   # bad
+        #   x = (:a || :b) ? one : two
+        #
+        #   # good
+        #   x = (val == :a || val == :b) ? one : two
+        class LiteralOperatorInCondition < Base
+          MSG = '`%<source>s` always evaluates to `%<result>s`, so this condition is constant.'.freeze
+
+          LITERAL_TYPES = %i[sym str int float true false nil].freeze
+          FALSY_TYPES = %i[false nil].freeze
+
+          # `unless` desugars to `if` and the ternary `? :` is an `if` node, so a
+          # single on_if covers both (plus modifier forms). `until` mirrors
+          # `while` — both expose `condition`.
+          def on_if(node)
+            check(node.condition)
+          end
+
+          def on_while(node)
+            check(node.condition)
+          end
+
+          alias on_until on_while
+
+          private
+
+          def check(condition)
+            inner = unwrap_begin(condition)
+            return unless inner.or_type?
+
+            leaves = flatten_chain(inner)
+            return unless leaves.all? { |leaf| LITERAL_TYPES.include?(leaf.type) }
+
+            add_offense(
+              inner,
+              message: format(MSG, source: inner.source, result: fold(leaves).source)
+            )
+          end
+
+          # The helpers below parallel DevDoc/Style/LiteralOrInWhenClause
+          # (`||`-only here). Lift them into a shared module if a third consumer
+          # appears; duplicated for now to keep that cop untouched.
+
+          # Parentheses wrap a condition in a `begin` node; unwrap it.
+          def unwrap_begin(node)
+            node = node.children.first while node.begin_type?
+            node
+          end
+
+          # Flatten a homogeneous `||` chain into its operand nodes. An operand
+          # wrapped in parentheses arrives as a `begin` node (`(:a || :b) || :c`),
+          # so unwrap before recursing; otherwise the inner chain reads as a
+          # single non-literal leaf and slips past the all-literal check.
+          def flatten_chain(node)
+            node = unwrap_begin(node)
+            return [node] unless node.or_type?
+
+            flatten_chain(node.lhs) + flatten_chain(node.rhs)
+          end
+
+          # The first truthy literal the `||` chain folds to (or its last
+          # operand when the whole chain is nil/false).
+          def fold(leaves)
+            leaves.find { |leaf| !FALSY_TYPES.include?(leaf.type) } || leaves.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dev_doc/style/literal_or_in_when_clause.rb

@@ -0,0 +1,134 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Style
+        # Flag `||` / `&&` between literals inside a `when` clause. The operator
+        # evaluates immediately (`:a || :b` is just `:a`), so the other literal
+        # silently never matches — `when` alternatives must be comma-separated.
+        #
+        # ## Rationale
+        # `when :issuing_country || :nationality` reads like "either of these"
+        # but compiles to `when :issuing_country`; the `:nationality` branch is
+        # dead from day one and nothing at runtime ever hints at it. No core or
+        # rubocop-rails cop catches this shape. Restricted to literal operands
+        # the pattern is provably wrong, so the false-positive surface is
+        # effectively zero (`when SOME_CONST || fallback` and variable operands
+        # are left alone — unusual, but potentially intentional).
+        #
+        #   ❌ :nationality can never match
+        #   when :issuing_country || :nationality
+        #
+        #   ✔️ comma-separated alternatives
+        #   when :issuing_country, :nationality
+        #
+        # Autocorrect rewrites `||` chains to a comma list. It is marked unsafe
+        # because it deliberately changes behavior: the dead alternative starts
+        # matching, which is the fix — but any code relying on the buggy
+        # behavior must be re-verified. Chains containing `nil`/`false` and all
+        # `&&` forms are flagged without autocorrect (the intent is ambiguous).
+        #
+        # @example
+        #   # bad
+        #   case topic
+        #   when :billing || :payments
+        #     route_to_finance
+        #   end
+        #
+        #   # good
+        #   case topic
+        #   when :billing, :payments
+        #     route_to_finance
+        #   end
+        class LiteralOrInWhenClause < Base
+          extend AutoCorrector
+
+          MSG = '`%<source>s` evaluates immediately to `%<result>s`, so the other ' \
+                'literal(s) in it can never match this `when` clause. List ' \
+                'alternatives with commas instead: `when %<list>s`.'.freeze
+
+          LITERAL_TYPES = %i[sym str int float true false nil].freeze
+          FALSY_TYPES = %i[false nil].freeze
+
+          def on_case(node)
+            node.when_branches.each do |branch|
+              branch.conditions.each { |condition| check(condition) }
+            end
+          end
+
+          private
+
+          def check(condition)
+            inner = unwrap_begin(condition)
+            return unless inner.or_type? || inner.and_type?
+
+            leaves = flatten_chain(inner, inner.type)
+            return unless leaves.all? { |leaf| LITERAL_TYPES.include?(leaf.type) }
+
+            add_offense(inner, message: offense_message(inner, leaves)) do |corrector|
+              next unless autocorrectable_chain?(inner, leaves)
+
+              corrector.replace(rewrite_range(condition), comma_list(leaves))
+            end
+          end
+
+          # Parentheses wrap a condition in a `begin` node; unwrap it for
+          # inspection while keeping the outer node for the autocorrect range.
+          def unwrap_begin(node)
+            node = node.children.first while node.begin_type?
+            node
+          end
+
+          # Replace the full condition including wrapping parentheses, so
+          # `when (:a || :b)` becomes `when :a, :b` rather than `when (:a, :b)`.
+          def rewrite_range(condition)
+            return condition unless condition.begin_type? && condition.loc.begin
+
+            condition.loc.begin.join(condition.loc.end)
+          end
+
+          def offense_message(condition, leaves)
+            format(
+              MSG,
+              source: condition.source,
+              result: fold(leaves, condition.type).source,
+              list: comma_list(leaves)
+            )
+          end
+
+          def comma_list(leaves)
+            leaves.map(&:source).join(', ')
+          end
+
+          # Flatten a homogeneous `||` (or `&&`) chain into its operand nodes.
+          # A mixed-operator chain yields operand nodes of differing types,
+          # which the caller's literal-type check then filters out. An operand
+          # wrapped in parentheses arrives as a `begin` node
+          # (`(:a || :b) || :c`), so unwrap before recursing; otherwise the
+          # inner chain reads as a single non-literal leaf and evades the check.
+          def flatten_chain(node, operator)
+            node = unwrap_begin(node)
+            return [node] unless node.type == operator
+
+            flatten_chain(node.lhs, operator) + flatten_chain(node.rhs, operator)
+          end
+
+          # The single literal the operator chain folds to.
+          def fold(leaves, operator)
+            if operator == :or
+              leaves.find { |leaf| !FALSY_TYPES.include?(leaf.type) } || leaves.last
+            else
+              leaves.find { |leaf| FALSY_TYPES.include?(leaf.type) } || leaves.last
+            end
+          end
+
+          # Only rewrite `||` chains of truthy literals: there the comma list is
+          # unambiguously what was meant. `nil`/`false` operands and `&&` forms
+          # have no clear when-clause intent, so they are flagged only.
+          def autocorrectable_chain?(condition, leaves)
+            condition.or_type? && leaves.none? { |leaf| FALSY_TYPES.include?(leaf.type) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dev_doc/style/no_unscoped_method_definitions.rb

@@ -74,7 +74,9 @@ module RuboCop
                 'or inside a DSL block (e.g. Rake `namespace`). ' \
                 'Methods defined here land on `Object` and can silently collide across files.'.freeze
 
-          DEFAULT_SAFE_DSL_RECEIVERS = %w[Struct Class Module].freeze
+          # Data (Ruby 3.2 value objects) scopes block-defined methods to the
+          # new class exactly like Struct.
+          DEFAULT_SAFE_DSL_RECEIVERS = %w[Struct Data Class Module].freeze
 
           def on_def(node)
             add_offense(node.loc.keyword) unless enclosed_in_class_or_module?(node)

data/lib/rubocop/cop/dev_doc/style/prefer_public_send.rb

@@ -67,17 +67,19 @@ module RuboCop
         #   # good — receiver-less send (calling self's own method)
         #   send(:internal_helper)
         class PreferPublicSend < Base
-          MSG = 'Prefer `public_send` over `send` — it respects method ' \
+          MSG = 'Prefer `public_send` over `%<method>s` — it respects method ' \
                 'visibility, surfacing typos/misconfig that would otherwise ' \
                 'silently invoke a private method. Disable with a reason ' \
                 'when bypassing visibility is intentional.'.freeze
 
-          RESTRICT_ON_SEND = %i[send].freeze
+          # `__send__` is the canonical alias — omitting it would leave a
+          # zero-cost visibility bypass that dodges this cop entirely.
+          RESTRICT_ON_SEND = %i[send __send__].freeze
 
           def on_send(node)
             return if node.receiver.nil?
 
-            add_offense(node.loc.selector)
+            add_offense(node.loc.selector, message: format(MSG, method: node.method_name))
           end
         end
       end

data/lib/rubocop/cop/dev_doc/style/redundant_guard_after_bang.rb

@@ -0,0 +1,155 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Style
+        # Flag a nil/presence guard on a variable that was just assigned from a
+        # bang method. Bang methods raise on failure instead of returning
+        # nil/false, so the guard can never fire — it is dead code that hides
+        # the real contract and invites style churn (e.g. `Rails/Presence`
+        # "fixing" the guard's shape instead of questioning its existence).
+        #
+        # ## Rationale
+        # By convention a `!` method signals failure by raising (`create!`,
+        # `save!`, `find_by!`, custom `do_thing!`). Guarding its result reads
+        # as if nil were possible, which misleads reviewers about the failure
+        # mode and preserves defensive noise through refactors. The fix is to
+        # delete the guard, not to restyle it.
+        #
+        # Ruby-core mutator bangs (`gsub!`, `uniq!`, `compact!`, ...) are the
+        # exception — they return nil when nothing changed, so guarding them is
+        # legitimate. Those are excluded via the default `AllowedMethods`; add
+        # any app-specific nil-returning bang there too (or better, rename it,
+        # since a nil-returning `!` method is itself misleading).
+        #
+        # Caveat on `present?`/`blank?`: for a bang that returns a possibly-empty
+        # collection or string, a `present?` check is emptiness logic rather than
+        # a nil-guard, and is NOT dead — the cop cannot distinguish this
+        # statically, so such methods also belong in `AllowedMethods`. Plain
+        # truthiness (`if x`), `nil?`, and `&.` guards carry no such ambiguity:
+        # `[]` and `""` are truthy, so those forms only ever test for nil.
+        #
+        #   ❌ dead guard — create! raises rather than return nil
+        #   snapshot = create_snapshot!(**attrs)
+        #   if snapshot.present?
+        #     snapshot.update_columns(version: version)
+        #   end
+        #
+        #   ✔️ no guard — the bang contract is the guard
+        #   snapshot = create_snapshot!(**attrs)
+        #   snapshot.update_columns(version: version)
+        #
+        #   ✔️ core mutator bang — nil means "no change", guard is real logic
+        #   cleaned = name.strip!
+        #   apply(cleaned) if cleaned
+        #
+        # @example
+        #   # bad
+        #   record = Order.create!(params)
+        #   record&.notify_owner
+        #
+        #   # good
+        #   record = Order.create!(params)
+        #   record.notify_owner
+        class RedundantGuardAfterBang < Base
+          MSG = '`%<method>s` raises on failure instead of returning nil, ' \
+                'so this guard on `%<var>s` is dead; remove it.'.freeze
+
+          # Value assigned from a plain (non-safe-navigation) send, with or
+          # without a block (named or numbered params). `obj&.create!` is
+          # deliberately not matched: a nil receiver nils the whole expression,
+          # making a guard legitimate.
+          def_node_matcher :bang_call, <<~PATTERN
+            {
+              (send _ $_ ...)
+              (block (send _ $_ ...) ...)
+              (numblock (send _ $_ ...) ...)
+            }
+          PATTERN
+
+          def_node_matcher :truthiness_condition?, <<~PATTERN
+            {
+              ({lvar ivar} %1)
+              (send ({lvar ivar} %1) {:present? :nil? :blank?})
+              (send (send ({lvar ivar} %1) :nil?) :!)
+            }
+          PATTERN
+
+          def_node_matcher :safe_navigation_on_var?, <<~PATTERN
+            {
+              (csend ({lvar ivar} %1) ...)
+              (csend (send ({lvar ivar} %1) :presence) ...)
+            }
+          PATTERN
+
+          def on_lvasgn(node)
+            # `a ||= x` wraps a value-less lvasgn in an or_asgn; nothing to check.
+            return unless node.expression
+
+            method_name = bang_call(node.expression)
+            return unless bang_method?(method_name)
+            return if allowed_method?(method_name)
+
+            following = next_sibling(node)
+            return unless following
+
+            guard = guard_node(following, node.name)
+            return unless guard
+
+            add_offense(guard, message: format(MSG, method: method_name, var: node.name))
+          end
+          alias on_ivasgn on_lvasgn
+
+          private
+
+          # Only the statement immediately after the assignment is considered:
+          # once other code intervenes, the variable may have been reassigned
+          # and the deadness is no longer provable.
+          def next_sibling(node)
+            parent = node.parent
+            return nil unless parent&.begin_type?
+
+            parent.children[node.sibling_index + 1]
+          end
+
+          def guard_node(stmt, var)
+            return stmt.condition if stmt.if_type? && guard_condition?(stmt.condition, var)
+            return stmt if safe_navigation_on_var?(stmt, var)
+
+            embedded_safe_navigation(stmt, var)
+          end
+
+          # A dead guard can sit in the condition itself, not only as the
+          # whole statement: `if record&.persisted?` is the same dead `&.` as
+          # a standalone `record&.foo` (the bang never returned nil).
+          def guard_condition?(condition, var)
+            truthiness_condition?(condition, var) || safe_navigation_on_var?(condition, var)
+          end
+
+          # y = x&.foo — the guard is embedded in another assignment's value.
+          def embedded_safe_navigation(stmt, var)
+            return nil unless stmt.respond_to?(:expression)
+
+            value = stmt.expression
+            return nil unless value.is_a?(RuboCop::AST::Node)
+
+            value if safe_navigation_on_var?(value, var)
+          end
+
+          def allowed_method?(method_name)
+            cop_config.fetch('AllowedMethods', []).include?(method_name.to_s)
+          end
+
+          # A trailing `!` signals raise-on-failure by convention. The unary
+          # negation operator parses as method `:!`, which also ends in `!` but
+          # is not a bang method, so it is excluded.
+          def bang_method?(method_name)
+            return false unless method_name
+
+            name = method_name.to_s
+            name.end_with?('!') && name != '!'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dev_doc/test/avoid_glib_travel_freeze.rb

@@ -36,15 +36,18 @@ module RuboCop
         #     expect(order.expired?).to be true
         #   end
         class AvoidGlibTravelFreeze < Base
-          MSG = 'Avoid `glib_travel_freeze` — use `glib_travel` instead. ' \
+          MSG = 'Avoid `%<method>s` — use `glib_travel` instead. ' \
                 'Frozen time masks timing bugs that surface in production. ' \
                 'Use `# rubocop:disable DevDoc/Test/AvoidGlibTravelFreeze` ' \
-                'with a comment explaining why `glib_travel` cannot work for this test.'
+                'with a comment explaining why `glib_travel` cannot work for this test.'.freeze
 
-          RESTRICT_ON_SEND = %i[glib_travel_freeze].freeze
+          # The native ActiveSupport helpers freeze the clock exactly the same
+          # way — policing only the glib spelling would ban one name for
+          # frozen time while leaving the ones agents know from training data.
+          RESTRICT_ON_SEND = %i[glib_travel_freeze freeze_time travel_to travel].freeze
 
           def on_send(node)
-            add_offense(node.loc.selector)
+            add_offense(node.loc.selector, message: format(MSG, method: node.method_name))
           end
         end
       end

data/lib/rubocop/cop/dev_doc/test/avoid_unit_test.rb

@@ -44,15 +44,25 @@ module RuboCop
         #     model's own": you usually don't need to — assert the *observable*
         #     guarantee through the real path; that is what matters in production.
         #
-        # When a unit test is genuinely necessary, suppress with a reason that
-        # explains why a controller test can't cover the path. That reason IS the
-        # required justification — keep it specific and reviewable:
+        # When a unit test is genuinely necessary, do NOT disable this cop —
+        # use the sanctioned form instead: subclass `Glib::LastResortUnitTest`
+        # (the name is the policy), place the file in a unit-test directory
+        # (test/models|services|helpers/), and open it with a justification
+        # header containing the marker phrase "deliberate exception" that
+        # explains why no controller path can reach the behaviour. That form is
+        # machine-enforced by DevDoc/Test/RequireUnitTestJustification and
+        # never trips this cop, so a properly justified unit test carries zero
+        # disable directives:
         #
-        #   # rubocop:disable DevDoc/Test/AvoidUnitTest -- search ranking isn't visible through the controller
-        #   class Ai::Retrieval::PgSearchStrategyTest < ActiveSupport::TestCase
+        #   # Per best practice, we focus on controller tests. This model test
+        #   # is a deliberate exception: <why no controller path exists>.
+        #   class MemberTest < Glib::LastResortUnitTest
         #     # ...
         #   end
-        #   # rubocop:enable DevDoc/Test/AvoidUnitTest
+        #
+        # Legacy `< ActiveSupport::TestCase` tests that predate the sanctioned
+        # form survive via project-config Excludes until migrated; new code has
+        # no reason to add one.
         #
         # NOTE: The cop matches the *direct* superclass only. A project base
         # (`class ApplicationServiceTest < ActiveSupport::TestCase`) is flagged
@@ -64,17 +74,20 @@ module RuboCop
         #   end
         #
         #   # good — exercised through the controller
-        #   class NotesControllerTest < ActionDispatch::IntegrationTest
+        #   class NotesControllerTest < Glib::IntegrationTest
         #   end
         #
-        #   # good — genuinely unit-only, justified with a reason
-        #   # rubocop:disable DevDoc/Test/AvoidUnitTest -- <why a controller test can't cover this>
-        #   class SomeServiceTest < ActiveSupport::TestCase
+        #   # good — genuinely unit-only: sanctioned base + unit directory +
+        #   # justification header (enforced by RequireUnitTestJustification)
+        #   # Per best practice, we focus on controller tests. This test is a
+        #   # deliberate exception: <why a controller test can't cover this>.
+        #   class SomeServiceTest < Glib::LastResortUnitTest
         #   end
-        #   # rubocop:enable DevDoc/Test/AvoidUnitTest
         class AvoidUnitTest < Base
           MSG = 'Prefer a controller test — unit tests are a rare exception. If a controller test ' \
-                'genuinely cannot cover this path, disable this cop on the class with a reason.'.freeze
+                'genuinely cannot cover this path, use `Glib::LastResortUnitTest` in a unit-test ' \
+                'directory with a justification header (see ' \
+                'DevDoc/Test/RequireUnitTestJustification); do not disable this cop.'.freeze
 
           def on_class(node)
             superclass = node.parent_class

data/lib/rubocop/cop/dev_doc/test/require_glib_integration_base.rb

@@ -0,0 +1,57 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Test
+        # In HTTP-driven test directories, integration tests must subclass the
+        # project base (`RequiredBase`, default `Glib::IntegrationTest`) rather
+        # than a raw framework base (`LegacyBases`, default
+        # `ActionDispatch::IntegrationTest`).
+        #
+        # ## Rationale
+        # The project base is where behavioural enforcement and plumbing are
+        # attached: DevDoc::Test::Lints::HttpDrivenControllerTests (which fails
+        # any test under test/controllers/ that completes without making an
+        # HTTP request), plus the glib helpers (submit_form, glib_travel,
+        # parallel coverage). A test that inherits the framework base directly
+        # sidesteps all of it — and that is an observed evasion shape: when the
+        # runtime lint fails a disguised unit test, switching the superclass to
+        # the raw framework base would silence the lint without fixing the
+        # test. This cop closes that hop statically, completing the loop with
+        # DevDoc/Test/RequireUnitTestJustification (which forbids unit bases in
+        # these directories and integration bases in unit directories).
+        #
+        # Framework-specific bases for other test types
+        # (`ActionMailer::TestCase`, `ActionCable::Connection::TestCase`, ...)
+        # are not flagged — only the configured legacy integration bases.
+        #
+        # @example
+        #   # bad
+        #   class NotesControllerTest < ActionDispatch::IntegrationTest
+        #   end
+        #
+        #   # good
+        #   class NotesControllerTest < Glib::IntegrationTest
+        #   end
+        class RequireGlibIntegrationBase < Base
+          MSG = '`%<base>s` is the raw framework base — subclass `%<required>s` instead. The project ' \
+                'base carries the runtime HTTP-driven enforcement and the glib test plumbing; ' \
+                'inheriting the framework base directly sidesteps both.'.freeze
+
+          def on_class(node)
+            superclass = node.parent_class
+            return unless superclass&.const_type?
+            return unless legacy_bases.include?(superclass.const_name)
+
+            add_offense(superclass, message: format(MSG, base: superclass.const_name, required: required_base))
+          end
+
+          private
+
+          def legacy_bases = cop_config.fetch('LegacyBases', %w[ActionDispatch::IntegrationTest])
+
+          def required_base = cop_config.fetch('RequiredBase', 'Glib::IntegrationTest')
+        end
+      end
+    end
+  end
+end