rubocop-callbacksystems 0.1.0

data/docs/cops.md

@@ -0,0 +1,111 @@
+# Cops
+
+<!-- Generated by `bin/docs`. Do not edit by hand. -->
+
+Every cop lives under the `Callbacksystems/` namespace and ships enabled. Each one links to its source, where an `@example` block contrasts the code it rejects with the code it asks for, and `config/default.yml` holds its options and default scope.
+
+| Cop | Autocorrect | Description |
+|---|---|---|
+| [`Callbacksystems/ApplicationControllerMethodDefinition`](../lib/rubocop/cop/callbacksystems/application_controller_method_definition.rb) |  | Prohibits defining methods directly in ApplicationController. |
+| [`Callbacksystems/AssertWithExpectedArgument`](../lib/rubocop/cop/callbacksystems/assert_with_expected_argument.rb) |  | Flags a two-argument `assert` whose second argument is not a failure message. |
+| [`Callbacksystems/BodyOrder`](../lib/rubocop/cop/callbacksystems/body_order.rb) | yes | Orders a class body: mixins, constants, class declarations, state declarations, associations, delegates, macros, methods, nested classes. |
+| [`Callbacksystems/BuilderMethodParentheses`](../lib/rubocop/cop/callbacksystems/builder_method_parentheses.rb) | yes | Requires parentheses on builder method calls that take arguments. |
+| [`Callbacksystems/CollapseMultilineExpression`](../lib/rubocop/cop/callbacksystems/collapse_multiline_expression.rb) | yes | Collapses multiline expressions that fit on a single line. |
+| [`Callbacksystems/CommentBlockLength`](../lib/rubocop/cop/callbacksystems/comment_block_length.rb) |  | Limits how many lines a comment block takes. |
+| [`Callbacksystems/ComplexConditional`](../lib/rubocop/cop/callbacksystems/complex_conditional.rb) |  | Limits boolean operators in a conditional, so predicates get extracted. |
+| [`Callbacksystems/ControllerTestResponseAssertion`](../lib/rubocop/cop/callbacksystems/controller_test_response_assertion.rb) |  | Requires every controller test that makes a request to assert the response. |
+| [`Callbacksystems/ControllerTestResponseFirstAssertion`](../lib/rubocop/cop/callbacksystems/controller_test_response_first_assertion.rb) |  | Requires the response assertion to come first after a request in controller tests. |
+| [`Callbacksystems/DataClump`](../lib/rubocop/cop/callbacksystems/data_clump.rb) |  | Detects parameter names that travel together across private methods and belong in an object of their own. |
+| [`Callbacksystems/DeclarativeMethodNaming`](../lib/rubocop/cop/callbacksystems/declarative_method_naming.rb) |  | Requires a value-returning method to be named for the value, not the action. |
+| [`Callbacksystems/DelegateRequiresPrivateOption`](../lib/rubocop/cop/callbacksystems/delegate_requires_private_option.rb) | yes | Requires `private: true` on a `delegate` that stands in the private section. |
+| [`Callbacksystems/EagerLoadingScopeNaming`](../lib/rubocop/cop/callbacksystems/eager_loading_scope_naming.rb) |  | Reserves `with_*` for eager loading scopes and requires specific association names. |
+| [`Callbacksystems/EarlyReturn`](../lib/rubocop/cop/callbacksystems/early_return.rb) |  | Allows a single guard clause on the first line as the only early exit. |
+| [`Callbacksystems/EmptyLineBeforeMethod`](../lib/rubocop/cop/callbacksystems/empty_line_before_method.rb) | yes | Requires an empty line before a method definition. |
+| [`Callbacksystems/EmptyLineBetweenSections`](../lib/rubocop/cop/callbacksystems/empty_line_between_sections.rb) | yes | Requires a blank line between two adjacent statements of different sections of a class body. |
+| [`Callbacksystems/EmptyPrivateSection`](../lib/rubocop/cop/callbacksystems/empty_private_section.rb) | yes | Flags a `private` keyword that declares an empty section. |
+| [`Callbacksystems/ExpandedEmptyClassOrModule`](../lib/rubocop/cop/callbacksystems/expanded_empty_class_or_module.rb) | yes | Requires an empty class or module to keep its `end` on a line of its own. |
+| [`Callbacksystems/InlineMemoizedComputation`](../lib/rubocop/cop/callbacksystems/inline_memoized_computation.rb) |  | Requires the computation to be inlined in the method that memoizes it. |
+| [`Callbacksystems/JobEnqueueMethods`](../lib/rubocop/cop/callbacksystems/job_enqueue_methods.rb) |  | Requires a method that enqueues a job to carry the `_later` suffix. |
+| [`Callbacksystems/MaxSafeNavigationDepth`](../lib/rubocop/cop/callbacksystems/max_safe_navigation_depth.rb) |  | Limits the depth of a chain of safe navigation calls. |
+| [`Callbacksystems/MethodInvocationOrder`](../lib/rubocop/cop/callbacksystems/method_invocation_order.rb) | yes | Requires methods to be ordered by invocation, each caller before its callees. |
+| [`Callbacksystems/NestedClassOrder`](../lib/rubocop/cop/callbacksystems/nested_class_order.rb) | yes | Requires nested classes to be ordered by reference, each before the ones it names. |
+| [`Callbacksystems/NoAbbreviations`](../lib/rubocop/cop/callbacksystems/no_abbreviations.rb) |  | Requires full words in declared names, including CamelCase, while preserving Ruby and Rails vocabulary. |
+| [`Callbacksystems/NoAnemicDelegation`](../lib/rubocop/cop/callbacksystems/no_anemic_delegation.rb) |  | Flags a private method that only delegates to a freshly built object. |
+| [`Callbacksystems/NoAnemicRecord`](../lib/rubocop/cop/callbacksystems/no_anemic_record.rb) |  | Detects a hash literal of several fields read across methods, which reads better as a class. |
+| [`Callbacksystems/NoAssertSelect`](../lib/rubocop/cop/callbacksystems/no_assert_select.rb) |  | Prohibits `assert_select` in tests. |
+| [`Callbacksystems/NoBangMethodWithoutCounterpart`](../lib/rubocop/cop/callbacksystems/no_bang_method_without_counterpart.rb) |  | Prohibits a bang method without a non-bang counterpart. |
+| [`Callbacksystems/NoCallMethod`](../lib/rubocop/cop/callbacksystems/no_call_method.rb) |  | Prohibits defining a method named `call`, except for Rack middleware endpoints. |
+| [`Callbacksystems/NoCommentsInTestClassBody`](../lib/rubocop/cop/callbacksystems/no_comments_in_test_class_body.rb) |  | Prohibits comments in the direct body of a test class. |
+| [`Callbacksystems/NoConsecutiveAppends`](../lib/rubocop/cop/callbacksystems/no_consecutive_appends.rb) | yes | Collapses consecutive appends to one collection into a single `push`. |
+| [`Callbacksystems/NoCustomRouteActions`](../lib/rubocop/cop/callbacksystems/no_custom_route_actions.rb) |  | Keeps routes on the standard resource actions. |
+| [`Callbacksystems/NoDirectEagerLoading`](../lib/rubocop/cop/callbacksystems/no_direct_eager_loading.rb) |  | Keeps `preload`, `eager_load`, and `includes` inside `app/models` behind named scopes. |
+| [`Callbacksystems/NoEachWithEarlyReturn`](../lib/rubocop/cop/callbacksystems/no_each_with_early_return.rb) |  | Prefers `find` over an `each` block with a conditional early return. |
+| [`Callbacksystems/NoExplicitPublicModifier`](../lib/rubocop/cop/callbacksystems/no_explicit_public_modifier.rb) | yes | Prohibits the explicit `public` modifier. |
+| [`Callbacksystems/NoHashWithDefaultBlock`](../lib/rubocop/cop/callbacksystems/no_hash_with_default_block.rb) |  | Prefers declarative grouping over `Hash.new` with a default block. |
+| [`Callbacksystems/NoLocalVariableReturn`](../lib/rubocop/cop/callbacksystems/no_local_variable_return.rb) | yes | Prohibits returning a local variable as the last statement of a method. |
+| [`Callbacksystems/NoManualAccumulation`](../lib/rubocop/cop/callbacksystems/no_manual_accumulation.rb) |  | Prefers declarative collection methods over filling an empty array or hash inside `each`. |
+| [`Callbacksystems/NoMixedMemoization`](../lib/rubocop/cop/callbacksystems/no_mixed_memoization.rb) |  | Prohibits mixing memoization with other statements in the same method. |
+| [`Callbacksystems/NoNestedModulesInClasses`](../lib/rubocop/cop/callbacksystems/no_nested_modules_in_classes.rb) |  | Prohibits a module nested inside a class. |
+| [`Callbacksystems/NoNilAtEndOfMethod`](../lib/rubocop/cop/callbacksystems/no_nil_at_end_of_method.rb) |  | Prohibits a trailing `nil` at the end of a method. |
+| [`Callbacksystems/NoRedundantValidationName`](../lib/rubocop/cop/callbacksystems/no_redundant_validation_name.rb) |  | Requires a validation callback to name its condition without repeating `valid` or `validate`. |
+| [`Callbacksystems/NoRedundantWrapperMethod`](../lib/rubocop/cop/callbacksystems/no_redundant_wrapper_method.rb) |  | Flags a private method that only forwards to another call. |
+| [`Callbacksystems/NoSectionDividerComments`](../lib/rubocop/cop/callbacksystems/no_section_divider_comments.rb) | yes | Prohibits ASCII-art section divider comments. |
+| [`Callbacksystems/NoSendInTests`](../lib/rubocop/cop/callbacksystems/no_send_in_tests.rb) |  | Prohibits `send` and `__send__` in tests. |
+| [`Callbacksystems/NoServiceObjects`](../lib/rubocop/cop/callbacksystems/no_service_objects.rb) |  | Prohibits service object directories under `app/`. |
+| [`Callbacksystems/NoSingleLetterNames`](../lib/rubocop/cop/callbacksystems/no_single_letter_names.rb) |  | Prohibits single-letter variable, block argument, and parameter names. |
+| [`Callbacksystems/NoSingletonClassInModules`](../lib/rubocop/cop/callbacksystems/no_singleton_class_in_modules.rb) |  | Prefers `extend self` over `class << self` in a module. |
+| [`Callbacksystems/NoTapCollectionBuilding`](../lib/rubocop/cop/callbacksystems/no_tap_collection_building.rb) |  | Prohibits building a collection imperatively with `tap`. |
+| [`Callbacksystems/NoTurboStreamInControllers`](../lib/rubocop/cop/callbacksystems/no_turbo_stream_in_controllers.rb) |  | Keeps Turbo Stream markup out of controllers. |
+| [`Callbacksystems/NoTypographicClutter`](../lib/rubocop/cop/callbacksystems/no_typographic_clutter.rb) | yes | Prohibits typographic punctuation and double-hyphen dashes in comments, and invisible characters in comments and strings. |
+| [`Callbacksystems/NoWritesInGetActions`](../lib/rubocop/cop/callbacksystems/no_writes_in_get_actions.rb) |  | Keeps GET actions free of writes and enqueued side effects. |
+| [`Callbacksystems/OrderedMixinArguments`](../lib/rubocop/cop/callbacksystems/ordered_mixin_arguments.rb) | yes | Requires mixin arguments to be sorted alphabetically. |
+| [`Callbacksystems/PluralControllerNames`](../lib/rubocop/cop/callbacksystems/plural_controller_names.rb) |  | Requires controller names to be plural. |
+| [`Callbacksystems/PreferAttrReaderOverInstanceVariable`](../lib/rubocop/cop/callbacksystems/prefer_attr_reader_over_instance_variable.rb) |  | Prefers an `attr_reader` over reading an instance variable assigned in `initialize`. |
+| [`Callbacksystems/PreferBackslashContinuation`](../lib/rubocop/cop/callbacksystems/prefer_backslash_continuation.rb) | yes | Prefers backslash continuation over parentheses for a multiline call that cannot fit on one line. |
+| [`Callbacksystems/PreferClassForState`](../lib/rubocop/cop/callbacksystems/prefer_class_for_state.rb) |  | Detects a value threaded through many methods that reads better as class state. |
+| [`Callbacksystems/PreferClassNewForEmptyNestedClass`](../lib/rubocop/cop/callbacksystems/prefer_class_new_for_empty_nested_class.rb) | yes | Prefers a `Class.new` constant over a nested class with no body. |
+| [`Callbacksystems/PreferClassOverBuilderBlock`](../lib/rubocop/cop/callbacksystems/prefer_class_over_builder_block.rb) | yes | Prefers a class over a `Data.define`, `Struct.new`, or `Class.new` given a block. |
+| [`Callbacksystems/PreferDefaultArgument`](../lib/rubocop/cop/callbacksystems/prefer_default_argument.rb) |  | Prefers a default in the signature over a fallback assigned at the top of the method. |
+| [`Callbacksystems/PreferDelegate`](../lib/rubocop/cop/callbacksystems/prefer_delegate.rb) | yes | Prefers `delegate` over a method that only forwards to a same-named method. |
+| [`Callbacksystems/PreferDelegateOverInstanceVariableAssignment`](../lib/rubocop/cop/callbacksystems/prefer_delegate_over_instance_variable_assignment.rb) |  | Prefers `delegate` over an `initialize` assignment that mirrors a method call. |
+| [`Callbacksystems/PreferExcluding`](../lib/rubocop/cop/callbacksystems/prefer_excluding.rb) | yes | Prefers `excluding` for collection subtraction and suggests it for record-ID exclusions. |
+| [`Callbacksystems/PreferExtractAssociated`](../lib/rubocop/cop/callbacksystems/prefer_extract_associated.rb) | yes | Prefers `extract_associated` over preloading and collecting the same association in a model. |
+| [`Callbacksystems/PreferItBlockParameter`](../lib/rubocop/cop/callbacksystems/prefer_it_block_parameter.rb) | yes | Prefers `it` over a single named parameter in a single-line block. |
+| [`Callbacksystems/PreferMany`](../lib/rubocop/cop/callbacksystems/prefer_many.rb) | yes | Prefers `many?` over comparing `size` with one. |
+| [`Callbacksystems/PreferMethodOverLambda`](../lib/rubocop/cop/callbacksystems/prefer_method_over_lambda.rb) |  | Prefers a method over a lambda or proc held in a local that captures nothing from its method. |
+| [`Callbacksystems/PreferMethodOverVariable`](../lib/rubocop/cop/callbacksystems/prefer_method_over_variable.rb) |  | Prefers a method over a local variable that repeats the name it calls. |
+| [`Callbacksystems/PreferModuleForStaticClass`](../lib/rubocop/cop/callbacksystems/prefer_module_for_static_class.rb) |  | Prefers a module with `extend self` over a class holding only class-level code. |
+| [`Callbacksystems/PreferOrdinalArrayAccess`](../lib/rubocop/cop/callbacksystems/prefer_ordinal_array_access.rb) | yes | Prefers an ordinal method such as `first` over a numeric array index. |
+| [`Callbacksystems/PreferPositiveWrap`](../lib/rubocop/cop/callbacksystems/prefer_positive_wrap.rb) | yes | Prefers wrapping the happy path in `if` over a leading negative guard. |
+| [`Callbacksystems/PreferSquish`](../lib/rubocop/cop/callbacksystems/prefer_squish.rb) | yes | Prefers `squish` over stripping and collapsing whitespace by hand. |
+| [`Callbacksystems/PreferStringifyKeys`](../lib/rubocop/cop/callbacksystems/prefer_stringify_keys.rb) | yes | Prefers `stringify_keys` over `transform_keys(&:to_s)`. |
+| [`Callbacksystems/PreferSymbolizeKeys`](../lib/rubocop/cop/callbacksystems/prefer_symbolize_keys.rb) | yes | Prefers `symbolize_keys` over `transform_keys(&:to_sym)`. |
+| [`Callbacksystems/PreferTurboPageRefreshBroadcasts`](../lib/rubocop/cop/callbacksystems/prefer_turbo_page_refresh_broadcasts.rb) |  | Prefers Turbo page refreshes over targeted stream broadcasts. |
+| [`Callbacksystems/PrivateConstantsInPrivateSection`](../lib/rubocop/cop/callbacksystems/private_constants_in_private_section.rb) |  | Requires a constant that serves the implementation to live in the private section. |
+| [`Callbacksystems/PrivateDelegatePlacement`](../lib/rubocop/cop/callbacksystems/private_delegate_placement.rb) | yes | Requires a `delegate ... private: true` to sit in the private section. |
+| [`Callbacksystems/PrivateMethodsInPrivateSection`](../lib/rubocop/cop/callbacksystems/private_methods_in_private_section.rb) |  | Requires a private method to be defined in the private section, not marked afterwards. |
+| [`Callbacksystems/PrivateNestedClassMethodVisibility`](../lib/rubocop/cop/callbacksystems/private_nested_class_method_visibility.rb) |  | Requires a method in a nested class placed below `private` to be private when nothing outside calls it. |
+| [`Callbacksystems/PrivateNestedClasses`](../lib/rubocop/cop/callbacksystems/private_nested_classes.rb) |  | Requires a nested class to be declared in the private section. |
+| [`Callbacksystems/PublicMethodsMustHaveTests`](../lib/rubocop/cop/callbacksystems/public_methods_must_have_tests.rb) |  | Requires every public method to have a test. |
+| [`Callbacksystems/RedundantConcernExtend`](../lib/rubocop/cop/callbacksystems/redundant_concern_extend.rb) | yes | Flags an unnecessary `extend ActiveSupport::Concern`. |
+| [`Callbacksystems/RedundantConstantFreeze`](../lib/rubocop/cop/callbacksystems/redundant_constant_freeze.rb) | yes | Flags a `freeze` on a constant assignment. |
+| [`Callbacksystems/RedundantConstantNamespace`](../lib/rubocop/cop/callbacksystems/redundant_constant_namespace.rb) | yes | Flags a constant reference that repeats the namespace it is written inside. |
+| [`Callbacksystems/ReflowComments`](../lib/rubocop/cop/callbacksystems/reflow_comments.rb) | yes | Refills a comment block wrapped short of the maximum line length. |
+| [`Callbacksystems/RepeatedFixtureInTests`](../lib/rubocop/cop/callbacksystems/repeated_fixture_in_tests.rb) |  | Requires a fixture used by several tests to move to `setup`. |
+| [`Callbacksystems/RestrictedControllerActions`](../lib/rubocop/cop/callbacksystems/restricted_controller_actions.rb) |  | Restricts a controller to the seven standard Rails actions. |
+| [`Callbacksystems/RoutesModuleScope`](../lib/rubocop/cop/callbacksystems/routes_module_scope.rb) | yes | Requires repeated `module:` options in routes to be extracted to a scope block. |
+| [`Callbacksystems/SingleLineSetupBlock`](../lib/rubocop/cop/callbacksystems/single_line_setup_block.rb) | yes | Requires braces for a single-line `setup` or `teardown` block. |
+| [`Callbacksystems/SingleSingletonClass`](../lib/rubocop/cop/callbacksystems/single_singleton_class.rb) |  | Requires class-level methods to live in a single `class << self` section. |
+| [`Callbacksystems/SingleTopLevelClassOrModule`](../lib/rubocop/cop/callbacksystems/single_top_level_class_or_module.rb) |  | Prohibits more than one top-level class or module per file. |
+| [`Callbacksystems/SingleUseFixtureVariable`](../lib/rubocop/cop/callbacksystems/single_use_fixture_variable.rb) | yes | Requires a fixture used once to be inlined. |
+| [`Callbacksystems/SingleUseSetupVariable`](../lib/rubocop/cop/callbacksystems/single_use_setup_variable.rb) | yes | Requires a setup variable used by at most one test to be inlined. |
+| [`Callbacksystems/SingularScopeNames`](../lib/rubocop/cop/callbacksystems/singular_scope_names.rb) |  | Requires scope names to be singular unless they use a `with_` prefix. |
+| [`Callbacksystems/SpaceInsidePercentLiteral`](../lib/rubocop/cop/callbacksystems/space_inside_percent_literal.rb) | yes | Requires a space inside the delimiters of a percent literal. |
+| [`Callbacksystems/SystemTestBrowserDriver`](../lib/rubocop/cop/callbacksystems/system_test_browser_driver.rb) |  | Keeps system tests on a real browser driver. |
+| [`Callbacksystems/TestMethodDefinition`](../lib/rubocop/cop/callbacksystems/test_method_definition.rb) |  | Requires `test` and block syntax over `def test_*` and setup method definitions. |
+| [`Callbacksystems/TestMethodOrder`](../lib/rubocop/cop/callbacksystems/test_method_order.rb) | yes | Requires tests to follow the method order of the file they cover. |
+| [`Callbacksystems/TooManyInstanceVariables`](../lib/rubocop/cop/callbacksystems/too_many_instance_variables.rb) |  | Limits instance variable assignments in a private method. |
+| [`Callbacksystems/TooManyLocalVariables`](../lib/rubocop/cop/callbacksystems/too_many_local_variables.rb) |  | Limits local variable assignments in a method. |
+| [`Callbacksystems/TooManyValidationGuards`](../lib/rubocop/cop/callbacksystems/too_many_validation_guards.rb) |  | Limits the validation guards standing at the start of a method. |
+| [`Callbacksystems/UnnecessaryLocalVariable`](../lib/rubocop/cop/callbacksystems/unnecessary_local_variable.rb) | yes | Flags a local variable that aliases a method call already reading as a name. |
+| [`Callbacksystems/UnusedPrivateMethodInNestedClass`](../lib/rubocop/cop/callbacksystems/unused_private_method_in_nested_class.rb) |  | Flags an unused private method in a nested class placed below `private`. |

data/lib/rubocop/callbacksystems/autocorrection/batch.rb

@@ -0,0 +1,135 @@
+# Corrections from one cop rehearsed together. The common path parses the rewritten file once. When preserving comments
+# fails, every entry must have a safe form and their exact aggregate must pass a second rehearsal. A batch is atomic
+# because its entries may depend on each other in ways syntax and comment checks cannot see.
+class RuboCop::Callbacksystems::Autocorrection::Batch
+  BYPASS_DEPTH = :rubocop_callbacksystems_correction_batch_bypass_depth
+
+  class << self
+    # The audit reads what a correction does on its own, so a cop that declines can be told from one held back.
+    def bypassing
+      Thread.current.thread_variable_set(BYPASS_DEPTH, bypass_depth + 1)
+      yield
+    ensure
+      Thread.current.thread_variable_set(BYPASS_DEPTH, bypass_depth - 1)
+    end
+
+    def bypassed?
+      bypass_depth.positive?
+    end
+
+    private
+      def bypass_depth
+        Thread.current.thread_variable_get(BYPASS_DEPTH).to_i
+      end
+  end
+
+  def initialize(entries, processed_source)
+    @entries = entries
+    @processed_source = processed_source
+  end
+
+  def correction_for(entry)
+    corrections[entry]
+  end
+
+  private
+    attr_reader :entries, :processed_source
+
+    def corrections
+      self.class.bypassed? ? bypassed_corrections : accepted_corrections
+    end
+
+    def bypassed_corrections
+      @bypassed_corrections ||= selected_corrections
+    end
+
+    def selected_corrections
+      Selection.new(entries, processed_source).corrections
+    end
+
+    def accepted_corrections
+      @accepted_corrections ||= selected_corrections
+    end
+
+    class Selection
+      attr_reader :corrections
+
+      def initialize(entries, processed_source)
+        @entries = entries
+        @processed_source = processed_source
+        @corrections = {}.compare_by_identity
+        selected.each { |entry, correction| corrections[entry] = correction }
+      end
+
+      private
+        attr_reader :entries, :processed_source
+
+        def selected
+          if accepts?(as_written) then as_written
+          elsif rescued_corrections_accepted? then rescued
+          else []
+          end
+        end
+
+        def accepts?(candidates)
+          rehearsal = RuboCop::Callbacksystems::Autocorrection::Rehearsal.new \
+            combined_correction(candidates), processed_source
+          RuboCop::Callbacksystems::Autocorrection::Batch.bypassed? || rehearsal.empty? ||
+            (rehearsal.parses? && (rewrites_comments? || rehearsal.keeps_comments?))
+        rescue Parser::ClobberingError
+          false
+        end
+
+        def combined_correction(candidates)
+          ->(corrector) { candidates.each { it.last.call(corrector) } }
+        end
+
+        def rewrites_comments?
+          entries.all? { it.respond_to?(:rewrites_comments?) && it.rewrites_comments? }
+        end
+
+        def as_written
+          @as_written ||= entries.map { [ it, it.correction ] }
+        end
+
+        def rescued_corrections_accepted?
+          !rewrites_comments? && rescued && accepts?(rescued)
+        end
+
+        def rescued
+          @rescued ||= RehearsedCandidates.new(entries, processed_source).to_a
+        end
+
+        class RehearsedCandidates
+          def initialize(entries, processed_source)
+            @entries = entries
+            @processed_source = processed_source
+          end
+
+          def to_a
+            candidates if candidates.size == entries.size
+          end
+
+          private
+            attr_reader :entries, :processed_source
+
+            def candidates
+              @candidates ||= entries.lazy.map { candidate_for(it) }.take_while(&:last).to_a
+            end
+
+            def candidate_for(entry)
+              [ entry, preserving_comments_in(entry) ]
+            end
+
+            def preserving_comments_in(entry)
+              comment_rescue_for(entry).preserving(entry.correction)
+            end
+
+            def comment_rescue_for(entry)
+              RuboCop::Callbacksystems::Autocorrection::CommentRescue.new \
+                RuboCop::Callbacksystems::Autocorrection::Rehearsal.new(entry.correction, processed_source),
+                processed_source
+            end
+        end
+    end
+end

data/lib/rubocop/callbacksystems/autocorrection/comment_rescue.rb

@@ -0,0 +1,112 @@
+# The edits of a rehearsed correction with the comments they swallowed written back in: trailing the rewritten line they
+# were on, or standing on lines of their own where the code around them went away.
+class RuboCop::Callbacksystems::Autocorrection::CommentRescue
+  def initialize(rehearsal, processed_source)
+    @rehearsal = rehearsal
+    @processed_source = processed_source
+  end
+
+  def preserving(original_correction)
+    replacements.none?(&:rescues?) ? original_correction : correction
+  end
+
+  def correction
+    if replacements.any?(&:rescues?) && replacements.none?(&:rescues_tooling?)
+      ->(corrector) { replacements.each { corrector.replace(it.range, it.rescued_text) } }
+    end
+  end
+
+  private
+    attr_reader :rehearsal, :processed_source
+
+    def replacements
+      @replacements ||= rehearsal.as_replacements.map do |range, text|
+        Replacement.new(range, text, source_comments)
+      end
+    end
+
+    def source_comments
+      @source_comments ||= RuboCop::Callbacksystems::Source::Comments.for(processed_source)
+    end
+
+    class Replacement
+      include RuboCop::Callbacksystems::Helpers
+
+      attr_reader :range
+
+      def initialize(range, text, source_comments)
+        @range = range
+        @text = text
+        @source_comments = source_comments
+      end
+
+      def rescues?
+        comments.any?
+      end
+
+      def rescues_tooling?
+        comments.any? { tooling_comment?(it) }
+      end
+
+      def rescued_text
+        if comments.empty? then text
+        elsif text.empty? then standing_lines
+        else trailing_text
+        end
+      end
+
+      private
+        attr_reader :text, :source_comments
+
+        def comments
+          @comments ||= source_comments.within(range).reject { text.include?(it.text) }
+        end
+
+        def standing_lines
+          comments.map.with_index { |comment, index| index.zero? ? opening_line_for(comment) : own_line_for(comment) }
+            .join + closing
+        end
+
+        def opening_line_for(comment)
+          before = range.begin.source_line[0...range.begin.column]
+          if before.strip.present? then " #{comment.text}"
+          elsif range.begin.column.zero? then own_line_for(comment).delete_prefix("\n")
+          else comment.text
+          end
+        end
+
+        def own_line_for(comment)
+          "\n#{line_indentation_of(comment)}#{comment.text}"
+        end
+
+        # A comment that trailed code takes the indentation of its line, not the column it sat at.
+        def line_indentation_of(comment)
+          comment.source_range.source_line[/\A[ \t]*/]
+        end
+
+        def closing
+          after = range.end.source_line[range.end.column..]
+          after.strip.empty? ? "" : "\n#{" " * range.end.column}"
+        end
+
+        def trailing_text
+          "#{opened(text.chomp)}#{trailing_below_first}#{standing}#{"\n" if text.end_with?("\n")}"
+        end
+
+        def opened(body)
+          body.sub(/$/) { on_first_line.map { " #{it.text}" }.join }
+        end
+
+        def on_first_line
+          comments.select { it.loc.line == range.line && !own_line_comment?(it) }
+        end
+
+        def trailing_below_first
+          comments.reject { it.loc.line == range.line || own_line_comment?(it) }.map { " #{it.text}" }.join
+        end
+
+        def standing
+          comments.select { own_line_comment?(it) }.map { own_line_for(it) }.join
+        end
+    end
+end

data/lib/rubocop/callbacksystems/autocorrection/rehearsal.rb

@@ -0,0 +1,65 @@
+require "prism"
+
+# A correction run on a corrector of its own, so what it would do to the source can be read before it is offered.
+class RuboCop::Callbacksystems::Autocorrection::Rehearsal
+  delegate :empty?, :as_replacements, to: :corrector
+
+  def initialize(correction, processed_source)
+    @correction = correction
+    @processed_source = processed_source
+  end
+
+  def parses?
+    prism_parser? ? parsed_rewrite.success? : processed_rewrite.valid_syntax?
+  end
+
+  def keeps_comments?
+    comment_counts.all? { |text, count| rewritten_comment_counts.fetch(text, 0) >= count }
+  end
+
+  private
+    attr_reader :correction, :processed_source
+
+    def prism_parser?
+      processed_source.parser_engine == :parser_prism
+    end
+
+    def parsed_rewrite
+      @parsed_rewrite ||= Prism.parse \
+        rewritten,
+        filepath: processed_source.path,
+        version: processed_source.ruby_version.to_s
+    end
+
+    def rewritten
+      @rewritten ||= corrector.rewrite
+    end
+
+    def corrector
+      @corrector ||= RuboCop::Cop::Corrector.new(processed_source).tap { correction.call(it) }
+    end
+
+    def processed_rewrite
+      @processed_rewrite ||= RuboCop::ProcessedSource.new \
+        rewritten,
+        processed_source.ruby_version,
+        processed_source.path,
+        parser_engine: processed_source.parser_engine
+    end
+
+    def comment_counts
+      @comment_counts ||= processed_source.comments.map(&:text).tally
+    end
+
+    def rewritten_comment_counts
+      @rewritten_comment_counts ||= rewritten_comment_texts.tally
+    end
+
+    def rewritten_comment_texts
+      if prism_parser?
+        parsed_rewrite.comments.map { it.location.slice }
+      else
+        processed_rewrite.comments.map(&:text)
+      end
+    end
+end

data/lib/rubocop/callbacksystems/autocorrection/rewrite_permit.rb

@@ -0,0 +1,14 @@
+# The single rewrite a pass may spend. A statement carrying a body travels with everything written inside it, so a
+# second rewrite reaching into that same text would clobber it, and the pass that follows takes the next one.
+class RuboCop::Callbacksystems::Autocorrection::RewritePermit
+  def initialize(granted: true)
+    @granted = granted
+  end
+
+  def claim
+    granted.tap { @granted = false }
+  end
+
+  private
+    attr_reader :granted
+end

data/lib/rubocop/callbacksystems/class_structure/builder_assignment.rb

@@ -0,0 +1,48 @@
+# A constant assignment whose expression uses one of Ruby's root class or module builders.
+class RuboCop::Callbacksystems::ClassStructure::BuilderAssignment
+  include RuboCop::Callbacksystems::Helpers
+
+  CLASS_BUILDERS = { Data: :define, Struct: :new, Class: :new }
+  MODULE_BUILDERS = { Module: :new }
+
+  def initialize(node)
+    @node = node
+  end
+
+  def builds_class_with_body?
+    builds_class? && block_with_body?
+  end
+
+  def builds_class?
+    builds?(CLASS_BUILDERS)
+  end
+
+  def builds_module_with_body?
+    builds_module? && block_with_body?
+  end
+
+  def builds_module?
+    builds?(MODULE_BUILDERS)
+  end
+
+  private
+    attr_reader :node
+
+    def builds?(builders)
+      builder_named_in?(builders)
+    end
+
+    def builder_named_in?(builders)
+      builder_call&.receiver.then do |receiver|
+        core_constant?(receiver) && builders[receiver.short_name] == builder_call.method_name
+      end
+    end
+
+    def builder_call
+      @builder_call ||= call_of(node.expression) if node&.casgn_type?
+    end
+
+    def block_with_body?
+      any_block_type?(node.expression) && node.expression.body.present?
+    end
+end

data/lib/rubocop/callbacksystems/class_structure/class_body.rb

@@ -0,0 +1,50 @@
+class RuboCop::Callbacksystems::ClassStructure::ClassBody
+  include RuboCop::Callbacksystems::Helpers
+
+  def initialize(body)
+    @body = body
+  end
+
+  def public_method_nodes
+    public_children.select(&:def_type?)
+  end
+
+  def public_children
+    each_child_with_visibility.filter_map { |child, level| child if level == :public }
+  end
+
+  def each_child_with_visibility
+    if block_given?
+      visibility.each_statement { |child, level| yield child, level }
+    else
+      visibility.each_statement
+    end
+  end
+
+  def private_method_nodes
+    private_children.select(&:def_type?)
+  end
+
+  def private_nested_classes
+    private_children.select(&:class_type?)
+  end
+
+  def in_private_section?(node)
+    visibility.level_at(node) == :private
+  end
+
+  def private_modifier
+    statements_in(body).find { visibility_modifier_of(it) == :private }
+  end
+
+  private
+    attr_reader :body
+
+    def visibility
+      @visibility ||= RuboCop::Callbacksystems::ClassStructure::Visibility.for(body)
+    end
+
+    def private_children
+      each_child_with_visibility.filter_map { |child, level| child if level == :private }
+    end
+end

data/lib/rubocop/callbacksystems/class_structure/divergence.rb

@@ -0,0 +1,31 @@
+# The first place a sequence of names departs from the order expected of it, read as the index, the name the order
+# expects there and the name found instead.
+class RuboCop::Callbacksystems::ClassStructure::Divergence
+  def initialize(names, from:)
+    @names = names
+    @order = from
+  end
+
+  def found?
+    index.present?
+  end
+
+  def index
+    @index ||= names.each_index.find { names[it] != order[it] } if comparable?
+  end
+
+  def expected
+    order[index]
+  end
+
+  def actual
+    names[index]
+  end
+
+  private
+    attr_reader :names, :order
+
+    def comparable?
+      names.size == order.size && names.tally == order.tally
+    end
+end

data/lib/rubocop/callbacksystems/class_structure/node_visibility.rb

@@ -0,0 +1,82 @@
+class RuboCop::Callbacksystems::ClassStructure::NodeVisibility
+  include RuboCop::Callbacksystems::Helpers
+
+  def initialize(node)
+    @node = node
+  end
+
+  def public?
+    level == :public
+  end
+
+  def level
+    level_of_wrapping_modifier || explicitly_assigned_level || default_level
+  end
+
+  def enclosing_body
+    visibility_owner&.body&.then { it if it.type?(:begin, :kwbegin) }
+  end
+
+  def enclosing_definition
+    node.each_ancestor(:class, :module, :sclass).first
+  end
+
+  def level_in(body)
+    RuboCop::Callbacksystems::ClassStructure::Visibility.for(body).level_at(node)
+  end
+
+  def private?
+    level == :private
+  end
+
+  def protected?
+    level == :protected
+  end
+
+  def private_non_predicate?
+    level != :public && !node.predicate_method?
+  end
+
+  private
+    attr_reader :node
+
+    def level_of_wrapping_modifier
+      visibility_applied_to(node.parent, node)
+    end
+
+    def explicitly_assigned_level
+      assignment_bodies.filter_map do |body|
+        RuboCop::Callbacksystems::ClassStructure::Visibility.for(body).assignment_after \
+          node, singleton: node.defs_type? || body.equal?(singleton_owner_body)
+      end.max_by(&:position)&.level
+    end
+
+    def assignment_bodies
+      [ enclosing_body, singleton_owner_body ].compact.uniq(&:object_id)
+    end
+
+    def singleton_owner_body
+      singleton_class&.each_ancestor&.find { visibility_owner?(it) }&.body
+    end
+
+    def singleton_class
+      @singleton_class ||= visibility_owner if visibility_owner&.sclass_type? &&
+        visibility_owner.children.first.self_type?
+    end
+
+    def visibility_owner
+      @visibility_owner ||= node.each_ancestor.find { visibility_owner?(it) }
+    end
+
+    def visibility_owner?(candidate)
+      candidate.type?(:class, :module, :sclass) || any_block_type?(candidate)
+    end
+
+    def default_level
+      if !node.defs_type? && enclosing_body
+        level_in(enclosing_body)
+      else
+        :public
+      end
+    end
+end