rubocop 0.87.0 → 0.90.0

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

@@ -48,8 +48,9 @@ module RuboCop
       #     foo(i)
       #     bar(i)
       #   }
-      class MultilineBlockLayout < Cop
+      class MultilineBlockLayout < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Block body expression is on the same line as ' \
               'the block start.'
@@ -70,23 +71,6 @@ module RuboCop
           add_offense_for_expression(node, node.body, MSG)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            unless args_on_beginning_line?(node)
-              autocorrect_arguments(corrector, node)
-              expr_before_body = node.arguments.source_range.end
-            end
-
-            return unless node.body
-
-            expr_before_body ||= node.loc.begin
-
-            if expr_before_body.line == node.body.first_line
-              autocorrect_body(corrector, node, node.body)
-            end
-          end
-        end
-
         private
 
         def args_on_beginning_line?(node)
@@ -95,17 +79,46 @@ module RuboCop
         end
 
         def line_break_necessary_in_args?(node)
-          needed_length = node.source_range.column +
-                          node.source.lines.first.length +
-                          block_arg_string(node, node.arguments).length +
-                          PIPE_SIZE
-          needed_length > max_line_length
+          needed_length_for_args(node) > max_line_length
+        end
+
+        def needed_length_for_args(node)
+          node.source_range.column +
+            characters_needed_for_space_and_pipes(node) +
+            node.source.lines.first.chomp.length +
+            block_arg_string(node, node.arguments).length
+        end
+
+        def characters_needed_for_space_and_pipes(node)
+          if node.source.lines.first.end_with?("|\n")
+            PIPE_SIZE
+          else
+            1 + PIPE_SIZE * 2
+          end
         end
 
         def add_offense_for_expression(node, expr, msg)
           expression = expr.source_range
           range = range_between(expression.begin_pos, expression.end_pos)
-          add_offense(node, location: range, message: msg)
+
+          add_offense(range, message: msg) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          unless args_on_beginning_line?(node)
+            autocorrect_arguments(corrector, node)
+            expr_before_body = node.arguments.source_range.end
+          end
+
+          return unless node.body
+
+          expr_before_body ||= node.loc.begin
+
+          return unless expr_before_body.line == node.body.first_line
+
+          autocorrect_body(corrector, node, node.body)
         end
 
         def autocorrect_arguments(corrector, node)

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

@@ -88,8 +88,9 @@ module RuboCop
       #     # good
       #     { a: 1,
       #       b: 2 }
-      class MultilineHashBraceLayout < Cop
+      class MultilineHashBraceLayout < Base
         include MultilineLiteralBraceLayout
+        extend AutoCorrector
 
         SAME_LINE_MESSAGE = 'Closing hash brace must be on the same line as ' \
           'the last hash element when opening brace is on the same line as ' \
@@ -108,10 +109,6 @@ module RuboCop
         def on_hash(node)
           check_brace_layout(node)
         end
-
-        def autocorrect(node)
-          MultilineLiteralBraceCorrector.new(node, processed_source)
-        end
       end
     end
   end

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

@@ -20,8 +20,9 @@ module RuboCop
       #     b: 2,
       #     c: 3
       #   }
-      class MultilineHashKeyLineBreaks < Cop
+      class MultilineHashKeyLineBreaks < Base
         include MultilineElementLineBreaks
+        extend AutoCorrector
 
         MSG = 'Each key in a multi-line hash must start on a ' \
           'separate line.'
@@ -35,10 +36,6 @@ module RuboCop
           check_line_breaks(node, node.children) if node.loc.begin
         end
 
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
-
         private
 
         def starts_with_curly_brace?(node)

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

@@ -19,8 +19,9 @@ module RuboCop
       #     b,
       #     c
       #   )
-      class MultilineMethodArgumentLineBreaks < Cop
-        include(MultilineElementLineBreaks)
+      class MultilineMethodArgumentLineBreaks < Base
+        include MultilineElementLineBreaks
+        extend AutoCorrector
 
         MSG = 'Each argument in a multi-line method call must start ' \
           'on a separate line.'
@@ -36,16 +37,11 @@ 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 = args[0...-1] + last_arg.children if last_arg&.hash_type? && !last_arg&.braces?
 
           check_line_breaks(node, args)
         end
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
       end
     end
   end

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

@@ -88,8 +88,9 @@ module RuboCop
       #   # good
       #   foo(a,
       #     b)
-      class MultilineMethodCallBraceLayout < Cop
+      class MultilineMethodCallBraceLayout < Base
         include MultilineLiteralBraceLayout
+        extend AutoCorrector
 
         SAME_LINE_MESSAGE = 'Closing method call brace must be on the ' \
           'same line as the last argument when opening brace is on the same ' \
@@ -109,10 +110,6 @@ module RuboCop
           check_brace_layout(node)
         end
 
-        def autocorrect(node)
-          MultilineLiteralBraceCorrector.new(node, processed_source)
-        end
-
         private
 
         def children(node)

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

@@ -100,8 +100,9 @@ module RuboCop
       #   def foo(a,
       #     b)
       #   end
-      class MultilineMethodDefinitionBraceLayout < Cop
+      class MultilineMethodDefinitionBraceLayout < Base
         include MultilineLiteralBraceLayout
+        extend AutoCorrector
 
         SAME_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
           'same line as the last parameter when opening brace is on the same ' \
@@ -121,10 +122,6 @@ module RuboCop
           check_brace_layout(node.arguments)
         end
         alias on_defs on_def
-
-        def autocorrect(node)
-          MultilineLiteralBraceCorrector.new(node, processed_source)
-        end
       end
     end
   end

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

@@ -21,8 +21,9 @@ module RuboCop
       #   rescue
       #     puts 'error'
       #   end
-      class RescueEnsureAlignment < Cop
+      class RescueEnsureAlignment < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
               'aligned with `%<beginning>s` at ' \
@@ -41,19 +42,7 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          whitespace = whitespace_range(node)
-          # Some inline node is sitting before current node.
-          return nil unless whitespace.source.strip.empty?
-
-          alignment_node = alignment_node(node)
-          return false if alignment_node.nil?
-
-          new_column = alignment_node.loc.column
-          ->(corrector) { corrector.replace(whitespace, ' ' * new_column) }
-        end
-
-        def investigate(processed_source)
+        def on_new_investigation
           @modifier_locations =
             processed_source.tokens.each_with_object([]) do |token, locations|
               next unless token.rescue_modifier?
@@ -73,15 +62,23 @@ module RuboCop
           alignment_loc = alignment_node.loc.expression
           kw_loc        = node.loc.keyword
 
-          return if
-            alignment_loc.column == kw_loc.column ||
-            alignment_loc.line   == kw_loc.line
+          return if alignment_loc.column == kw_loc.column || alignment_loc.line == kw_loc.line
 
           add_offense(
-            node,
-            location: kw_loc,
-            message: format_message(alignment_node, alignment_loc, kw_loc)
-          )
+            kw_loc, message: format_message(alignment_node, alignment_loc, kw_loc)
+          ) do |corrector|
+            autocorrect(corrector, node, alignment_node)
+          end
+        end
+
+        def autocorrect(corrector, node, alignment_node)
+          whitespace = whitespace_range(node)
+          # Some inline node is sitting before current node.
+          return nil unless whitespace.source.strip.empty?
+
+          new_column = alignment_node.loc.column
+
+          corrector.replace(whitespace, ' ' * new_column)
         end
 
         def format_message(alignment_node, alignment_loc, kw_loc)
@@ -96,7 +93,6 @@ module RuboCop
           )
         end
 
-        # rubocop:disable Metrics/AbcSize
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
@@ -115,7 +111,6 @@ module RuboCop
 
           range_between(starting_loc.begin_pos, ending_loc.end_pos).source
         end
-        # rubocop:enable Metrics/AbcSize
 
         # We will use ancestor or wrapper with access modifier.
 

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

@@ -13,7 +13,9 @@ module RuboCop
       #
       #   # good
       #   def f(a:, b: 2); {a: 3}; end
-      class SpaceAfterColon < Cop
+      class SpaceAfterColon < Base
+        extend AutoCorrector
+
         MSG = 'Space missing after colon.'
 
         def on_pair(node)
@@ -21,7 +23,7 @@ module RuboCop
 
           colon = node.loc.operator
 
-          add_offense(colon, location: colon) unless followed_by_space?(colon)
+          register_offense(colon) unless followed_by_space?(colon)
         end
 
         def on_kwoptarg(node)
@@ -29,15 +31,17 @@ module RuboCop
           # optional keyword argument's name, so must construct one.
           colon = node.loc.name.end.resize(1)
 
-          add_offense(colon, location: colon) unless followed_by_space?(colon)
-        end
-
-        def autocorrect(range)
-          ->(corrector) { corrector.insert_after(range, ' ') }
+          register_offense(colon) unless followed_by_space?(colon)
         end
 
         private
 
+        def register_offense(colon)
+          add_offense(colon) do |corrector|
+            corrector.insert_after(colon, ' ')
+          end
+        end
+
         def followed_by_space?(colon)
           /\s/.match?(colon.source_buffer.source[colon.end_pos])
         end

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

@@ -14,12 +14,9 @@ module RuboCop
       #   # good
       #   [1, 2]
       #   { foo:bar, }
-      class SpaceAfterComma < Cop
+      class SpaceAfterComma < Base
         include SpaceAfterPunctuation
-
-        def autocorrect(comma)
-          PunctuationCorrector.add_space(comma)
-        end
+        extend AutoCorrector
 
         def space_style_before_rcurly
           cfg = config.for_cop('Layout/SpaceInsideHashLiteralBraces')

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

@@ -14,8 +14,9 @@ module RuboCop
       #   # good
       #   def func(x) end
       #   def method=(y) end
-      class SpaceAfterMethodName < Cop
+      class SpaceAfterMethodName < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not put a space between a method name and the opening ' \
               'parenthesis.'
@@ -29,13 +30,11 @@ module RuboCop
                                                 expr.begin_pos)
           return unless pos_before_left_paren.source.start_with?(' ')
 
-          add_offense(pos_before_left_paren, location: pos_before_left_paren)
+          add_offense(pos_before_left_paren) do |corrector|
+            corrector.remove(pos_before_left_paren)
+          end
         end
         alias on_defs on_def
-
-        def autocorrect(pos_before_left_paren)
-          ->(corrector) { corrector.remove(pos_before_left_paren) }
-        end
       end
     end
   end

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

@@ -11,29 +11,27 @@ module RuboCop
       #
       #   # good
       #   !something
-      class SpaceAfterNot < Cop
+      class SpaceAfterNot < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not leave space between `!` and its argument.'
 
         def on_send(node)
           return unless node.prefix_bang? && whitespace_after_operator?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            corrector.remove(
+              range_between(node.loc.selector.end_pos, node.receiver.source_range.begin_pos)
+            )
+          end
         end
 
+        private
+
         def whitespace_after_operator?(node)
           node.receiver.loc.column - node.loc.column > 1
         end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(
-              range_between(node.loc.selector.end_pos,
-                            node.receiver.source_range.begin_pos)
-            )
-          end
-        end
       end
     end
   end

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

@@ -11,12 +11,9 @@ module RuboCop
       #
       #   # good
       #   x = 1; y = 2
-      class SpaceAfterSemicolon < Cop
+      class SpaceAfterSemicolon < Base
         include SpaceAfterPunctuation
-
-        def autocorrect(semicolon)
-          PunctuationCorrector.add_space(semicolon)
-        end
+        extend AutoCorrector
 
         def space_style_before_rcurly
           cfg = config.for_cop('Layout/SpaceInsideBlockBraces')

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

@@ -56,11 +56,12 @@ module RuboCop
         def check_inside_pipes(arguments)
           opening_pipe, closing_pipe = pipes(arguments)
 
-          if style == :no_space
+          case style
+          when :no_space
             check_no_space_style_inside_pipes(arguments.children,
                                               opening_pipe,
                                               closing_pipe)
-          elsif style == :space
+          when :space
             check_space_style_inside_pipes(arguments.children,
                                            opening_pipe,
                                            closing_pipe)

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

@@ -27,10 +27,11 @@ module RuboCop
       #   def some_method(arg1=:default, arg2=nil, arg3=[])
       #     # do something...
       #   end
-      class SpaceAroundEqualsInParameterDefault < Cop
+      class SpaceAroundEqualsInParameterDefault < Base
         include SurroundingSpace
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Surrounding space %<type>s in default value assignment.'
 
@@ -40,13 +41,6 @@ module RuboCop
           check_optarg(arg, equals, value)
         end
 
-        def autocorrect(range)
-          m = range.source.match(/=\s*(\S+)/)
-          rest = m ? m.captures[0] : ''
-          replacement = style == :space ? ' = ' : '='
-          ->(corrector) { corrector.replace(range, replacement + rest) }
-        end
-
         private
 
         def check_optarg(arg, equals, value)
@@ -65,14 +59,25 @@ module RuboCop
         def incorrect_style_detected(arg, value, space_on_both_sides,
                                      no_surrounding_space)
           range = range_between(arg.end_pos, value.begin_pos)
-          add_offense(range, location: range) do
-            if style == :space && no_surrounding_space ||
-               style == :no_space && space_on_both_sides
-              opposite_style_detected
-            else
-              unrecognized_style_detected
-            end
+
+          if style == :space && no_surrounding_space ||
+             style == :no_space && space_on_both_sides
+            return unless opposite_style_detected
+          else
+            return unless unrecognized_style_detected
           end
+
+          add_offense(range) do |corrector|
+            autocorrect(corrector, range)
+          end
+        end
+
+        def autocorrect(corrector, range)
+          m = range.source.match(/=\s*(\S+)/)
+          rest = m ? m.captures[0] : ''
+          replacement = style == :space ? ' = ' : '='
+
+          corrector.replace(range, replacement + rest)
         end
 
         def space_on_both_sides?(arg, equals)