rubocop 0.87.1 → 0.91.0

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,14 +20,15 @@ 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.'
 
         def on_send(node)
-          args = node.arguments
+          args = node.arguments.dup
 
           # If there is a trailing hash arg without explicit braces, like this:
           #
@@ -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)
@@ -161,11 +164,11 @@ module RuboCop
         end
 
         def heredoc_body(node)
-          node.loc.heredoc_body.source.scrub
+          node.loc.heredoc_body.source
         end
 
         def heredoc_end(node)
-          node.loc.heredoc_end.source.scrub
+          node.loc.heredoc_end.source
         end
       end
     end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Layout

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

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

@@ -49,31 +49,33 @@ module RuboCop
       #   #ruby=2.7.0
       #   #ruby-gemset=myproject
       #
-      class LeadingCommentSpace < Cop
+      class LeadingCommentSpace < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Missing space after `#`.'
 
-        def investigate(processed_source)
-          processed_source.each_comment do |comment|
+        def on_new_investigation
+          processed_source.comments.each do |comment|
             next unless /\A#+[^#\s=:+-]/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
             next if doxygen_comment_style?(comment)
             next if gemfile_ruby_comment?(comment)
 
-            add_offense(comment)
+            add_offense(comment) do |corrector|
+              expr = comment.loc.expression
+
+              corrector.insert_after(hash_mark(expr), ' ')
+            end
           end
         end
 
-        def autocorrect(comment)
-          expr = comment.loc.expression
-          hash_mark = range_between(expr.begin_pos, expr.begin_pos + 1)
+        private
 
-          ->(corrector) { corrector.insert_after(hash_mark, ' ') }
+        def hash_mark(expr)
+          range_between(expr.begin_pos, expr.begin_pos + 1)
         end
 
-        private
-
         def allowed_on_first_line?(comment)
           shebang?(comment) || rackup_config_file? && rackup_options?(comment)
         end

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

@@ -27,23 +27,18 @@ module RuboCop
       #   # good
       #   # (start of file)
       #   # a comment
-      class LeadingEmptyLines < Cop
+      class LeadingEmptyLines < Base
+        extend AutoCorrector
+
         MSG = 'Unnecessary blank line at the beginning of the source.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           token = processed_source.tokens[0]
           return unless token && token.line > 1
 
-          add_offense(processed_source.tokens[0],
-                      location: processed_source.tokens[0].pos)
-        end
-
-        def autocorrect(node)
-          range = Parser::Source::Range.new(processed_source.buffer,
-                                            0,
-                                            node.begin_pos)
+          add_offense(token.pos) do |corrector|
+            range = Parser::Source::Range.new(processed_source.buffer, 0, token.begin_pos)
 
-          lambda do |corrector|
             corrector.remove(range)
           end
         end

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

@@ -88,8 +88,9 @@ module RuboCop
       #     # good
       #     [ :a,
       #       :b ]
-      class MultilineArrayBraceLayout < Cop
+      class MultilineArrayBraceLayout < Base
         include MultilineLiteralBraceLayout
+        extend AutoCorrector
 
         SAME_LINE_MESSAGE = 'The closing array brace must be on the same ' \
           'line as the last array element when the opening brace is on the ' \
@@ -108,10 +109,6 @@ module RuboCop
         def on_array(node)
           check_brace_layout(node)
         end
-
-        def autocorrect(node)
-          MultilineLiteralBraceCorrector.new(node, processed_source)
-        end
       end
     end
   end