rubocop-dev_doc 0.1.0 → 0.3.0

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

@@ -0,0 +1,118 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Style
+        # Avoid using `&.` on the same receiver more than once in a method body.
+        #
+        # ## Rationale
+        # When a receiver appears with `&.` repeatedly across a method, the
+        # reader has to mentally re-evaluate the nil case at every call, and
+        # the *intent* of each `&.` becomes ambiguous — is this call nullable
+        # for a fresh reason, or is the dev just mirroring the earlier `&.`
+        # out of habit? Repetition also propagates nil silently into
+        # downstream comparisons (`current_user&.id == something` evaluates
+        # to `nil == something`, which is false but not for the reason the
+        # reader expects).
+        #
+        # Resolve the nil case once at the top of the method, then use the
+        # local with plain `.`:
+        #
+        #   ❌
+        #   def show?
+        #     current_user&.super_admin? ||
+        #       current_user&.developer?  ||
+        #       current_user&.admin_of_organization?(organization)
+        #   end
+        #
+        #   ✔️ Guard once, then plain calls
+        #   def show?
+        #     return false unless current_user
+        #
+        #     current_user.super_admin? ||
+        #       current_user.developer?  ||
+        #       current_user.admin_of_organization?(organization)
+        #   end
+        #
+        #   ✔️ Alternative — assign-and-test in the condition
+        #   def label
+        #     if (user = current_user)
+        #       "#{user.full_name} <#{user.email}>"
+        #     end
+        #   end
+        #
+        # The cop is policy-safe by design: it does not assume anything
+        # about `current_user` non-nullability or branching semantics — it
+        # only flags repeated `&.` on the same receiver, which is a smell
+        # regardless of whether the receiver is `current_user`, a model
+        # attribute, or a local variable.
+        #
+        # ## Exception
+        # Legitimate cases (e.g. when the repeated calls are conceptually
+        # distinct sources that happen to share source spelling) go through
+        # inline `# rubocop:disable` with a reason.
+        #
+        # NOTE: Receivers are compared by source text — two `&.` calls
+        # share a receiver if their source spelling matches verbatim. The
+        # cop does not perform flow analysis, so a receiver reassigned
+        # between uses is not detected (false negative).
+        #
+        # NOTE: Scope is the enclosing `def`/`defs` body. The cop does not
+        # partition by inner blocks, so the same parameter name reused
+        # across separate block bodies in one method may produce a false
+        # positive — inline-disable with a reason if it surfaces.
+        #
+        # @example
+        #   # bad — same receiver, multiple safe-nav reads
+        #   def card
+        #     name = current_user&.full_name
+        #     email = current_user&.email
+        #   end
+        #
+        #   # bad — same receiver, multiple safe-nav predicates
+        #   def show?
+        #     user&.super_admin? || user&.developer?
+        #   end
+        #
+        #   # good — assign once, then plain calls
+        #   def show?
+        #     return false unless user
+        #
+        #     user.super_admin? || user.developer?
+        #   end
+        #
+        #   # good — single use of safe-nav
+        #   def label
+        #     current_user&.full_name
+        #   end
+        class RepeatedSafeNavigationReceiver < Base
+          MSG = "Receiver `%<receiver>s` already used with `&.` earlier in this method — assign once and use `.` after.".freeze
+
+          def on_def(node)
+            check_method(node)
+          end
+          alias on_defs on_def
+
+          private
+
+          def check_method(def_node)
+            body = def_node.body
+            return unless body
+
+            seen = {}
+            body.each_descendant(:csend) do |csend|
+              receiver = csend.receiver
+              next unless receiver
+
+              key = receiver.source
+              if seen[key]
+                add_offense(csend.loc.dot, message: format(MSG, receiver: key))
+              else
+                seen[key] = true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Style
+        # Flag direct `==` / `!=` comparisons between a known-string source
+        # and a symbol literal. Such comparisons are silently always false
+        # (`'draft' == :draft` is `false` in Ruby), so they signal that the
+        # caller forgot to convert at the boundary.
+        #
+        # ## Rationale
+        # Strings and symbols are not equal in Ruby, and string-typed values
+        # arrive from boundaries the developer doesn't control: HTTP params,
+        # request headers, ENV. Comparing one of these directly against a
+        # symbol literal is a guaranteed bug. Convert at the boundary instead
+        # — see `best_practices/backend/en/01a_defensive_programming.md` item 7.
+        #
+        #   ❌
+        #   if params[:status] == :draft   # always false
+        #
+        #   ✔ Convert at the boundary, then compare
+        #   @filter_status = params[:status]&.to_sym
+        #   if @filter_status == :draft
+        #
+        # ## Sources detected
+        # - `params[…]`
+        # - `request.headers[…]`
+        # - `ENV[…]`
+        #
+        # ## Limitations
+        # The cop only catches the *direct* comparison form. Once the value
+        # flows into a local or instance variable, type information is lost
+        # and Rubocop cannot trace it back to the original string source.
+        # Those cases are caught by review.
+        #
+        # @example
+        #   # bad
+        #   params[:status] == :draft
+        #   :production == ENV['MODE']
+        #   request.headers['X-Mode'] != :debug
+        #
+        #   # good
+        #   params[:status]&.to_sym == :draft
+        #   ENV['MODE'] == 'production'
+        class StringSymbolComparison < Base
+          MSG = 'Comparing string-typed `%<source>s` to a symbol literal is always false. ' \
+                'Convert at the boundary with `&.to_sym` or compare against a string instead ' \
+                '(see backend/01a_defensive_programming.md item 7).'.freeze
+
+          RESTRICT_ON_SEND = %i[== !=].freeze
+
+          def_node_matcher :params_access?, <<~PATTERN
+            (send (send nil? :params) :[] _)
+          PATTERN
+
+          def_node_matcher :request_headers_access?, <<~PATTERN
+            (send (send _ :headers) :[] _)
+          PATTERN
+
+          def_node_matcher :env_access?, <<~PATTERN
+            (send (const nil? :ENV) :[] _)
+          PATTERN
+
+          def on_send(node)
+            lhs = node.receiver
+            rhs = node.first_argument
+            return unless lhs && rhs
+
+            source_node = pick_string_source(lhs, rhs)
+            return unless source_node
+
+            add_offense(node, message: format(MSG, source: source_node.source))
+          end
+
+          private
+
+          def pick_string_source(left, right)
+            if string_source?(left) && right.sym_type?
+              left
+            elsif string_source?(right) && left.sym_type?
+              right
+            end
+          end
+
+          def string_source?(node)
+            params_access?(node) || request_headers_access?(node) || env_access?(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Test
+        # Flag `glib_travel_freeze` calls in test files — use `glib_travel` instead.
+        #
+        # ## Rationale
+        # `glib_travel_freeze` stops the clock completely, which is not representative
+        # of real-world behavior: in production, time ticks as code executes.
+        # We have had bugs that went undetected in tests because `glib_travel_freeze`
+        # masked timing issues, only to surface in production.
+        #
+        # `glib_travel` advances time normally inside the block — use it instead.
+        # Reserve `glib_travel_freeze` only as a last resort when `glib_travel`
+        # truly cannot work for a specific test, and document why.
+        #
+        # ## Escape hatch
+        # Disable per-line with a comment explaining why `glib_travel` doesn't work:
+        #
+        #   glib_travel_freeze(time) do  # rubocop:disable DevDoc/Test/AvoidGlibTravelFreeze
+        #     # Reason: <explanation>
+        #   end
+        #
+        # @example
+        #   # bad
+        #   glib_travel_freeze(Time.current) do
+        #     expect(order.expired?).to be true
+        #   end
+        #
+        #   # bad (non-block form)
+        #   glib_travel_freeze(Time.current)
+        #   expect(order.expired?).to be true
+        #
+        #   # good
+        #   glib_travel(Time.current) do
+        #     expect(order.expired?).to be true
+        #   end
+        class AvoidGlibTravelFreeze < Base
+          MSG = 'Avoid `glib_travel_freeze` — 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.'
+
+          RESTRICT_ON_SEND = %i[glib_travel_freeze].freeze
+
+          def on_send(node)
+            add_offense(node.loc.selector)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Test
+        # Prefer controller tests; flag unit/service tests (`< ActiveSupport::TestCase`).
+        #
+        # ## Rationale
+        # What the user sees and experiences is what matters; internal
+        # implementation does not. A controller test exercises behaviour
+        # end-to-end through the same path a user takes, so it catches the
+        # regressions that actually reach production. A unit/service test is only
+        # needed when a code path genuinely cannot be reached through a
+        # controller test (very rare) — e.g. a search-ranking detail the
+        # controller never exposes.
+        #
+        # This cop flags only the literal `< ActiveSupport::TestCase`
+        # superclass. The blessed blackbox bases —
+        # `ActionDispatch::IntegrationTest`, `Glib::IntegrationTest`,
+        # `ActionMailer::TestCase`, `ActiveJob::TestCase` — are NOT flagged, even
+        # though they inherit from `ActiveSupport::TestCase` transitively.
+        #
+        # ## Escape hatch
+        # 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:
+        #
+        #   # rubocop:disable DevDoc/Test/AvoidUnitTest -- search ranking isn't visible through the controller
+        #   class Ai::Retrieval::PgSearchStrategyTest < ActiveSupport::TestCase
+        #     # ...
+        #   end
+        #   # rubocop:enable DevDoc/Test/AvoidUnitTest
+        #
+        # NOTE: The cop matches the *direct* superclass only. A project base
+        # (`class ApplicationServiceTest < ActiveSupport::TestCase`) is flagged
+        # once (justify it there); subclasses of that base are not re-flagged.
+        #
+        # @example
+        #   # bad
+        #   class NoteRenderingTest < ActiveSupport::TestCase
+        #   end
+        #
+        #   # good — exercised through the controller
+        #   class NotesControllerTest < ActionDispatch::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
+        #   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
+
+          def on_class(node)
+            superclass = node.parent_class
+            return unless superclass&.const_type?
+            return unless superclass.const_name == 'ActiveSupport::TestCase'
+
+            add_offense(superclass)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,179 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Test
+        # Controller tests that assert on the rendered `response.body` should
+        # also snapshot the full response with `response_assert_equal`.
+        #
+        # ## Rationale
+        # `response_assert_equal` (glib-web's `Glib::TestHelpers`) is the most
+        # blackbox assertion available — it snapshots the entire rendered
+        # response, so it catches regressions anywhere in the output, not just
+        # the one substring a targeted assertion happens to check. Per the
+        # testing best practice, happy- and unhappy-path controller tests
+        # should always use it.
+        #
+        # The common slip this cop guards against: a test inspects the rendered
+        # body with `assert_match` / `assert_no_match` / `assert_includes` /
+        # `response.body.scan(...)` but forgets the snapshot. The targeted
+        # assertion documents intent, but on its own it only proves the one
+        # line — collateral changes elsewhere in the response slip through.
+        #
+        #   ❌ Inspects the body, but no snapshot
+        #   test 'index lists the item' do
+        #     get items_url(format: :json)
+        #     assert_response :success
+        #     assert_match 'Widget', response.body
+        #   end
+        #
+        #   ✔️ Keep the focused assertion AND snapshot the whole response
+        #   test 'index lists the item' do
+        #     get items_url(format: :json)
+        #     assert_response :success
+        #     assert_match 'Widget', response.body
+        #     response_assert_equal
+        #   end
+        #
+        # ## What is NOT flagged
+        # - Tests that already call `response_assert_equal`.
+        # - Exception/redirect paths — a test asserting a non-success status
+        #   (`assert_response :not_found`, `:forbidden`, `:redirect`, etc.)
+        #   often has no stable rendered body to snapshot.
+        # - State-change tests that never read `response.body` (e.g.
+        #   `assert_difference 'Model.count'`, mailer assertions). Passing
+        #   `response.body` to a helper like `submit_form(response.body, ...)`
+        #   is not a body assertion and is not flagged.
+        #
+        # ## Inline disable
+        # For the rare happy-path test whose response is genuinely
+        # non-deterministic and cannot be made stable, add a
+        # `rubocop:disable DevDoc/Test/ResponseAssertEqual` comment to the
+        # `test '...' do` line, with a written reason on the next line
+        # (e.g. "chunked response includes a per-run boundary token").
+        #
+        # @example
+        #   # bad
+        #   test 'shows the row' do
+        #     get foo_url(format: :json)
+        #     assert_match 'bar', response.body
+        #   end
+        #
+        #   # good
+        #   test 'shows the row' do
+        #     get foo_url(format: :json)
+        #     assert_match 'bar', response.body
+        #     response_assert_equal
+        #   end
+        class ResponseAssertEqual < Base
+          MSG = 'Asserts on `response.body` but never calls `response_assert_equal`. ' \
+                'Add the snapshot assertion (usually last) — it captures the whole rendered ' \
+                'response, a stronger guard than a targeted body assertion. Exception-path ' \
+                'tests that cannot snapshot may disable this cop with a reason.'.freeze
+
+          # @!method test_block?(node)
+          def_node_matcher :test_block?, <<~PATTERN
+            (block (send nil? :test ...) _args _body)
+          PATTERN
+
+          # @!method response_body_read?(node)
+          def_node_matcher :response_body_read?, <<~PATTERN
+            (send (send nil? :response) {:body :parsed_body})
+          PATTERN
+
+          # @!method calls_snapshot?(node)
+          def_node_search :calls_snapshot?, <<~PATTERN
+            (send nil? :response_assert_equal)
+          PATTERN
+
+          # @!method response_status?(node)
+          def_node_matcher :response_status?, '(send (send nil? :response) :status)'
+
+          # Non-success HTTP statuses (symbol form). A test asserting any of
+          # these is an exception / redirect / empty-body path — no JSON body
+          # to snapshot.
+          NON_SUCCESS_STATUS_SYMBOLS = %i[
+            not_found forbidden unauthorized unprocessable_entity unprocessable_content
+            bad_request conflict gone no_content not_modified redirect moved_permanently
+            found see_other payment_required too_many_requests precondition_failed
+          ].freeze
+
+          def on_block(node)
+            return unless test_block?(node)
+            return unless node.body
+            return if calls_snapshot?(node)
+            return if exempt_from_snapshot?(node)
+            return unless inspects_response_body?(node)
+
+            add_offense(node.send_node.loc.selector)
+          end
+
+          private
+
+          # Exception / redirect / empty-body responses can't (and shouldn't) be
+          # snapshotted. Handles both the `assert_response :symbol` convention
+          # and the numeric `assert_response 404` / `assert_equal 404,
+          # response.status` convention, plus `assert_empty response.body`.
+          def exempt_from_snapshot?(test_node)
+            test_node.each_descendant(:send).any? { |s| non_snapshotable_assertion?(s) }
+          end
+
+          def non_snapshotable_assertion?(send_node)
+            case send_node.method_name
+            when :assert_response then non_success_status?(send_node.first_argument)
+            when :assert_equal then non_success_status_equal?(send_node)
+            when :assert_empty then response_body_read?(send_node.first_argument)
+            else false
+            end
+          end
+
+          # `assert_equal <non-2xx code>, response.status`
+          def non_success_status_equal?(send_node)
+            args = send_node.arguments
+            args.size >= 2 && non_success_status?(args[0]) && response_status?(args[1])
+          end
+
+          # A non-success status: a symbol (`:not_found`) or a numeric code
+          # >= 300 (`404`). 2xx codes are NOT exempt — they should snapshot.
+          def non_success_status?(node)
+            return false unless node
+
+            (node.sym_type? && NON_SUCCESS_STATUS_SYMBOLS.include?(node.value)) ||
+              (node.int_type? && node.value >= 300)
+          end
+
+          # True when the test inspects the response *as JSON*. Three forms count:
+          #   - `response.parsed_body` (any use — it's the JSON-parsed body)
+          #   - `JSON.parse(response.body)` (explicit JSON parse, even if the
+          #     result is stored in a local first)
+          #   - `response.body` directly inside an assertion
+          #     (`assert_match 'x', response.body`)
+          #
+          # Deliberately NOT counted: `response.body` fed to a format-specific
+          # parser (`parse_xlsx`, `CSV.parse`, `Nokogiri…parse`) or a render/submit
+          # helper (`submit_form`) — those are non-JSON or pass-through, and
+          # `response_assert_equal` (JSON-only) can't snapshot them.
+          def inspects_response_body?(test_node)
+            test_node.each_descendant(:send).any? do |read|
+              next false unless response_body_read?(read)
+
+              read.method_name == :parsed_body || asserted?(read) || json_parsed?(read)
+            end
+          end
+
+          # `response.body` / `response.parsed_body` read within an assertion.
+          def asserted?(read)
+            read.each_ancestor(:send).any? { |a| a.method_name.to_s.start_with?('assert') }
+          end
+
+          # `JSON.parse(response.body)` — the JSON constant specifically, so
+          # format-specific parsers (`parse_xlsx`, `CSV.parse`) don't match.
+          def json_parsed?(read)
+            parent = read.parent
+            parent&.send_type? && parent.method_name == :parse &&
+              parent.receiver&.const_type? && parent.receiver.const_name == 'JSON'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/dev_doc/version.rb

@@ -1,5 +1,5 @@
 module RuboCop
   module DevDoc
-    VERSION = "0.1.0".freeze
+    VERSION = "0.3.0".freeze
   end
 end

data/lib/rubocop-dev_doc.rb

@@ -1,3 +1,4 @@
 require "rubocop"
+require "rubocop-rails"
 require "lint_roller"
 require_relative "rubocop/dev_doc"

metadata

@@ -1,42 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-dev_doc
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - dev-doc contributors
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.72'
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.72'
+        version: '4.2'
 - !ruby/object:Gem::Dependency
-  name: rubocop-rails
+  name: fugit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.9'
 - !ruby/object:Gem::Dependency
   name: lint_roller
   requirement: !ruby/object:Gem::Requirement
@@ -51,31 +52,92 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.72'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.72'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description:
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - config/default.yml
+- 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/no_file_excludes.rb
 - lib/rubocop-dev_doc.rb
+- lib/rubocop/cop/dev_doc/auth/current_user_branching.rb
+- lib/rubocop/cop/dev_doc/auth/load_resource_current_user_guard.rb
+- lib/rubocop/cop/dev_doc/migration/amount_column_in_cents.rb
+- lib/rubocop/cop/dev_doc/migration/avoid_bypassing_validation.rb
 - lib/rubocop/cop/dev_doc/migration/avoid_column_default.rb
+- lib/rubocop/cop/dev_doc/migration/avoid_conditional_schema_changes.rb
 - lib/rubocop/cop/dev_doc/migration/avoid_json_column.rb
-- lib/rubocop/cop/dev_doc/migration/avoid_update_column.rb
+- lib/rubocop/cop/dev_doc/migration/avoid_non_null.rb
 - lib/rubocop/cop/dev_doc/migration/avoid_vague_column_names.rb
 - lib/rubocop/cop/dev_doc/migration/date_column_naming.rb
+- lib/rubocop/cop/dev_doc/migration/no_create_join_table.rb
 - lib/rubocop/cop/dev_doc/migration/prefer_belongs_to.rb
+- lib/rubocop/cop/dev_doc/migration/require_primary_key.rb
 - lib/rubocop/cop/dev_doc/migration/require_timestamps.rb
+- lib/rubocop/cop/dev_doc/rails/application_record_transaction.rb
+- lib/rubocop/cop/dev_doc/rails/avoid_rails_callbacks.rb
+- lib/rubocop/cop/dev_doc/rails/bang_save_in_transaction.rb
+- lib/rubocop/cop/dev_doc/rails/enum_column_not_null.rb
+- lib/rubocop/cop/dev_doc/rails/enum_must_be_symbolized.rb
+- lib/rubocop/cop/dev_doc/rails/no_block_predicate_on_relation.rb
 - lib/rubocop/cop/dev_doc/rails/no_deliver_later_in_transaction.rb
 - lib/rubocop/cop/dev_doc/rails/no_perform_later_in_model.rb
+- lib/rubocop/cop/dev_doc/rails/strong_parameters_expect.rb
+- lib/rubocop/cop/dev_doc/route/no_custom_actions.rb
+- lib/rubocop/cop/dev_doc/route/resource_name_number.rb
 - lib/rubocop/cop/dev_doc/route/resources_require_only.rb
 - 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/minimize_variable_scope.rb
+- lib/rubocop/cop/dev_doc/style/no_unscoped_method_definitions.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/test/avoid_glib_travel_freeze.rb
+- lib/rubocop/cop/dev_doc/test/avoid_unit_test.rb
+- lib/rubocop/cop/dev_doc/test/response_assert_equal.rb
 - lib/rubocop/dev_doc.rb
 - lib/rubocop/dev_doc/plugin.rb
 - lib/rubocop/dev_doc/version.rb
+homepage:
 licenses: []
 metadata:
   default_lint_roller_plugin: RuboCop::DevDoc::Plugin
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -90,7 +152,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.4.6
+signing_key:
 specification_version: 4
 summary: RuboCop cops enforcing dev-doc best practices
 test_files: []