rubocop 1.9.0 → 1.12.1

data/lib/rubocop/cop/internal_affairs/offense_location_keyword.rb

@@ -34,10 +34,12 @@ module RuboCop
 
         private
 
+        # @!method node_type_check(node)
         def_node_matcher :node_type_check, <<~PATTERN
           (send nil? :add_offense $_node $hash)
         PATTERN
 
+        # @!method offending_location_argument(node)
         def_node_matcher :offending_location_argument, <<~PATTERN
           (pair (sym :location) $(send (send $_node :loc) $_keyword))
         PATTERN

data/lib/rubocop/cop/internal_affairs/redundant_described_class_as_subject.rb

@@ -21,6 +21,7 @@ module RuboCop
 
         MSG = 'Remove the redundant `subject`%<additional_message>s.'
 
+        # @!method described_class_subject?(node)
         def_node_matcher :described_class_subject?, <<~PATTERN
           (block
             (send nil? :subject

data/lib/rubocop/cop/internal_affairs/redundant_let_rubocop_config_new.rb

@@ -25,6 +25,7 @@ module RuboCop
 
         MSG = 'Remove `let` that is `RuboCop::Config.new` with no arguments%<additional_message>s.'
 
+        # @!method let_rubocop_config_new?(node)
         def_node_matcher :let_rubocop_config_new?, <<~PATTERN
           (block
             (send nil? :let

data/lib/rubocop/cop/internal_affairs/redundant_location_argument.rb

@@ -23,6 +23,7 @@ module RuboCop
         MSG = 'Redundant location argument to `#add_offense`.'
         RESTRICT_ON_SEND = %i[add_offense].freeze
 
+        # @!method redundant_location_argument(node)
         def_node_matcher :redundant_location_argument, <<~PATTERN
           (send nil? :add_offense _
             (hash <$(pair (sym :location) (sym :expression)) ...>)

data/lib/rubocop/cop/internal_affairs/redundant_message_argument.rb

@@ -26,16 +26,19 @@ module RuboCop
         MSG = 'Redundant message argument to `#add_offense`.'
         RESTRICT_ON_SEND = %i[add_offense].freeze
 
+        # @!method node_type_check(node)
         def_node_matcher :node_type_check, <<~PATTERN
           (send nil? :add_offense $_node $hash)
         PATTERN
 
+        # @!method redundant_message_argument(node)
         def_node_matcher :redundant_message_argument, <<~PATTERN
           (pair
             (sym :message)
             ${(const nil? :MSG) (send nil? :message) (send nil? :message _)})
         PATTERN
 
+        # @!method message_method_call(node)
         def_node_matcher :message_method_call, '(send nil? :message $_node)'
 
         def on_send(node)

data/lib/rubocop/cop/internal_affairs/style_detected_api_use.rb

@@ -67,18 +67,22 @@ module RuboCop
           no_acceptable_style! style_detected
         ].freeze
 
+        # @!method correct_style_detected_check(node)
         def_node_matcher :correct_style_detected_check, <<~PATTERN
           (send nil? :correct_style_detected)
         PATTERN
 
+        # @!method negative_style_detected_method_check(node)
         def_node_matcher :negative_style_detected_method_check, <<~PATTERN
           (send nil? /(?:opposite|unexpected|ambiguous|unrecognized)_style_detected|conflicting_styles_detected/ ...)
         PATTERN
 
+        # @!method no_acceptable_style_check(node)
         def_node_matcher :no_acceptable_style_check, <<~PATTERN
           (send nil? :no_acceptable_style!)
         PATTERN
 
+        # @!method style_detected_check(node)
         def_node_matcher :style_detected_check, <<~PATTERN
           (send nil? :style_detected ...)
         PATTERN

data/lib/rubocop/cop/internal_affairs/useless_message_assertion.rb

@@ -16,10 +16,12 @@ module RuboCop
       class UselessMessageAssertion < Base
         MSG = 'Do not specify cop behavior using `described_class::MSG`.'
 
+        # @!method described_class_msg(node)
         def_node_search :described_class_msg, <<~PATTERN
           (const (send nil? :described_class) :MSG)
         PATTERN
 
+        # @!method rspec_expectation_on_msg?(node)
         def_node_matcher :rspec_expectation_on_msg?, <<~PATTERN
           (send (send nil? :expect #contains_described_class_msg?) :to ...)
         PATTERN

data/lib/rubocop/cop/layout/access_modifier_indentation.rb

@@ -32,10 +32,11 @@ module RuboCop
       #   private
       #     def smooth; end
       #   end
-      class AccessModifierIndentation < Cop
+      class AccessModifierIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = '%<style>s access modifiers like `%<node>s`.'
 
@@ -48,12 +49,12 @@ module RuboCop
         alias on_module on_class
         alias on_block  on_class
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, @column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
         def check_body(body, node)
           modifiers = body.each_child_node(:send)
                           .select(&:bare_access_modifier?)
@@ -69,18 +70,20 @@ module RuboCop
           if @column_delta.zero?
             correct_style_detected
           else
-            add_offense(send_node) do
+            add_offense(send_node) do |corrector|
               if offset == unexpected_indent_offset
                 opposite_style_detected
               else
                 unrecognized_style_detected
               end
+
+              autocorrect(corrector, send_node)
             end
           end
         end
 
-        def message(node)
-          format(MSG, style: style.capitalize, node: node.loc.selector.source)
+        def message(range)
+          format(MSG, style: style.capitalize, node: range.source)
         end
 
         def expected_indent_offset

data/lib/rubocop/cop/layout/argument_alignment.rb

@@ -37,8 +37,9 @@ module RuboCop
       #
       #   foo :bar,
       #       :baz
-      class ArgumentAlignment < Cop
+      class ArgumentAlignment < Base
         include Alignment
+        extend AutoCorrector
 
         ALIGN_PARAMS_MSG = 'Align the arguments of a method call if ' \
           'they span more than one line.'
@@ -54,12 +55,12 @@ module RuboCop
         end
         alias on_csend on_send
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
         def message(_node)
           fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
         end

data/lib/rubocop/cop/layout/array_alignment.rb

@@ -33,8 +33,9 @@ module RuboCop
       #
       #   array = [1, 2, 3,
       #            4, 5, 6]
-      class ArrayAlignment < Cop
+      class ArrayAlignment < Base
         include Alignment
+        extend AutoCorrector
 
         ALIGN_ELEMENTS_MSG = 'Align the elements of an array literal ' \
           'if they span more than one line.'
@@ -49,13 +50,13 @@ module RuboCop
           check_alignment(node.children, base_column(node, node.children))
         end
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
-        end
-
         private
 
-        def message(_node)
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
+        def message(_range)
           fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_ELEMENTS_MSG
         end
 

data/lib/rubocop/cop/layout/assignment_indentation.rb

@@ -21,13 +21,16 @@ module RuboCop
       #
       # The indentation of the remaining lines can be corrected with
       # other cops such as `IndentationConsistency` and `EndAlignment`.
-      class AssignmentIndentation < Cop
+      class AssignmentIndentation < Base
         include CheckAssignment
         include Alignment
+        extend AutoCorrector
 
         MSG = 'Indent the first line of the right-hand-side of a ' \
               'multi-line assignment.'
 
+        private
+
         def check_assignment(node, rhs)
           return unless rhs
           return unless node.loc.operator
@@ -37,8 +40,8 @@ module RuboCop
           check_alignment([rhs], base + configured_indentation_width)
         end
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
         end
 
         def leftmost_multiple_assignment(node)

data/lib/rubocop/cop/layout/block_alignment.rb

@@ -68,6 +68,7 @@ module RuboCop
 
         MSG = '%<current>s is not aligned with %<prefer>s%<alt_prefer>s.'
 
+        # @!method block_end_align_target?(node, child)
         def_node_matcher :block_end_align_target?, <<~PATTERN
           {assignment?
            splat

data/lib/rubocop/cop/layout/block_end_newline.rb

@@ -24,8 +24,9 @@ module RuboCop
       #   blah { |i|
       #     foo(i)
       #   }
-      class BlockEndNewline < Cop
+      class BlockEndNewline < Base
         include Alignment
+        extend AutoCorrector
 
         MSG = 'Expression at %<line>d, %<column>d should be on its own line.'
 
@@ -35,13 +36,8 @@ module RuboCop
           # If the end is on its own line, there is no offense
           return if begins_its_line?(node.loc.end)
 
-          add_offense(node, location: :end)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(delimiter_range(node),
-                              "\n#{node.loc.end.source}#{offset(node)}")
+          add_offense(node.loc.end, message: message(node)) do |corrector|
+            corrector.replace(delimiter_range(node), "\n#{node.loc.end.source}#{offset(node)}")
           end
         end
 

data/lib/rubocop/cop/layout/class_structure.rb

@@ -147,6 +147,7 @@ module RuboCop
         MSG = '`%<category>s` is supposed to appear before ' \
               '`%<previous>s`.'
 
+        # @!method dynamic_constant?(node)
         def_node_matcher :dynamic_constant?, <<~PATTERN
           (casgn nil? _ (send ...))
         PATTERN

data/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb

@@ -68,8 +68,9 @@ module RuboCop
       #   )
       #
       #
-      class ClosingParenthesisIndentation < Cop
+      class ClosingParenthesisIndentation < Base
         include Alignment
+        extend AutoCorrector
 
         MSG_INDENT = 'Indent `)` to column %<expected>d (not %<actual>d)'
 
@@ -89,12 +90,12 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, @column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
         def check(node, elements)
           if elements.empty?
             check_for_no_elements(node)
@@ -115,11 +116,10 @@ module RuboCop
 
           return if @column_delta.zero?
 
-          add_offense(right_paren,
-                      location: right_paren,
-                      message:  message(correct_column,
-                                        left_paren,
-                                        right_paren))
+          message = message(correct_column, left_paren, right_paren)
+          add_offense(right_paren, message: message) do |corrector|
+            autocorrect(corrector, right_paren)
+          end
         end
 
         def check_for_no_elements(node)
@@ -135,11 +135,10 @@ module RuboCop
           # select the first one of candidates to determine a specification.
           correct_column = candidates.first
           @column_delta = correct_column - right_paren.column
-          add_offense(right_paren,
-                      location: right_paren,
-                      message:  message(correct_column,
-                                        left_paren,
-                                        right_paren))
+          message = message(correct_column, left_paren, right_paren)
+          add_offense(right_paren, message: message) do |corrector|
+            autocorrect(corrector, right_paren)
+          end
         end
 
         def expected_column(left_paren, elements)

data/lib/rubocop/cop/layout/comment_indentation.rb

@@ -32,29 +32,30 @@ module RuboCop
       #     true
       #   end
       #
-      class CommentIndentation < Cop
+      class CommentIndentation < Base
         include Alignment
+        extend AutoCorrector
 
         MSG = 'Incorrect indentation detected (column %<column>d ' \
           'instead of %<correct_comment_indentation>d).'
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.comments.each { |comment| check(comment) }
         end
 
-        def autocorrect(comment)
-          corrections = autocorrect_preceding_comments(comment) <<
-                        autocorrect_one(comment)
-          ->(corrector) { corrections.each { |corr| corr.call(corrector) } }
-        end
-
         private
 
+        def autocorrect(corrector, comment)
+          autocorrect_preceding_comments(corrector, comment)
+
+          autocorrect_one(corrector, comment)
+        end
+
         # Corrects all comment lines that occur immediately before the given
         # comment and have the same indentation. This is to avoid a long chain
         # of correcting, saving the file, parsing and inspecting again, and
         # then correcting one more line, and so on.
-        def autocorrect_preceding_comments(comment)
+        def autocorrect_preceding_comments(corrector, comment)
           comments = processed_source.comments
           index = comments.index(comment)
 
@@ -62,7 +63,7 @@ module RuboCop
             .reverse_each
             .each_cons(2)
             .take_while { |below, above| should_correct?(above, below) }
-            .map { |_, above| autocorrect_one(above) }
+            .map { |_, above| autocorrect_one(corrector, above) }
         end
 
         def should_correct?(preceding_comment, reference_comment)
@@ -71,8 +72,8 @@ module RuboCop
           loc.line == ref_loc.line - 1 && loc.column == ref_loc.column
         end
 
-        def autocorrect_one(comment)
-          AlignmentCorrector.correct(processed_source, comment, @column_delta)
+        def autocorrect_one(corrector, comment)
+          AlignmentCorrector.correct(corrector, processed_source, comment, @column_delta)
         end
 
         def check(comment)
@@ -93,10 +94,9 @@ module RuboCop
             return if column == correct_comment_indentation
           end
 
-          add_offense(
-            comment,
-            message: message(column, correct_comment_indentation)
-          )
+          add_offense(comment, message: message(column, correct_comment_indentation)) do |corrector|
+            autocorrect(corrector, comment)
+          end
         end
 
         def message(column, correct_comment_indentation)

data/lib/rubocop/cop/layout/else_alignment.rb

@@ -29,10 +29,11 @@ module RuboCop
       #   else
       #     code
       #   end
-      class ElseAlignment < Cop
+      class ElseAlignment < Base
         include EndKeywordAlignment
         include Alignment
         include CheckAssignment
+        extend AutoCorrector
 
         MSG = 'Align `%<else_range>s` with `%<base_range>s`.'
 
@@ -67,12 +68,12 @@ module RuboCop
           )
         end
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
         def check_nested(node, base)
           on_if(node, base)
           ignore_node(node)
@@ -140,7 +141,9 @@ module RuboCop
             else_range: else_range.source,
             base_range: base_range.source[/^\S*/]
           )
-          add_offense(else_range, location: else_range, message: message)
+          add_offense(else_range, message: message) do |corrector|
+            autocorrect(corrector, else_range)
+          end
         end
 
         def assignment_node(node)