rubocop-constable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4c912fddff14925ab4b86ed12735d37dce21f02b6d3fdedbfd5d86a4cf842b05
+  data.tar.gz: e81930e509b082e3acc5014f47769a48c310032bfd7d9e905c4f46aa45ed36f7
+SHA512:
+  metadata.gz: 0d48aedd13025539938ee08952e99da6833a8e40f73bfe5b7875d69d9126dd563deff331833613f6cf251c742d52d704d28773335922563f7b6edb32826c55ec
+  data.tar.gz: da375578877020106791b8ee52776866fb180b93eb683d7c568f87cc78847e3d7b4a72e751584df8beaeef8b8be014ed154f31107ca2a1efe800a0c74fbff7d0

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to `rubocop-constable` are documented here.
+This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - unreleased
+
+Initial release. Seven cops, all enabled by default, all scoped to native
+`Constable::Case` files:
+
+- `Constable/NoSleep`
+- `Constable/NoUnfrozenTime`
+- `Constable/NoNetworkWithoutStub`
+- `Constable/NoSharedMutableState`
+- `Constable/NoConditionalAssertions`
+- `Constable/NoRetryHelpers`
+- `Constable/UnsafeBlockVisibility`
+
+Cold cases (`Constable::ColdCase::RSpec`, `Constable::ColdCase::Minitest`) are
+exempt from every one of them, by design.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Ray Hughes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,260 @@
+# rubocop-constable
+
+The companion RuboCop extension for [Constable](https://github.com/Ray-Hughes/constable),
+the opinionated Rails testing gem published as `constable-rails`.
+
+Constable's second principle is that **nondeterminism is caught by the linter, not
+discovered in CI**. This gem is that linter. Seven cops, all on by default, each one
+aimed at a specific way a suite stops being trustworthy: a bare `sleep`, an unfrozen
+clock, a live HTTP call, class-level shared state, an assertion hiding behind a
+branch, a retry helper papering over a real failure, and an `unsafe` block that never
+says why it exists.
+
+## Installation
+
+```ruby
+# Gemfile
+group :development, :test do
+  gem "constable-rails"
+  gem "rubocop-constable", require: false
+end
+```
+
+```yaml
+# .rubocop.yml
+require:
+  - rubocop-constable
+```
+
+That is the whole setup. Every cop arrives enabled, with `Include` globs already
+pointed at case files — nothing to copy into your own config.
+
+On RuboCop 1.72 and newer you can use the `plugins:` key instead of `require:`;
+both work.
+
+## Scope: native cases only
+
+**Every cop here is scoped to native `Constable::Case` files.** A file whose class
+inherits from `Constable::ColdCase::RSpec` or `Constable::ColdCase::Minitest` is
+exempt from all of them.
+
+That is a design decision, not an oversight. Constable's third principle is that
+adoption never requires a rewrite: an existing RSpec or Minitest file becomes a cold
+case with a one-line superclass swap and runs verbatim from day one. Linting those
+files would punish exactly the people who took the on-ramp, and would turn a
+zero-risk import into a thousand-offense wall. Cold cases already announce
+themselves — the runner emits one warning per cold-case file, every run, in the
+summary's own WARNINGS section — so they are visible without being blocked.
+
+### The heuristic
+
+For each file, in order:
+
+1. **Cold case wins.** If any class in the file inherits from a constant with a
+   `ColdCase` segment (`Constable::ColdCase::RSpec`, `Constable::ColdCase::Minitest`,
+   or a project-local `ColdCase` base class), the file is exempt. This runs first, so
+   a cold case is never dragged back into scope by a path glob — and a file holding
+   both a cold case and a native case gets the benefit of the doubt.
+2. **Native case.** If any class inherits from a constant whose last segment ends in
+   `Case` — `Constable::Case` itself, or the tier base classes the install generator
+   writes (`UnitCase`, `IntegrationCase`, `SystemCase`) — the file is in scope.
+   Matching the `Case` suffix rather than `Constable::Case` literally is deliberate:
+   the recommended pattern is subclassing a tier base class, so the literal
+   superclass of a real case file usually *isn't* `Constable::Case`.
+3. **Path fallback.** Otherwise, a file under one of the cop's `Include` globs is
+   treated as in scope. This keeps the cops useful for a shared module living under
+   `test/cases/`, or a case file whose class definition a static parser can't see.
+   It is safe precisely because rule 1 already took cold cases off the table.
+4. Anything else reports nothing.
+
+The default `Include` globs are:
+
+```yaml
+Include:
+  - 'test/cases/**/*.rb'
+  - 'spec/cases/**/*.rb'
+  - 'test/**/*_case.rb'
+  - 'spec/**/*_case.rb'
+```
+
+## The escape hatch
+
+Six of the seven cops go quiet inside an `unsafe { }` block, because that is
+Constable's designed valve for the genuine edge case — and it is never silent: the
+runtime emits a warning with `file:line` and the adjacent comment for every
+occurrence, every run.
+
+The seventh cop, `Constable/UnsafeBlockVisibility`, is what keeps that honest. It
+does not object to `unsafe` at all; it objects only to an `unsafe` that does not say
+why.
+
+## The cops
+
+### `Constable/NoSleep`
+
+A bare `sleep` is the most common way a suite becomes both slow and flaky at once: it
+costs seconds on every green run and is still not long enough on the loaded CI box.
+`sleep(...)` and `Kernel.sleep(...)` are flagged; `some_object.sleep` is not.
+
+```ruby
+# bad
+investigate("expires the session") { sleep(0.2); attest(session).to be_expired }
+
+# good
+investigate("expires the session") { travel_to(2.hours.from_now); attest(session).to be_expired }
+
+# good -- the timeout is the subject, and it says so
+unsafe { sleep(0.1) } # testing an actual timeout path, not a code smell
+```
+
+### `Constable/NoUnfrozenTime`
+
+Reading the wall clock makes a test a function of when it runs — invisible until the
+suite goes red at midnight, on the last day of a month, or in the one CI region that
+isn't UTC. Flags `Time.now`, `Time.current`, `Time.zone.now`, `Date.today`,
+`Date.current`, `DateTime.now` and `DateTime.current`.
+
+Satisfied by any of: a lexically enclosing `freeze_time { }` / `travel_to(...) { }`
+block; a bare `freeze_time` / `travel_to` earlier in the same `investigate`; a
+`freeze_time` / `travel_to` in any `briefing` in the file (a briefing runs before
+every investigation, so it covers all of them); being the argument to a freeze helper
+(`travel_to(Time.now + 1.day)` is fine); or `unsafe { }`.
+
+| Option | Default |
+| --- | --- |
+| `ForbiddenCalls` | `Time.now`, `Time.current`, `Time.zone.now`, `Date.today`, `Date.current`, `DateTime.now`, `DateTime.current` |
+| `FreezeHelpers` | `freeze_time`, `travel_to` |
+
+### `Constable/NoNetworkWithoutStub`
+
+A case that talks to the real network is not a test of your code, it is a test of
+somebody else's uptime. If the file never calls `stub_network!`, HTTP entry points are
+flagged: `Net::HTTP`, `HTTParty`, `Faraday`, `RestClient`, `Excon`, `Typhoeus`,
+`HTTPClient`, `HTTPX`, `HTTP`, `Curl`, `Patron`, `Mechanize`, `OpenURI`, `Down`, plus
+`URI.open` / `URI.read` and open-uri's `open("https://...")`.
+
+One `stub_network!` anywhere in the file — normally in a `briefing`, which runs before
+every investigation — silences the cop for the whole case.
+
+The cop matches calls made *directly* on a known entry-point constant, so a chain like
+`Faraday.new(url: url).get("/profile")` reports once, at its entry point. A connection
+object handed around by a `witness` is out of reach of a static check; `stub_network!`
+itself catches that one at runtime.
+
+| Option | Default |
+| --- | --- |
+| `StubHelpers` | `stub_network!` |
+| `HttpConstants` | the list above |
+
+### `Constable/NoSharedMutableState`
+
+Isolation is non-negotiable in native code. A class variable or global written from
+inside a case survives the investigation that wrote it, so the suite's result depends
+on its order — and the failure lands on whichever test ran second, not on the one that
+caused it. This is why Constable has no `before(:all)`.
+
+Reading `@@x` or `$x` is fine. Writing is not: assignment, `||=`/`+=`, `<<`, `push`,
+`merge!`, `[]=`, and anything else ending in `!` or `=`. Use `witness` for per-test
+memoized data, `briefing` for per-test setup, and an ordinary instance variable for
+whatever an investigation needs to remember about itself.
+
+### `Constable/NoConditionalAssertions`
+
+An assertion behind a branch is an assertion that might not run. The test goes green
+either way, so nobody notices when the interesting branch stops being taken — the case
+quietly stops testing anything while still counting itself as coverage.
+
+Flags `if`, `unless`, modifier forms, ternaries, `case/when` and `case/in` whose
+branch bodies contain `attest` or an `assert_*`/`refute_*` call. Only the outermost
+conditional is reported, so a nested tree yields one offense, not five. The fix is to
+split the branches into separate `investigate` blocks — or separate `docket` blocks —
+so each one asserts unconditionally and each one's name says which world it describes.
+
+| Option | Default |
+| --- | --- |
+| `AssertionMethods` | `attest` |
+| `AssertionPrefixes` | `assert`, `refute` |
+
+### `Constable/NoRetryHelpers`
+
+Retrying is how a flaky test hides. It turns a test that fails some of the time into
+one that passes most of the time — strictly worse, because now nobody is looking at
+it.
+
+Flags the `retry` keyword, the helper calls `wait_for`, `eventually`, `with_retries`,
+`try_again`, `retry_until`, `retry_on_failure`, `poll_until`, `keep_trying`, and
+`loop`/`while`/`until` bodies that poll with `sleep`. The loop heuristic is
+deliberately narrow — a `while` doing real work is left alone.
+
+Constable's real answer for genuine flakiness is **warrants**: the runner reruns a
+failing test in isolation, records what it finds in the blotter, and reports it in its
+own summary section. Visible and counted, rather than swallowed by a
+`rescue; retry; end`.
+
+`wait_for(timeout:, interval:)` does exist in the runtime DSL for genuinely async work
+— but it is legal only inside `unsafe { }`, and raises outside it. This cop enforces
+the same rule statically.
+
+| Option | Default |
+| --- | --- |
+| `RetryHelpers` | the list above |
+
+### `Constable/UnsafeBlockVisibility`
+
+Every escape hatch is visible. This cop fails **only** when an `unsafe` block has
+nothing next to it explaining why. Satisfied by a trailing comment on the same line, a
+comment on the line immediately above, or a literal reason argument. That text is what
+the runner quotes in the run summary:
+
+```
+⚠ spec/controllers/sessions_case.rb:44
+  unsafe { sleep(0.1) } — "testing an actual timeout path, not a code smell"
+```
+
+```ruby
+# bad
+unsafe { sleep(0.1) }
+
+# good
+unsafe { sleep(0.1) } # testing an actual timeout path, not a code smell
+
+# good
+# testing an actual timeout path, not a code smell
+unsafe do
+  sleep(0.1)
+end
+
+# good
+unsafe("testing an actual timeout path, not a code smell") { sleep(0.1) }
+```
+
+| Option | Default |
+| --- | --- |
+| `AllowReasonArgument` | `true` — set to `false` to insist on a comment |
+
+## Autocorrection
+
+None of these cops autocorrect. Every one of them is reporting a decision a human has
+to make — which investigation to split the branch into, whether the clock or the
+network is genuinely the subject, whether the retry was hiding a real bug. A machine
+guessing at that would be worse than the offense.
+
+## Development
+
+The suite is plain Minitest, matching the rest of the Constable repo:
+
+```
+bundle install
+bundle exec rake test
+# or, without bundler:
+ruby -Ilib -Itest test/no_sleep_test.rb
+```
+
+Each cop is exercised by building a `RuboCop::ProcessedSource` and running it through
+a `Commissioner` holding just that cop; `test/integration_test.rb` runs the whole
+department through a real `Team` over real files, which is what proves the `Include`
+filtering and the cold-case exemption end to end.
+
+## License
+
+MIT. See [LICENSE.txt](LICENSE.txt).

data/config/default.yml

@@ -0,0 +1,150 @@
+# Defaults for rubocop-constable.
+#
+# Every cop here is scoped to native `Constable::Case` files. A file whose class
+# inherits from `Constable::ColdCase::RSpec` or `Constable::ColdCase::Minitest`
+# has explicitly opted out of native rules and is exempt from all of them, no
+# matter which of the `Include` globs below it happens to sit under.
+
+Constable:
+  Enabled: true
+  DocumentationBaseURL: https://github.com/Ray-Hughes/constable/blob/main/rubocop-constable/README.md
+
+Constable/NoConditionalAssertions:
+  Description: >-
+    Do not put `if`/`unless`/ternary/`case` branching around `attest` or
+    `assert_*` calls. An assertion behind a branch may never run, so the case
+    passes whichever way the branch falls.
+  Enabled: true
+  VersionAdded: '0.1.0'
+  SafeAutoCorrect: false
+  AssertionMethods:
+    - attest
+  AssertionPrefixes:
+    - assert
+    - refute
+  Include:
+    - 'test/cases/**/*.rb'
+    - 'spec/cases/**/*.rb'
+    - 'test/**/*_case.rb'
+    - 'spec/**/*_case.rb'
+
+Constable/NoNetworkWithoutStub:
+  Description: >-
+    Do not make real HTTP calls from a case that never calls `stub_network!`.
+    A test that depends on somebody else's uptime is not testing your code.
+  Enabled: true
+  VersionAdded: '0.1.0'
+  SafeAutoCorrect: false
+  StubHelpers:
+    - stub_network!
+  HttpConstants:
+    - Net::HTTP
+    - Net::HTTPS
+    - HTTParty
+    - Faraday
+    - RestClient
+    - Excon
+    - Typhoeus
+    - HTTPClient
+    - HTTPX
+    - HTTP
+    - Curl
+    - Patron
+    - Mechanize
+    - OpenURI
+    - Down
+  Include:
+    - 'test/cases/**/*.rb'
+    - 'spec/cases/**/*.rb'
+    - 'test/**/*_case.rb'
+    - 'spec/**/*_case.rb'
+
+Constable/NoRetryHelpers:
+  Description: >-
+    Do not retry. `retry`, `eventually`, `wait_for` and `sleep`-driven polling
+    loops all hide a flaky test instead of fixing it -- that is what warrants
+    are for.
+  Enabled: true
+  VersionAdded: '0.1.0'
+  SafeAutoCorrect: false
+  RetryHelpers:
+    - wait_for
+    - eventually
+    - with_retries
+    - try_again
+    - retry_until
+    - retry_on_failure
+    - poll_until
+    - keep_trying
+  Include:
+    - 'test/cases/**/*.rb'
+    - 'spec/cases/**/*.rb'
+    - 'test/**/*_case.rb'
+    - 'spec/**/*_case.rb'
+
+Constable/NoSharedMutableState:
+  Description: >-
+    Do not assign or mutate class variables or globals inside a case. State that
+    outlives an investigation makes the suite order-dependent, which is the
+    hardest class of flake to debug. Use `witness` or `briefing`.
+  Enabled: true
+  VersionAdded: '0.1.0'
+  SafeAutoCorrect: false
+  Include:
+    - 'test/cases/**/*.rb'
+    - 'spec/cases/**/*.rb'
+    - 'test/**/*_case.rb'
+    - 'spec/**/*_case.rb'
+
+Constable/NoSleep:
+  Description: >-
+    Do not use a bare `sleep` in a case. It costs seconds on every green run and
+    is still not long enough on the red one. Wrap it in `unsafe { }` when the
+    delay itself is under test.
+  Enabled: true
+  VersionAdded: '0.1.0'
+  SafeAutoCorrect: false
+  Include:
+    - 'test/cases/**/*.rb'
+    - 'spec/cases/**/*.rb'
+    - 'test/**/*_case.rb'
+    - 'spec/**/*_case.rb'
+
+Constable/NoUnfrozenTime:
+  Description: >-
+    Do not read the wall clock in a case without freezing it first. Call
+    `freeze_time` or `travel_to`, otherwise the test is a function of when it
+    runs.
+  Enabled: true
+  VersionAdded: '0.1.0'
+  SafeAutoCorrect: false
+  ForbiddenCalls:
+    - Time.now
+    - Time.current
+    - Time.zone.now
+    - Date.today
+    - Date.current
+    - DateTime.now
+    - DateTime.current
+  FreezeHelpers:
+    - freeze_time
+    - travel_to
+  Include:
+    - 'test/cases/**/*.rb'
+    - 'spec/cases/**/*.rb'
+    - 'test/**/*_case.rb'
+    - 'spec/**/*_case.rb'
+
+Constable/UnsafeBlockVisibility:
+  Description: >-
+    An `unsafe` block must say why it exists -- a trailing comment, a comment on
+    the line above, or a literal reason argument. Every escape hatch is visible.
+  Enabled: true
+  VersionAdded: '0.1.0'
+  SafeAutoCorrect: false
+  AllowReasonArgument: true
+  Include:
+    - 'test/cases/**/*.rb'
+    - 'spec/cases/**/*.rb'
+    - 'test/**/*_case.rb'
+    - 'spec/**/*_case.rb'

data/lib/rubocop/constable/inject.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Constable
+    # Merges this extension's `config/default.yml` into RuboCop's own default
+    # configuration, so users get sensible defaults for every `Constable/*` cop
+    # from `require: rubocop-constable` alone -- no copy-pasting of departments
+    # into their `.rubocop.yml`.
+    #
+    # This is the standard RuboCop extension injection pattern, as used by
+    # rubocop-rails, rubocop-rspec and friends.
+    module Inject
+      def self.defaults!
+        path = ::RuboCop::Constable.config_default.to_s
+        hash = ::RuboCop::ConfigLoader.send(:load_yaml_configuration, path)
+        config = ::RuboCop::Config.new(hash, path).tap(&:make_excludes_absolute)
+        puts "configuration from #{path}" if ::RuboCop::ConfigLoader.debug?
+        config = ::RuboCop::ConfigLoader.merge_with_default(config, path)
+        ::RuboCop::ConfigLoader.instance_variable_set(:@default_configuration, config)
+      end
+    end
+  end
+end

data/lib/rubocop/constable/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Constable
+    VERSION = "0.1.0"
+  end
+end

data/lib/rubocop/constable.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module RuboCop
+  # RuboCop cops for Constable, the opinionated Rails testing gem.
+  #
+  # Constable's promise is that fast and non-flaky are structural properties of a
+  # suite, not a matter of discipline. These cops are the half of that promise that
+  # runs before the suite does: nondeterminism is caught by the linter, not
+  # discovered in CI.
+  module Constable
+    PROJECT_ROOT = Pathname.new(__dir__).parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join("config", "default.yml").freeze
+    CONFIG = YAML.safe_load(CONFIG_DEFAULT.read, permitted_classes: [Regexp, Symbol]).freeze
+
+    private_constant :CONFIG_DEFAULT, :PROJECT_ROOT
+
+    class << self
+      # @return [Pathname] the gem's own root, used to locate config/default.yml.
+      def project_root
+        PROJECT_ROOT
+      end
+
+      # @return [Pathname] path to the shipped default configuration.
+      def config_default
+        CONFIG_DEFAULT
+      end
+    end
+  end
+end

data/lib/rubocop/cop/constable/case_scope.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Constable
+      # Scopes every `Constable/*` cop to **native** `Constable::Case` files.
+      #
+      # Constable's whole adoption story is that an existing RSpec or Minitest file
+      # can run untouched from day one as a *cold case*. A cold case has explicitly
+      # opted out of native rules, so linting it would punish exactly the people who
+      # took the on-ramp. Cold-case files are therefore exempt by design, not by
+      # oversight -- their escape hatch is already reported once per file, every run,
+      # by the runner itself.
+      #
+      # == The heuristic
+      #
+      # In order, for each file:
+      #
+      # 1. *Cold case wins.* If any class in the file inherits from a constant with a
+      #    +ColdCase+ segment (+Constable::ColdCase::RSpec+, +Constable::ColdCase::Minitest+,
+      #    or a project-local +ColdCase+ base class), the file is exempt. This check runs
+      #    first so a cold case is never dragged back in by a path glob.
+      # 2. *Native case.* If any class inherits from a constant whose last segment ends in
+      #    +Case+ -- +Constable::Case+ itself, or the tier base classes the install
+      #    generator writes (+UnitCase+, +IntegrationCase+, +SystemCase+) -- the file is in
+      #    scope. Matching on the +Case+ suffix rather than on +Constable::Case+ literally is
+      #    deliberate: SPEC.md recommends subclassing a tier base class, so the literal
+      #    superclass of a real case file usually *isn't* +Constable::Case+.
+      # 3. *Path fallback.* Otherwise, a file sitting under one of the cop's own +Include+
+      #    globs (+test/cases/**/*.rb+ and friends) is treated as in scope. This keeps the
+      #    cops useful for a shared module under +test/cases/+ or a case file whose class
+      #    definition the parser can't see, and it is safe precisely because rule 1 already
+      #    took cold cases off the table.
+      # 4. Anything else is out of scope and reports nothing.
+      #
+      # Cops mix this in and guard their handlers with +#constable_case_file?+, rather than
+      # overriding +#relevant_file?+, so the exemption is enforced identically whether the
+      # cop runs under a full RuboCop team or a bare Commissioner.
+      module CaseScope
+        COLD_CASE_SEGMENT = "ColdCase"
+        NATIVE_CASE_SUFFIX = /Case\z/.freeze
+
+        def on_new_investigation
+          @constable_case_file = nil
+          super
+        end
+
+        # @return [Boolean] whether this file is a native Constable case file.
+        def constable_case_file?
+          return @constable_case_file unless @constable_case_file.nil?
+
+          @constable_case_file = compute_constable_case_file
+        end
+
+        # @return [Boolean] whether the file opted out of native rules.
+        def cold_case_file?
+          superclass_names.any? { |name| cold_case_superclass?(name) }
+        end
+
+        private
+
+        def compute_constable_case_file
+          names = superclass_names
+          return false if names.any? { |name| cold_case_superclass?(name) }
+          return true if names.any? { |name| native_case_superclass?(name) }
+
+          include_path_scope?
+        end
+
+        # Every `class Foo < Bar` superclass constant in the file, as dotless
+        # `::`-joined strings. Non-constant superclasses (`Class.new(x)`, dynamic
+        # superclass expressions) are ignored -- they can't be resolved statically.
+        def superclass_names
+          @superclass_names ||= begin
+            ast = processed_source&.ast
+            if ast.nil?
+              []
+            else
+              ast.each_node(:class).filter_map { |node| constant_name(node.parent_class) }
+            end
+          end
+        end
+
+        def constant_name(node)
+          return nil unless node.respond_to?(:const_type?) && node.const_type?
+
+          name = node.const_name
+          name && name.sub(/\A::/, "")
+        end
+
+        def cold_case_superclass?(name)
+          name.split("::").include?(COLD_CASE_SEGMENT)
+        end
+
+        def native_case_superclass?(name)
+          segments = name.split("::")
+          return false if segments.include?(COLD_CASE_SEGMENT)
+
+          NATIVE_CASE_SUFFIX.match?(segments.last.to_s)
+        end
+
+        def include_path_scope?
+          path = current_file_path
+          return false if path.nil?
+
+          patterns = Array(cop_config["Include"])
+          return false if patterns.empty?
+
+          path_candidates(path).any? do |candidate|
+            patterns.any? { |pattern| ::RuboCop::PathUtil.match_path?(pattern, candidate) }
+          end
+        end
+
+        def current_file_path
+          path = processed_source&.file_path
+          return nil if path.nil? || path.empty?
+          # `(string)` -- source handed to the cop without a path at all.
+          return nil if path.start_with?("(")
+
+          path
+        end
+
+        def path_candidates(path)
+          candidates = [path, path.delete_prefix("#{Dir.pwd}/")]
+          begin
+            candidates << config.path_relative_to_config(path)
+          rescue StandardError # rubocop:disable Lint/SuppressedException
+          end
+          candidates.compact.uniq
+        end
+      end
+    end
+  end
+end