rubocop 0.89.1 → 0.93.0

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)
+        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

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

@@ -20,8 +20,9 @@ module RuboCop
       #     b,
       #     c
       #   ]
-      class MultilineArrayLineBreaks < Cop
+      class MultilineArrayLineBreaks < Base
         include MultilineElementLineBreaks
+        extend AutoCorrector
 
         MSG = 'Each item in a multi-line array must start ' \
           'on a separate line.'
@@ -29,10 +30,6 @@ module RuboCop
         def on_array(node)
           check_line_breaks(node, node.children)
         end
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
       end
     end
   end

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

@@ -31,10 +31,11 @@ module RuboCop
       #   foo = if expression
       #     'bar'
       #   end
-      class MultilineAssignmentLayout < Cop
+      class MultilineAssignmentLayout < Base
         include CheckAssignment
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         NEW_LINE_OFFENSE = 'Right hand side of multi-line assignment is on ' \
           'the same line as the assignment operator `=`.'
@@ -63,24 +64,19 @@ module RuboCop
         def check_new_line_offense(node, rhs)
           return unless node.loc.operator.line == rhs.first_line
 
-          add_offense(node, message: NEW_LINE_OFFENSE)
+          add_offense(node, message: NEW_LINE_OFFENSE) do |corrector|
+            corrector.insert_after(node.loc.operator, "\n")
+          end
         end
 
         def check_same_line_offense(node, rhs)
           return unless node.loc.operator.line != rhs.first_line
 
-          add_offense(node, message: SAME_LINE_OFFENSE)
-        end
-
-        def autocorrect(node)
-          case style
-          when :new_line
-            ->(corrector) { corrector.insert_after(node.loc.operator, "\n") }
-          when :same_line
-            range = range_between(node.loc.operator.end_pos,
-                                  extract_rhs(node).source_range.begin_pos)
-
-            ->(corrector) { corrector.replace(range, ' ') }
+          add_offense(node, message: SAME_LINE_OFFENSE) do |corrector|
+            range = range_between(
+              node.loc.operator.end_pos, extract_rhs(node).source_range.begin_pos
+            )
+            corrector.replace(range, ' ')
           end
         end
 

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)
@@ -116,7 +100,25 @@ module RuboCop
         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[0...-1] + last_arg.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,10 @@ module RuboCop
       #   rescue
       #     puts 'error'
       #   end
-      class RescueEnsureAlignment < Cop
+      class RescueEnsureAlignment < Base
         include RangeHelp
+        include EndKeywordAlignment
+        extend AutoCorrector
 
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
               'aligned with `%<beginning>s` at ' \
@@ -41,19 +43,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?
@@ -70,18 +60,26 @@ module RuboCop
           alignment_node = alignment_node(node)
           return if alignment_node.nil?
 
-          alignment_loc = alignment_node.loc.expression
+          alignment_loc = alignment_location(alignment_node)
           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_loc)
+          end
+        end
+
+        def autocorrect(corrector, node, alignment_location)
+          whitespace = whitespace_range(node)
+          # Some inline node is sitting before current node.
+          return nil unless whitespace.source.strip.empty?
+
+          new_column = alignment_location.column
+
+          corrector.replace(whitespace, ' ' * new_column)
         end
 
         def format_message(alignment_node, alignment_loc, kw_loc)
@@ -183,6 +181,27 @@ module RuboCop
 
           false
         end
+
+        def alignment_location(alignment_node)
+          if begin_end_alignment_style == 'start_of_line'
+            start_line_range(alignment_node)
+          else
+            alignment_node.loc.expression
+          end
+        end
+
+        def begin_end_alignment_style
+          # FIXME: Workaround for pending status for `Layout/BeginEndAlignment` cop
+          #        When RuboCop 1.0 is released, please replace it with the following condition.
+          #
+          # config.for_cop('Layout/BeginEndAlignment')['Enabled'] &&
+          #   config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
+          if config.for_all_cops['NewCops'] == 'enable' ||
+             config.for_cop('Layout/BeginEndAlignment')['Enabled'] &&
+             config.for_cop('Layout/BeginEndAlignment')['Enabled'] != 'pending'
+            config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
+          end
+        end
       end
     end
   end

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