rubocop 0.89.1 → 0.93.0

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

@@ -58,8 +58,9 @@ module RuboCop
       #
       #     do_something2
       #   end
-      class EmptyLinesAroundExceptionHandlingKeywords < Cop
+      class EmptyLinesAroundExceptionHandlingKeywords < Base
         include EmptyLinesAroundBody
+        extend AutoCorrector
 
         MSG = 'Extra empty line detected %<location>s the `%<keyword>s`.'
 
@@ -73,10 +74,6 @@ module RuboCop
           check_body(body)
         end
 
-        def autocorrect(node)
-          EmptyLineCorrector.correct(node)
-        end
-
         private
 
         def check_body(node)
@@ -116,10 +113,9 @@ module RuboCop
         end
 
         def keyword_locations_in_rescue(node)
-          _begin_body, *resbodies, _else_body = *node
           [
             node.loc.else,
-            *resbodies.map { |body| body.loc.keyword }
+            *node.resbody_branches.map { |body| body.loc.keyword }
           ].compact
         end
 

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

@@ -20,8 +20,9 @@ module RuboCop
       #     # ...
       #
       #   end
-      class EmptyLinesAroundMethodBody < Cop
+      class EmptyLinesAroundMethodBody < Base
         include EmptyLinesAroundBody
+        extend AutoCorrector
 
         KIND = 'method'
 
@@ -30,10 +31,6 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          EmptyLineCorrector.correct(node)
-        end
-
         private
 
         def style

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

@@ -44,18 +44,15 @@ module RuboCop
       #       # ...
       #     end
       #   end
-      class EmptyLinesAroundModuleBody < Cop
+      class EmptyLinesAroundModuleBody < Base
         include EmptyLinesAroundBody
+        extend AutoCorrector
 
         KIND = 'module'
 
         def on_module(node)
           check(node, node.body)
         end
-
-        def autocorrect(node)
-          EmptyLineCorrector.correct(node)
-        end
       end
     end
   end

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

@@ -17,6 +17,11 @@ module RuboCop
       # If it's set to `start_of_line`, the `end` shall be aligned with the
       # start of the line where the matching keyword appears.
       #
+      # This `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
+      # by default. On the other hand, `Layout/BeginEndAlignment` cop aligns with
+      # `EnforcedStyleAlignWith: start_of_line` by default due to `||= begin` tends
+      # to align with the start of the line. These style can be configured by each cop.
+      #
       # @example EnforcedStyleAlignWith: keyword (default)
       #   # bad
       #
@@ -67,10 +72,11 @@ module RuboCop
       #   variable =
       #     if true
       #     end
-      class EndAlignment < Cop
+      class EndAlignment < Base
         include CheckAssignment
         include EndKeywordAlignment
         include RangeHelp
+        extend AutoCorrector
 
         def on_class(node)
           check_other_alignment(node)
@@ -100,14 +106,12 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          AlignmentCorrector.align_end(processed_source,
-                                       node,
-                                       alignment_node(node))
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.align_end(corrector, processed_source, node, alignment_node(node))
+        end
+
         def check_assignment(node, rhs)
           # If there are method calls chained to the right hand side of the
           # assignment, we let rhs be the receiver of those method calls before
@@ -174,16 +178,6 @@ module RuboCop
             node
           end
         end
-
-        def start_line_range(node)
-          expr   = node.source_range
-          buffer = expr.source_buffer
-          source = buffer.source_line(expr.line)
-          range  = buffer.line_range(expr.line)
-
-          range_between(range.begin_pos + (source =~ /\S/),
-                        range.begin_pos + (source =~ /\s*\z/))
-        end
       end
     end
   end

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

@@ -17,8 +17,9 @@ module RuboCop
       #       :a,
       #       :b]
       #
-      class FirstArrayElementLineBreak < Cop
+      class FirstArrayElementLineBreak < Base
         include FirstElementLineBreak
+        extend AutoCorrector
 
         MSG = 'Add a line break before the first element of a ' \
               'multi-line array.'
@@ -29,10 +30,6 @@ module RuboCop
           check_children_line_break(node, node.children)
         end
 
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
-
         private
 
         def assignment_on_same_line?(node)

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

@@ -16,8 +16,9 @@ module RuboCop
       #     {
       #       a: 1,
       #       b: 2 }
-      class FirstHashElementLineBreak < Cop
+      class FirstHashElementLineBreak < Base
         include FirstElementLineBreak
+        extend AutoCorrector
 
         MSG = 'Add a line break before the first element of a ' \
               'multi-line hash.'
@@ -27,10 +28,6 @@ module RuboCop
           # If it doesn't, Style/FirstMethodArgumentLineBreak will handle it
           check_children_line_break(node, node.children) if node.loc.begin
         end
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
       end
     end
   end

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

@@ -20,8 +20,9 @@ module RuboCop
       #     # ignored
       #     method foo, bar,
       #       baz
-      class FirstMethodArgumentLineBreak < Cop
+      class FirstMethodArgumentLineBreak < Base
         include FirstElementLineBreak
+        extend AutoCorrector
 
         MSG = 'Add a line break before the first argument of a ' \
               'multi-line method argument list.'
@@ -35,18 +36,13 @@ module RuboCop
           #
           # ...then each key/value pair is treated as a method 'argument'
           # when determining where line breaks should appear.
-          if (last_arg = args.last)
-            args = args.concat(args.pop.children) if last_arg.hash_type? && !last_arg.braces?
-          end
+          last_arg = args.last
+          args.concat(args.pop.children) if last_arg&.hash_type? && !last_arg&.braces?
 
           check_method_line_break(node, args)
         end
         alias on_csend on_send
         alias on_super on_send
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
       end
     end
   end

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

@@ -26,8 +26,9 @@ module RuboCop
       #         bar
       #       do_something
       #     end
-      class FirstMethodParameterLineBreak < Cop
+      class FirstMethodParameterLineBreak < Base
         include FirstElementLineBreak
+        extend AutoCorrector
 
         MSG = 'Add a line break before the first parameter of a ' \
               'multi-line method parameter list.'
@@ -36,10 +37,6 @@ module RuboCop
           check_method_line_break(node, node.arguments)
         end
         alias on_defs on_def
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
       end
     end
   end

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

@@ -175,9 +175,10 @@ module RuboCop
       #   do_something({foo: 1,
       #     bar: 2})
       #
-      class HashAlignment < Cop
+      class HashAlignment < Base
         include HashAlignmentStyles
         include RangeHelp
+        extend AutoCorrector
 
         MESSAGES = { KeyAlignment => 'Align the keys of a hash literal if ' \
                       'they span more than one line.',
@@ -212,13 +213,6 @@ module RuboCop
           check_pairs(node)
         end
 
-        def autocorrect(node)
-          delta = column_deltas[alignment_for(node).first.class][node]
-          return if delta.nil?
-
-          correct_node(node, delta)
-        end
-
         attr_accessor :offences_by, :column_deltas
 
         private
@@ -254,7 +248,11 @@ module RuboCop
         def add_offences
           format, offences = offences_by.min_by { |_, v| v.length }
           (offences || []).each do |offence|
-            add_offense(offence, message: MESSAGES[format])
+            add_offense(offence, message: MESSAGES[format]) do |corrector|
+              delta = column_deltas[alignment_for(offence).first.class][offence]
+
+              correct_node(corrector, offence, delta) unless delta.nil?
+            end
           end
         end
 
@@ -293,25 +291,26 @@ module RuboCop
             new_alignment('EnforcedColonStyle')
         end
 
-        def correct_node(node, delta)
+        def correct_node(corrector, node, delta)
           # We can't use the instance variable inside the lambda. That would
           # just give each lambda the same reference and they would all get the
           # last value of each. A local variable fixes the problem.
 
           if !node.value
-            correct_no_value(delta[:key] || 0, node.source_range)
+            delta_value = delta[:key] || 0
+            correct_no_value(corrector, delta_value, node.source_range)
           else
-            correct_key_value(delta, node.key.source_range,
+            correct_key_value(corrector, delta, node.key.source_range,
                               node.value.source_range,
                               node.loc.operator)
           end
         end
 
-        def correct_no_value(key_delta, key)
-          ->(corrector) { adjust(corrector, key_delta, key) }
+        def correct_no_value(corrector, key_delta, key)
+          adjust(corrector, key_delta, key)
         end
 
-        def correct_key_value(delta, key, value, separator)
+        def correct_key_value(corrector, delta, key, value, separator)
           # We can't use the instance variable inside the lambda. That would
           # just give each lambda the same reference and they would all get the
           # last value of each. Some local variables fix the problem.
@@ -322,11 +321,9 @@ module RuboCop
           key_column = key.column
           key_delta = -key_column if key_delta < -key_column
 
-          lambda do |corrector|
-            adjust(corrector, key_delta, key)
-            adjust(corrector, separator_delta, separator)
-            adjust(corrector, value_delta, value)
-          end
+          adjust(corrector, key_delta, key)
+          adjust(corrector, separator_delta, separator)
+          adjust(corrector, value_delta, value)
         end
 
         def new_alignment(key)

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

@@ -50,12 +50,17 @@ module RuboCop
       #        123,
       #      )
       #
-      class HeredocArgumentClosingParenthesis < Cop
+      class HeredocArgumentClosingParenthesis < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Put the closing parenthesis for a method call with a ' \
         'HEREDOC parameter on the same line as the HEREDOC opening.'
 
+        def self.autocorrect_incompatible_with
+          [Style::TrailingCommaInArguments]
+        end
+
         def on_send(node)
           heredoc_arg = extract_heredoc_argument(node)
           return unless heredoc_arg
@@ -65,9 +70,13 @@ module RuboCop
           return unless outermost_send.loc.end
           return unless heredoc_arg.first_line != outermost_send.loc.end.line
 
-          add_offense(outermost_send, location: :end)
+          add_offense(outermost_send.loc.end) do |corrector|
+            autocorrect(corrector, outermost_send)
+          end
         end
 
+        private
+
         # Autocorrection note:
         #
         # Commas are a bit tricky to handle when the method call is
@@ -94,22 +103,14 @@ module RuboCop
         #   SQL
         #   third_array_value,
         # ]
-        def autocorrect(node)
-          lambda do |corrector|
-            fix_closing_parenthesis(node, corrector)
+        def autocorrect(corrector, node)
+          fix_closing_parenthesis(node, corrector)
 
-            remove_internal_trailing_comma(node, corrector) if internal_trailing_comma?(node)
+          remove_internal_trailing_comma(node, corrector) if internal_trailing_comma?(node)
 
-            fix_external_trailing_comma(node, corrector) if external_trailing_comma?(node)
-          end
+          fix_external_trailing_comma(node, corrector) if external_trailing_comma?(node)
         end
 
-        def self.autocorrect_incompatible_with
-          [Style::TrailingCommaInArguments]
-        end
-
-        private
-
         def outermost_send_on_same_line(heredoc)
           previous = heredoc
           current = previous.parent

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

@@ -21,9 +21,9 @@ module RuboCop
       #     something
       #   RUBY
       #
-      #
-      class HeredocIndentation < Cop
+      class HeredocIndentation < Base
         include Heredoc
+        extend AutoCorrector
 
         TYPE_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
                    'heredoc by using `<<~` instead of `%<current_indent_type>s`.'
@@ -34,8 +34,9 @@ module RuboCop
           return if body.strip.empty?
 
           body_indent_level = indent_level(body)
+          heredoc_indent_type = heredoc_indent_type(node)
 
-          if heredoc_indent_type(node) == '~'
+          if heredoc_indent_type == '~'
             expected_indent_level = base_indent_level(node) + indentation_width
             return if expected_indent_level == body_indent_level
           else
@@ -44,12 +45,16 @@ module RuboCop
 
           return if line_too_long?(node)
 
-          add_offense(node, location: :heredoc_body)
+          register_offense(node, heredoc_indent_type)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if heredoc_indent_type(node) == '~'
+        private
+
+        def register_offense(node, heredoc_indent_type)
+          message = message(heredoc_indent_type)
+
+          add_offense(node.loc.heredoc_body, message: message) do |corrector|
+            if heredoc_indent_type == '~'
               adjust_squiggly(corrector, node)
             else
               adjust_minus(corrector, node)
@@ -57,10 +62,8 @@ module RuboCop
           end
         end
 
-        private
-
-        def message(node)
-          current_indent_type = "<<#{heredoc_indent_type(node)}"
+        def message(heredoc_indent_type)
+          current_indent_type = "<<#{heredoc_indent_type}"
 
           if current_indent_type == '<<~'
             width_message(indentation_width)

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

@@ -17,21 +17,20 @@ module RuboCop
       #     def foo; end
       #   end
       #
-      class InitialIndentation < Cop
+      class InitialIndentation < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Indentation of first line in file detected.'
 
-        def investigate(_processed_source)
+        def on_new_investigation
           space_before(first_token) do |space|
-            add_offense(space, location: first_token.pos)
+            add_offense(first_token.pos) do |corrector|
+              corrector.remove(space)
+            end
           end
         end
 
-        def autocorrect(range)
-          ->(corrector) { corrector.remove(range) }
-        end
-
         private
 
         def first_token