rubocop 1.11.0 → 1.12.0

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_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/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)

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

@@ -144,10 +144,11 @@ module RuboCop
       #     nested_first_param),
       #   second_param
       #
-      class FirstArgumentIndentation < Cop
+      class FirstArgumentIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Indent the first argument one step more than %<base>s.'
 
@@ -161,12 +162,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 bare_operator?(node)
           node.operator_method? && !node.dot?
         end

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

@@ -79,10 +79,11 @@ module RuboCop
       #   and_now_for_something = [
       #                             :completely_different
       #                           ]
-      class FirstArrayElementIndentation < Cop
+      class FirstArrayElementIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include MultilineElementIndentation
+        extend AutoCorrector
 
         MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
               'in an array, relative to %<base_description>s.'
@@ -98,12 +99,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 brace_alignment_style
           :align_brackets
         end
@@ -132,7 +133,9 @@ module RuboCop
           return if @column_delta.zero?
 
           msg = msg(left_parenthesis)
-          add_offense(right_bracket, location: right_bracket, message: msg)
+          add_offense(right_bracket, message: msg) do |corrector|
+            autocorrect(corrector, right_bracket)
+          end
         end
 
         # Returns the description of what the correct indentation is based on.

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

@@ -77,10 +77,11 @@ module RuboCop
       #   and_now_for_something = {
       #                             completely: :different
       #                           }
-      class FirstHashElementIndentation < Cop
+      class FirstHashElementIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include MultilineElementIndentation
+        extend AutoCorrector
 
         MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
               'in a hash, relative to %<base_description>s.'
@@ -96,12 +97,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 brace_alignment_style
           :align_braces
         end
@@ -134,16 +135,10 @@ module RuboCop
           @column_delta = expected_column - right_brace.column
           return if @column_delta.zero?
 
-          msg = if style == :align_braces
-                  'Indent the right brace the same as the left brace.'
-                elsif style == :special_inside_parentheses && left_parenthesis
-                  'Indent the right brace the same as the first position ' \
-                  'after the preceding left parenthesis.'
-                else
-                  'Indent the right brace the same as the start of the line ' \
-                  'where the left brace is.'
-                end
-          add_offense(right_brace, location: right_brace, message: msg)
+          message = message_for_right_brace(left_parenthesis)
+          add_offense(right_brace, message: message) do |corrector|
+            autocorrect(corrector, right_brace)
+          end
         end
 
         def separator_style?(first_pair)
@@ -178,6 +173,18 @@ module RuboCop
             base_description: base_description
           )
         end
+
+        def message_for_right_brace(left_parenthesis)
+          if style == :align_braces
+            'Indent the right brace the same as the left brace.'
+          elsif style == :special_inside_parentheses && left_parenthesis
+            'Indent the right brace the same as the first position ' \
+            'after the preceding left parenthesis.'
+          else
+            'Indent the right brace the same as the start of the line ' \
+            'where the left brace is.'
+          end
+        end
       end
     end
   end

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

@@ -41,10 +41,11 @@ module RuboCop
       #   second_param)
       #     123
       #   end
-      class FirstParameterIndentation < Cop
+      class FirstParameterIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include MultilineElementIndentation
+        extend AutoCorrector
 
         MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
              'in method args, relative to %<base_description>s.'
@@ -57,12 +58,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 brace_alignment_style
           :align_parentheses
         end

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

@@ -118,9 +118,10 @@ module RuboCop
       #       def bar
       #       end
       #   end
-      class IndentationConsistency < Cop
+      class IndentationConsistency < Base
         include Alignment
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Inconsistent indentation detected.'
 
@@ -132,12 +133,12 @@ module RuboCop
           check(node)
         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
+
         # Not all nodes define `bare_access_modifier?` (for example,
         # `RuboCop::AST::DefNode` does not), so we must check `send_type?` first
         # to avoid a NoMethodError.
@@ -161,8 +162,10 @@ module RuboCop
           # to the level of the module (see `AccessModifierIndentation` cop) we
           # return nil so that `check_alignment` will derive the correct
           # indentation from the first child that is not an access modifier.
-          module_indent = display_column(node.parent.source_range)
           access_modifier_indent = display_column(first_child.source_range)
+          return access_modifier_indent unless node.parent
+
+          module_indent = display_column(node.parent.source_range)
           access_modifier_indent if access_modifier_indent > module_indent
         end
 

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

@@ -31,60 +31,57 @@ module RuboCop
       #   def foo
       #     bar
       #   end
-      class IndentationStyle < Cop
+      class IndentationStyle < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = '%<type>s detected in indentation.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           str_ranges = string_literal_ranges(processed_source.ast)
 
           processed_source.lines.each.with_index(1) do |line, lineno|
-            match = find_offence(line)
-            next unless match
-
-            range = source_range(processed_source.buffer,
-                                 lineno,
-                                 match.begin(0)...match.end(0))
+            next unless (range = find_offence(line, lineno))
             next if in_string_literal?(str_ranges, range)
 
-            add_offense(range, location: range)
+            add_offense(range) do |corrector|
+              autocorrect(corrector, range)
+            end
           end
         end
 
-        def autocorrect(range)
+        private
+
+        def autocorrect(corrector, range)
           if range.source.include?("\t")
-            autocorrect_lambda_for_tabs(range)
+            autocorrect_lambda_for_tabs(corrector, range)
           else
-            autocorrect_lambda_for_spaces(range)
+            autocorrect_lambda_for_spaces(corrector, range)
           end
         end
 
-        private
+        def find_offence(line, lineno)
+          match = if style == :spaces
+                    line.match(/\A\s*\t+/)
+                  else
+                    line.match(/\A\s* +/)
+                  end
+          return unless match
 
-        def find_offence(line)
-          if style == :spaces
-            line.match(/\A\s*\t+/)
-          else
-            line.match(/\A\s* +/)
-          end
+          source_range(processed_source.buffer, lineno, match.begin(0)...match.end(0))
         end
 
-        def autocorrect_lambda_for_tabs(range)
-          lambda do |corrector|
-            spaces = ' ' * configured_indentation_width
-            corrector.replace(range, range.source.gsub(/\t/, spaces))
-          end
+        def autocorrect_lambda_for_tabs(corrector, range)
+          spaces = ' ' * configured_indentation_width
+          corrector.replace(range, range.source.gsub(/\t/, spaces))
         end
 
-        def autocorrect_lambda_for_spaces(range)
-          lambda do |corrector|
-            corrector.replace(range, range.source.gsub(/\A\s+/) do |match|
-              "\t" * (match.size / configured_indentation_width)
-            end)
-          end
+        def autocorrect_lambda_for_spaces(corrector, range)
+          corrector.replace(range, range.source.gsub(/\A\s+/) do |match|
+            "\t" * (match.size / configured_indentation_width)
+          end)
         end
 
         def in_string_literal?(ranges, tabs_range)