rubocop-dev_doc 0.7.0 → 0.8.0

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

@@ -0,0 +1,119 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Test
+        # Controller tests must run inside a `glib_travel` block.
+        #
+        # ## Rationale
+        # Per the testing best practice ("Time Travel"), tests should always run
+        # inside a `glib_travel` block — even when they do not appear
+        # time-sensitive. Controller tests integrate HTTP, the database, and the
+        # clock (timestamps, expiry windows, token validity, rate limits), so they
+        # are the highest-leverage place to enforce it. A controller test that
+        # does not freeze time passes today and flakes or regresses the moment an
+        # ordering, expiry, or TTL boundary shifts under it.
+        #
+        # The block form auto-returns to real time at the end of the test, so no
+        # teardown is needed:
+        #
+        #   test 'shows the row' do
+        #     glib_travel(FROZEN_TIME) do
+        #       get items_url(format: :json)
+        #       assert_response :success
+        #     end
+        #   end
+        #
+        # This cop is a *presence* check — it only asks "did you freeze time?".
+        # Whether you used the block form (vs. the leak-prone bare anchor) is
+        # enforced separately by `DevDoc/Test/RequireGlibTravelBlock`, and
+        # `glib_travel_freeze` vs. `glib_travel` by `AvoidGlibTravelFreeze`.
+        #
+        # ## What is NOT flagged
+        # - Tests that already call `glib_travel` or `glib_travel_freeze`.
+        # - Non-controller test files — the cop is scoped to
+        #   `test/controllers/**` via `Include`, where the time-sensitivity risk
+        #   is highest. (The best practice recommends the block form for every
+        #   test; this cop enforces the subset with the strongest evidence.)
+        #
+        # ## Inline disable
+        # For the rare controller test that is genuinely time-independent and the
+        # block adds noise, add a `rubocop:disable DevDoc/Test/RequireGlibTravel`
+        # comment to the test's opening line (`test '...' do` or `def test_*`)
+        # with a written reason.
+        #
+        # @example
+        #   # bad
+        #   test 'shows the row' do
+        #     get items_url(format: :json)
+        #     assert_response :success
+        #   end
+        #
+        #   # good
+        #   test 'shows the row' do
+        #     glib_travel(FROZEN_TIME) do
+        #       get items_url(format: :json)
+        #       assert_response :success
+        #     end
+        #   end
+        #
+        #   # good (method-style test — also covered)
+        #   def test_shows_the_row
+        #     glib_travel(FROZEN_TIME) do
+        #       get items_url(format: :json)
+        #     end
+        #   end
+        class RequireGlibTravel < Base
+          MSG = 'Wrap this test in a `glib_travel` block — controller tests integrate ' \
+                'HTTP, DB, and time, so the frozen time must be deterministic. See the ' \
+                'testing best practice ("Time Travel"). Disable with a written reason ' \
+                'only if the test is genuinely time-independent.'.freeze
+
+          # @!method test_block?(node)
+          def_node_matcher :test_block?, <<~PATTERN
+            (block (send nil? :test ...) _args _body)
+          PATTERN
+
+          # Any glib time helper satisfies the presence check. `glib_travel_freeze`
+          # counts as "froze time" here — its form is policed by
+          # AvoidGlibTravelFreeze, not by this cop.
+          # @!method calls_glib_time_helper?(node)
+          def_node_search :calls_glib_time_helper?, <<~PATTERN
+            (send nil? {:glib_travel :glib_travel_freeze} ...)
+          PATTERN
+
+          def on_block(node)
+            return unless test_block?(node)
+
+            check_test(node, node.send_node.loc.selector)
+          end
+
+          # Minitest also allows method-style tests (`def test_shows_the_row`);
+          # those are the same kind of controller test and must freeze time too.
+          def on_def(node)
+            return unless test_method?(node)
+
+            check_test(node, node.loc.name)
+          end
+
+          private
+
+          # Shared by the block form (`test '...' do`) and the method form
+          # (`def test_*`): a test with a body that never freezes time.
+          def check_test(node, location)
+            return unless node.body
+            return if calls_glib_time_helper?(node)
+
+            add_offense(location)
+          end
+
+          # Minitest treats any `def test_*` method as a test. Node patterns
+          # match exact method names rather than a prefix, so this is a plain
+          # Ruby string check. (`def test` — no underscore — is not a test.)
+          def test_method?(node)
+            node.method_name.to_s.start_with?('test_')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Test
+        # `glib_travel` must be called with a block — the bare anchor form leaks
+        # frozen time past the test.
+        #
+        # ## Rationale
+        # `glib_travel(point) do ... end` auto-returns to real time at the end of
+        # the block, so a test cannot leak a frozen clock into the next one. The
+        # bare anchor form `glib_travel(point)` (no block) freezes time until a
+        # matching `glib_travel_back`, which is easy to forget in `teardown` and
+        # then silently corrupts every test that runs afterward. This is the form
+        # that has repeatedly slipped in alongside the correct block form.
+        #
+        # ## What is NOT flagged
+        # - The block form `glib_travel(point) do ... end` (the correct form).
+        # - A bare DURATION argument that advances the frozen clock across
+        #   multiple requests within one test, e.g. `glib_travel(61.seconds)`,
+        #   `glib_travel(1.hour)`, `glib_travel(-5.minutes)`, or
+        #   `glib_travel(5.minutes + 30.seconds)`. This is the accepted
+        #   non-block form for rate-limiting / clock-tick tests; it is
+        #   recognized by a `Numeric#second(s)/minute(s)/hour(s)/day(s)/
+        #   week(s)/month(s)/year(s)` leaf, optionally unary-negated
+        #   (`-5.minutes`) or composed additively/subtractively
+        #   (`5.minutes + 30.seconds`), and is paired with an explicit
+        #   `glib_travel_back`. An absolute point expression such as
+        #   `Time.current`, `DateTime.new(...)`, or `2.hours.from_now` is NOT a
+        #   duration and is flagged. A duration reached through anything the
+        #   matcher cannot see statically — a constant or variable holding a
+        #   duration (`glib_travel(SOME_DURATION)`), a method call, or
+        #   multiplication/division (`glib_travel(5.minutes * 2)`) — is NOT
+        #   recognized; inline the literal expression or `# rubocop:disable`
+        #   with a reason.
+        # - `glib_travel_freeze` (covered by `DevDoc/Test/AvoidGlibTravelFreeze`).
+        #
+        # ## Inline disable
+        # For the rare case where the bare anchor form is genuinely required, add
+        # a `rubocop:disable DevDoc/Test/RequireGlibTravelBlock` comment with a
+        # written reason.
+        #
+        # @example
+        #   # bad (bare anchor — leaks frozen time without glib_travel_back)
+        #   glib_travel(FROZEN_TIME)
+        #   get items_url(format: :json)
+        #
+        #   # good
+        #   glib_travel(FROZEN_TIME) do
+        #     get items_url(format: :json)
+        #   end
+        #
+        #   # good (bare duration tick — advances the clock, paired with travel_back)
+        #   glib_travel(61.seconds)
+        class RequireGlibTravelBlock < Base
+          MSG = 'Use the block form `glib_travel(time) do ... end` — the bare anchor ' \
+                'form leaks frozen time past the test unless paired with ' \
+                '`glib_travel_back`. Use `# rubocop:disable ' \
+                'DevDoc/Test/RequireGlibTravelBlock` with a reason if the bare form ' \
+                'is genuinely required.'.freeze
+
+          RESTRICT_ON_SEND = %i[glib_travel].freeze
+
+          # A duration unit — the leaf of a duration expression. Both singular
+          # and plural ActiveSupport forms (`1.hour`, `2.minutes`). Receiver is
+          # unconstrained; in practice it is always a Numeric literal.
+          # @!method duration_argument?(node)
+          def_node_matcher :duration_argument?, <<~PATTERN
+            (send _ {:second :seconds :minute :minutes :hour :hours :day :days :week :weeks :month :months :year :years})
+          PATTERN
+
+          def on_send(node)
+            # `glib_travel` is a global test helper; a receiver-bearing call
+            # (`obj.glib_travel`) is a different method and none of our
+            # business — but `self.glib_travel` IS the same call and must not
+            # become a one-token dodge of the block-form rule.
+            return if node.receiver && !node.receiver.self_type?
+
+            return if block_form?(node)
+            return if bare_duration_tick?(node)
+
+            add_offense(node.loc.selector)
+          end
+
+          private
+
+          # True when this `glib_travel` send is the body of a block, i.e. the
+          # call is `glib_travel(...) do ... end`. Covers regular blocks and
+          # numbered-parameter blocks (`{ _1 }`).
+          def block_form?(node)
+            parent = node.parent
+            return false unless parent
+            return false unless parent.block_type? || parent.numblock_type?
+
+            parent.send_node == node
+          end
+
+          # A bare call whose argument is a Duration expression advances the
+          # frozen clock and is the accepted non-block form.
+          def bare_duration_tick?(node)
+            duration_expression?(node.first_argument)
+          end
+
+          # A single duration unit (`61.seconds`), optionally unary-negated
+          # (`-5.minutes`), or an additive/subtractive composition of durations
+          # (`5.minutes + 30.seconds`). A duration mixed with an absolute point
+          # (`Time.current + 5.minutes` — a Time, not a Duration) is NOT
+          # recognized and remains flagged; neither is multiplication/division
+          # nor a duration held in a variable/constant/method (see docstring).
+          def duration_expression?(node)
+            return false unless node
+            return true if duration_argument?(node)
+            return false unless node.send_type?
+            # A unary sign on a duration is still a duration (`-5.minutes`).
+            return duration_expression?(node.receiver) if %i[+@ -@].include?(node.method_name)
+            return false unless %i[+ -].include?(node.method_name)
+
+            duration_expression?(node.receiver) && duration_expression?(node.first_argument)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,217 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Test
+        # Classifies every test file (`test/**/*_test.rb`) into one of three
+        # buckets, so no directory placement can dodge test-type enforcement:
+        #
+        # 1. **Exempt** (`ExemptDirectories`, default: controllers, integration,
+        #    jobs, mailers, channels, system, linters, tasks) — covered by other
+        #    enforcement (test/controllers/ is guaranteed HTTP-driven at runtime
+        #    by DevDoc::Test::Lints::HttpDrivenControllerTests) or accepted
+        #    integration-shaped homes. Even here, inheriting a unit base class
+        #    (`UnitBaseClasses`, default `Glib::LastResortUnitTest`) is an offense: a unit
+        #    base is only legitimate in a unit-test directory, so its appearance
+        #    in an exempt directory means a unit test is parked where the
+        #    justification-header rule (and, for test/controllers/, the runtime
+        #    HTTP lint — which only reaches integration-base descendants) cannot
+        #    see it.
+        # 2. **Unit-test directories** (`UnitTestDirectories`, default: models,
+        #    services, helpers) — allowed only with a justification header: the
+        #    leading comments (before the first class/module) must contain the
+        #    marker phrase (default "deliberate exception") explaining why a
+        #    controller test can't cover this.
+        # 3. **Anything else** — flagged as an unrecognized test directory.
+        #    Adding a new test home is a reviewed decision made in this cop's
+        #    config, not something a generated test can do implicitly.
+        #
+        # ## Rationale
+        # Best practice strongly prefers controller tests (see AvoidUnitTest):
+        # unit tests stay green while the production wiring is broken, so a
+        # passing unit test is false confidence about production. The
+        # justification bar is deliberately high — before writing the header,
+        # assume a controller test IS possible and look harder, because that
+        # conclusion is almost always premature: AvoidUnitTest's docs list the
+        # patterns (inject a failure at a class-method chokepoint the real
+        # request hits, assert the observable guarantee through the real path)
+        # that make seemingly unit-only behaviour reachable end-to-end. Observed
+        # evasions by AI agents include ambiguous file names, unit tests mixed
+        # into controller-test files, inheriting the integration base class so
+        # the `< ActiveSupport::TestCase` heuristic never fires — and, once
+        # per-directory enforcement exists, inventing new directories outside
+        # it. The three-bucket total classification closes the last of those:
+        # every test file is either behaviorally enforced, explicitly justified,
+        # or flagged.
+        #
+        #   ❌ test/models/member_test.rb with no header
+        #   class MemberTest < Glib::IntegrationTest
+        #
+        #   ❌ test/controllers/member_test.rb — unit base hiding in an exempt dir
+        #   class MemberTest < Glib::LastResortUnitTest
+        #
+        #   ✔ justified
+        #   # Per best practice, we focus on controller tests. This model test
+        #   # is a deliberate exception: the safely_* guards raise on ANY direct
+        #   # call, so by design no controller path can reach them.
+        #   class MemberTest < Glib::LastResortUnitTest
+        #
+        # @example
+        #   # bad — test/units/quiet_test.rb (unrecognized directory)
+        #
+        #   # bad — test/models/member_test.rb without the marker phrase
+        #
+        #   # bad — test/controllers/member_test.rb inheriting Glib::LastResortUnitTest
+        #
+        #   # good — test/models/member_test.rb whose leading comments contain
+        #   # "deliberate exception" and explain why no controller path exists
+        class RequireUnitTestJustification < Base
+          MSG_JUSTIFY = 'Unit-test file without a justification header. Controller tests catch the ' \
+                        'wiring bugs unit tests miss, so first assume a controller test IS possible ' \
+                        'and look harder — that conclusion is almost always premature (see ' \
+                        'DevDoc/Test/AvoidUnitTest for patterns that reach "unit-only" behaviour ' \
+                        'end-to-end). If genuinely impossible, explain why in the leading comments, ' \
+                        'including the marker phrase "%<phrase>s".'.freeze
+
+          MSG_UNRECOGNIZED = 'Test file in unrecognized directory `test/%<dir>s/`. Unit tests hide in ' \
+                             'uncategorized directories: move this file to a recognized home ' \
+                             '(%<known>s), or add the directory to this cop\'s configuration — a ' \
+                             'reviewed decision, not an implicit one.'.freeze
+
+          MSG_BASE = '`%<base>s` is an integration base class — a unit test inheriting it lies about ' \
+                     'its type and gains HTTP helpers it must never use. Subclass a unit-test base ' \
+                     '(e.g. `Glib::LastResortUnitTest`) so the declaration is truthful and the verbs are ' \
+                     'structurally absent.'.freeze
+
+          MSG_UNIT_BASE = '`%<base>s` belongs only in a unit-test directory (%<unit_dirs>s), where ' \
+                          'the justification header is enforced. A unit test in `test/%<dir>s/` is ' \
+                          'hiding from that enforcement — move it there and justify it, or write a ' \
+                          'real %<dir>s test.'.freeze
+
+          FORBIDDEN_BASES = %w[ActionDispatch::IntegrationTest Glib::IntegrationTest].freeze
+          EXEMPT_DIRS = %w[controllers integration jobs mailers channels system linters tasks].freeze
+
+          def on_new_investigation
+            return if processed_source.blank?
+
+            dir = test_subdirectory
+            return if dir.nil? # not under a test/ tree at all
+
+            enforce_directory_rules(dir)
+          end
+
+          private
+
+          def enforce_directory_rules(dir)
+            if exempt_directories.include?(dir)
+              check_unit_bases(dir)
+            elsif unit_test_directories.include?(dir)
+              check_justification
+              check_base_classes
+            else
+              add_offense(offense_range, message: format(MSG_UNRECOGNIZED, dir: dir, known: known_directories))
+            end
+          end
+
+          def check_justification
+            return if leading_comments_contain_phrase?
+
+            add_offense(offense_range, message: format(MSG_JUSTIFY, phrase: marker_phrase))
+          end
+
+          # A justified unit test must also DECLARE itself truthfully: inheriting
+          # an integration base class hides the test type from readers and from
+          # base-class-keyed tooling (the observed AvoidUnitTest evasion).
+          def check_base_classes
+            each_class_with_base(forbidden_base_classes) do |superclass, base|
+              add_offense(superclass, message: format(MSG_BASE, base: base))
+            end
+          end
+
+          # The inverse rule for exempt directories: a unit base there means a
+          # unit test parked where neither the header rule nor the runtime HTTP
+          # lint (which only reaches integration-base descendants) can see it.
+          def check_unit_bases(dir)
+            each_class_with_base(unit_base_classes) do |superclass, base|
+              add_offense(superclass,
+                          message: format(MSG_UNIT_BASE, base: base, dir: dir, unit_dirs: unit_directories_list))
+            end
+          end
+
+          def each_class_with_base(bases)
+            root = processed_source.ast
+            return unless root
+
+            root.each_node(:class) do |class_node|
+              base = class_node.parent_class&.const_name
+              yield(class_node.parent_class, base) if base && bases.include?(base)
+            end
+          end
+
+          # First path segment after the (last) `test/` component; nil when the
+          # file is not under one, '.' for files directly in test/. Only
+          # `*_test.rb` files count — anything else (helpers, shared scenarios,
+          # previews) is never loaded by the test runner, so there is nothing to
+          # enforce. In-cop guard on purpose: the config Include says the same,
+          # but the cop must stay correct even when run with a forced config.
+          def test_subdirectory
+            path = processed_source.file_path.to_s
+            return nil unless File.basename(path).end_with?('_test.rb')
+
+            rest = path_after_test_root(path)
+            return nil unless rest
+
+            segments = rest.split('/')
+            segments.length == 1 ? '.' : segments.first
+          end
+
+          # Everything after the LAST `test/` root component (handles nesting
+          # like test/services/ai/x_test.rb and repos checked out under a
+          # directory that itself contains `test/`).
+          def path_after_test_root(path)
+            if (index = path.rindex('/test/'))
+              path[(index + '/test/'.length)..]
+            elsif path.start_with?('test/')
+              path.delete_prefix('test/')
+            end
+          end
+
+          def leading_comments_contain_phrase?
+            processed_source.comments.any? do |comment|
+              comment.location.line < first_definition_line &&
+                comment.text.downcase.include?(marker_phrase.downcase)
+            end
+          end
+
+          # Header comments legitimately sit between the `require`s and the test
+          # class, so "leading" means before the first class/module definition.
+          def first_definition_line
+            root = processed_source.ast
+            return Float::INFINITY unless root
+
+            definition = root.each_node(:class, :module).first
+            (definition || root).first_line
+          end
+
+          def marker_phrase = cop_config.fetch('MarkerPhrase', 'deliberate exception')
+
+          def forbidden_base_classes = cop_config.fetch('ForbiddenBaseClasses', FORBIDDEN_BASES)
+
+          def unit_base_classes = cop_config.fetch('UnitBaseClasses', %w[Glib::LastResortUnitTest])
+
+          def unit_test_directories = cop_config.fetch('UnitTestDirectories', %w[models services helpers])
+
+          def exempt_directories = cop_config.fetch('ExemptDirectories', EXEMPT_DIRS)
+
+          def known_directories = (exempt_directories + unit_test_directories).map { |d| "test/#{d}/" }.join(', ')
+
+          def unit_directories_list = unit_test_directories.map { |d| "test/#{d}/" }.join(', ')
+
+          def offense_range
+            range = processed_source.ast&.source_range || processed_source.comments.first&.source_range
+            range.with(end_pos: range.begin_pos + [range.source_line.length, 1].max)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dev_doc/view/prefer_prop_over_name.rb

@@ -0,0 +1,109 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module View
+        # Bind form fields to model attributes with `prop:`, not a raw
+        # `name: 'model[attr]'`.
+        #
+        # ## Rationale
+        # The form-field builder's `prop:` option binds a field to the form's
+        # model attribute and resolves its label, placeholder, and validation
+        # hints from i18n. Writing `name: 'model[attr]'` (the raw HTML-form
+        # instinct) bypasses all of that, so the label/placeholder get
+        # hardcoded next to it in English — the exact text this ecosystem
+        # keeps in locale files.
+        #
+        #   ❌ raw name + hardcoded text
+        #   form.fields_text name: 'user[email]', label: 'Email', placeholder: 'Email'
+        #
+        #   ✔️ bound to the model; text resolved from i18n
+        #   form.fields_text prop: :email
+        #
+        # Matching is receiver-agnostic (`form.`, `f.`, any block-arg name):
+        # keying on specific receiver names would make renaming the block
+        # argument a silent dodge. Any `fields_*` call with a
+        # single-level-bracket string `name:` is flagged.
+        #
+        # ## Exemptions
+        # - `fields_hidden` is exempt by default (`ExemptFieldMethods`):
+        #   hidden fields have no label/placeholder, and they are the
+        #   dominant legitimate `name:` users (echoed tokens, dynamic-group
+        #   indexes, forced values).
+        # - A field on an UNBOUND form (pre-auth flows: sessions, password
+        #   reset) cannot use `prop:` — there is no model to resolve against.
+        #   Prefer binding a fresh instance (e.g. `User.new`) so `prop:`
+        #   works; otherwise keep `name:` with a per-line
+        #   `rubocop:disable ... -- <reason>`.
+        # - Virtual/transient/credential fields where model-driven resolution
+        #   is undesirable: per-line disable with a reason.
+        #
+        # ## Autocorrect (unsafe)
+        # `name: 'model[attr]'` becomes `prop: :attr`. Two caveats make this
+        # unsafe:
+        # - The `model` segment is dropped: `prop:` binds to the FORM's
+        #   model, so if the raw name deliberately posted under a different
+        #   key, the rewrite silently re-parents the param. No static check
+        #   can compare the two — review the diff.
+        # - Sibling `label:`/`placeholder:` are NOT auto-deleted; verify the
+        #   i18n keys exist, then remove them manually.
+        #
+        # NOTE: a bare `name: 'something'` (no brackets) that should have
+        # been `prop:` is statically indistinguishable from a legitimately
+        # unbound field, so it is not flagged — a render-time assertion could
+        # close that gap later.
+        #
+        # @example
+        #   # bad
+        #   form.fields_text name: 'user[email]', label: 'Email'
+        #
+        #   # good
+        #   form.fields_text prop: :email
+        #
+        #   # good — hidden fields are exempt by default
+        #   form.fields_hidden name: 'user[reset_password_token]', value: token
+        class PreferPropOverName < Base
+          extend AutoCorrector
+
+          MSG = 'Bind the model attribute with `prop: :%<attr>s` instead of `name: %<name>s` — ' \
+                '`prop:` resolves label/placeholder/validation from i18n. After switching, remove ' \
+                'the now-redundant hardcoded `label:`/`placeholder:` (verify the i18n keys exist). ' \
+                'If this field deliberately posts a raw param, disable with a reason.'.freeze
+
+          MODEL_ATTR_NAME = /\A\w+\[(\w+)\]\z/
+
+          def on_send(node)
+            return unless node.method_name.to_s.start_with?('fields_')
+            return if exempt_field_methods.include?(node.method_name.to_s)
+
+            pair = bracket_name_pair(node)
+            return unless pair
+
+            attr = pair.value.value[MODEL_ATTR_NAME, 1]
+            add_offense(pair, message: format(MSG, attr: attr, name: pair.value.source)) do |corrector|
+              corrector.replace(pair, "prop: :#{attr}")
+            end
+          end
+
+          private
+
+          # The `name:` kwarg pair whose literal string value has the
+          # single-level `model[attr]` shape. Dynamic values and bare names
+          # are not provably model-bound, so they are left alone.
+          def bracket_name_pair(node)
+            hash = node.arguments.find(&:hash_type?)
+            return nil unless hash
+
+            hash.pairs.find do |pair|
+              pair.key.sym_type? && pair.key.value == :name &&
+                pair.value.str_type? && pair.value.value.match?(MODEL_ATTR_NAME)
+            end
+          end
+
+          def exempt_field_methods
+            cop_config.fetch('ExemptFieldMethods', %w[fields_hidden])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/dev_doc/version.rb

@@ -1,5 +1,5 @@
 module RuboCop
   module DevDoc
-    VERSION = "0.7.0".freeze
+    VERSION = "0.8.0".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-dev_doc
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - dev-doc contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-03 00:00:00.000000000 Z
+date: 2026-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -90,6 +90,7 @@ files:
 - lib/dev_doc/test/best_practice_lints.rb
 - lib/dev_doc/test/lints/cron_schedule.rb
 - lib/dev_doc/test/lints/duplicate_snapshot.rb
+- lib/dev_doc/test/lints/http_driven_controller_tests.rb
 - lib/dev_doc/test/lints/no_file_excludes.rb
 - lib/rubocop-dev_doc.rb
 - lib/rubocop/cop/dev_doc/auth/current_user_branching.rb
@@ -131,16 +132,24 @@ files:
 - lib/rubocop/cop/dev_doc/style/avoid_head_response.rb
 - lib/rubocop/cop/dev_doc/style/avoid_options_hash.rb
 - lib/rubocop/cop/dev_doc/style/avoid_send.rb
+- lib/rubocop/cop/dev_doc/style/literal_operator_in_condition.rb
+- lib/rubocop/cop/dev_doc/style/literal_or_in_when_clause.rb
 - lib/rubocop/cop/dev_doc/style/minimize_variable_scope.rb
 - lib/rubocop/cop/dev_doc/style/no_unscoped_method_definitions.rb
 - lib/rubocop/cop/dev_doc/style/prefer_public_send.rb
+- lib/rubocop/cop/dev_doc/style/redundant_guard_after_bang.rb
 - lib/rubocop/cop/dev_doc/style/repeated_bracket_read.rb
 - lib/rubocop/cop/dev_doc/style/repeated_safe_navigation_receiver.rb
 - lib/rubocop/cop/dev_doc/style/string_symbol_comparison.rb
 - lib/rubocop/cop/dev_doc/style/tap_block_ignores_value.rb
 - lib/rubocop/cop/dev_doc/test/avoid_glib_travel_freeze.rb
 - lib/rubocop/cop/dev_doc/test/avoid_unit_test.rb
+- lib/rubocop/cop/dev_doc/test/require_glib_integration_base.rb
+- lib/rubocop/cop/dev_doc/test/require_glib_travel.rb
+- lib/rubocop/cop/dev_doc/test/require_glib_travel_block.rb
+- lib/rubocop/cop/dev_doc/test/require_unit_test_justification.rb
 - lib/rubocop/cop/dev_doc/test/response_assert_equal.rb
+- lib/rubocop/cop/dev_doc/view/prefer_prop_over_name.rb
 - lib/rubocop/dev_doc.rb
 - lib/rubocop/dev_doc/plugin.rb
 - lib/rubocop/dev_doc/version.rb