rubocop 0.89.0 → 0.92.0

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

@@ -20,30 +20,30 @@ module RuboCop
       #   class Person
       #     # Some code
       #   end
-      class EmptyLineAfterMagicComment < Cop
+      class EmptyLineAfterMagicComment < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Add an empty line after magic comments.'
 
-        def investigate(source)
-          return unless source.ast &&
-                        (last_magic_comment = last_magic_comment(source))
-          return if source[last_magic_comment.loc.line].strip.empty?
+        def on_new_investigation
+          return unless processed_source.ast &&
+                        (last_magic_comment = last_magic_comment(processed_source))
+          return if processed_source[last_magic_comment.loc.line].strip.empty?
 
-          offending_range =
-            source_range(source.buffer, last_magic_comment.loc.line + 1, 0)
+          offending_range = offending_range(last_magic_comment)
 
-          add_offense(offending_range, location: offending_range)
-        end
-
-        def autocorrect(token)
-          lambda do |corrector|
-            corrector.insert_before(token, "\n")
+          add_offense(offending_range) do |corrector|
+            corrector.insert_before(offending_range, "\n")
           end
         end
 
         private
 
+        def offending_range(last_magic_comment)
+          source_range(processed_source.buffer, last_magic_comment.loc.line + 1, 0)
+        end
+
         # Find the last magic comment in the source file.
         #
         # Take all comments that precede the first line of code, select the

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop enforces empty line after multiline condition.
+      #
+      # @example
+      #   # bad
+      #   if multiline &&
+      #     condition
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if multiline &&
+      #     condition
+      #
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   case x
+      #   when foo,
+      #     bar
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   case x
+      #   when foo,
+      #     bar
+      #
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue FooError,
+      #     BarError
+      #     handle_error
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue FooError,
+      #     BarError
+      #
+      #     handle_error
+      #   end
+      #
+      class EmptyLineAfterMultilineCondition < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use empty line after multiline condition.'
+
+        def on_if(node)
+          return if node.ternary?
+
+          if node.modifier_form?
+            check_condition(node.condition) if node.right_sibling
+          else
+            check_condition(node.condition)
+          end
+        end
+
+        def on_while(node)
+          check_condition(node.condition)
+        end
+        alias on_until on_while
+
+        def on_while_post(node)
+          return unless node.right_sibling
+
+          check_condition(node.condition)
+        end
+        alias on_until_post on_while_post
+
+        def on_case(node)
+          node.each_when do |when_node|
+            last_condition = when_node.conditions.last
+
+            next if !multiline_when_condition?(when_node) ||
+                    next_line_empty?(last_condition.last_line)
+
+            add_offense(when_node, &autocorrect(last_condition))
+          end
+        end
+
+        def on_rescue(node)
+          node.resbody_branches.each do |resbody|
+            rescued_exceptions = resbody.exceptions
+            next if !multiline_rescue_exceptions?(rescued_exceptions) ||
+                    next_line_empty?(rescued_exceptions.last.last_line)
+
+            add_offense(resbody, &autocorrect(rescued_exceptions.last))
+          end
+        end
+
+        private
+
+        def check_condition(condition)
+          return unless condition.multiline?
+          return if next_line_empty?(condition.last_line)
+
+          add_offense(condition, &autocorrect(condition))
+        end
+
+        def next_line_empty?(line)
+          processed_source[line].blank?
+        end
+
+        def multiline_when_condition?(when_node)
+          when_node.conditions.first.first_line != when_node.conditions.last.last_line
+        end
+
+        def multiline_rescue_exceptions?(exception_nodes)
+          return false if exception_nodes.size <= 1
+
+          first, *_rest, last = *exception_nodes
+          first.first_line != last.last_line
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_by_whole_lines(node.source_range)
+            corrector.insert_after(range, "\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -29,8 +29,9 @@ module RuboCop
       #
       #   def b
       #   end
-      class EmptyLineBetweenDefs < Cop
+      class EmptyLineBetweenDefs < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use empty lines between method definitions.'
 
@@ -57,23 +58,26 @@ module RuboCop
                     cop_config['AllowAdjacentOneLineDefs']
 
           location = nodes.last.loc.keyword.join(nodes.last.loc.name)
-          add_offense(nodes.last, location: location)
+          add_offense(location) do |corrector|
+            autocorrect(corrector, *nodes)
+          end
         end
 
-        def autocorrect(node)
-          prev_def = prev_node(node)
-
+        def autocorrect(corrector, prev_def, node)
           # finds position of first newline
           end_pos = prev_def.loc.end.end_pos
           source_buffer = prev_def.loc.end.source_buffer
           newline_pos = source_buffer.source.index("\n", end_pos)
 
+          # Handle the case when multiple one-liners are on the same line.
+          newline_pos = end_pos + 1 if newline_pos > node.source_range.begin_pos
+
           count = blank_lines_count_between(prev_def, node)
 
           if count > maximum_empty_lines
-            autocorrect_remove_lines(newline_pos, count)
+            autocorrect_remove_lines(corrector, newline_pos, count)
           else
-            autocorrect_insert_lines(newline_pos, count)
+            autocorrect_insert_lines(corrector, newline_pos, count)
           end
         end
 
@@ -111,16 +115,12 @@ module RuboCop
           Array(cop_config['NumberOfEmptyLines']).last
         end
 
-        def prev_node(node)
-          return nil unless node.sibling_index.positive?
-
-          node.parent.children[node.sibling_index - 1]
-        end
-
         def lines_between_defs(first_def_node, second_def_node)
-          line_range = def_end(first_def_node)..(def_start(second_def_node) - 2)
+          begin_line_num = def_end(first_def_node)
+          end_line_num = def_start(second_def_node) - 2
+          return [] if end_line_num.negative?
 
-          processed_source.lines[line_range]
+          processed_source.lines[begin_line_num..end_line_num]
         end
 
         def def_start(node)
@@ -131,20 +131,18 @@ module RuboCop
           node.loc.end.line
         end
 
-        def autocorrect_remove_lines(newline_pos, count)
+        def autocorrect_remove_lines(corrector, newline_pos, count)
           difference = count - maximum_empty_lines
           range_to_remove = range_between(newline_pos, newline_pos + difference)
-          lambda do |corrector|
-            corrector.remove(range_to_remove)
-          end
+
+          corrector.remove(range_to_remove)
         end
 
-        def autocorrect_insert_lines(newline_pos, count)
+        def autocorrect_insert_lines(corrector, newline_pos, count)
           difference = minimum_empty_lines - count
           where_to_insert = range_between(newline_pos, newline_pos + 1)
-          lambda do |corrector|
-            corrector.insert_after(where_to_insert, "\n" * difference)
-          end
+
+          corrector.insert_after(where_to_insert, "\n" * difference)
         end
       end
     end

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

@@ -18,13 +18,14 @@ module RuboCop
       #   # one empty line
       #   some_method
       #
-      class EmptyLines < Cop
+      class EmptyLines < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Extra blank line detected.'
         LINE_OFFSET = 2
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.tokens.empty?
 
           lines = Set.new
@@ -33,14 +34,12 @@ module RuboCop
           end
 
           each_extra_empty_line(lines.sort) do |range|
-            add_offense(range, location: range)
+            add_offense(range) do |corrector|
+              corrector.remove(range)
+            end
           end
         end
 
-        def autocorrect(range)
-          ->(corrector) { corrector.remove(range) }
-        end
-
         private
 
         def each_extra_empty_line(lines)

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

@@ -40,9 +40,10 @@ module RuboCop
       #     def baz; end
       #   end
       #
-      class EmptyLinesAroundAccessModifier < Cop
+      class EmptyLinesAroundAccessModifier < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG_AFTER = 'Keep a blank line after `%<modifier>s`.'
         MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after ' \
@@ -83,20 +84,10 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.bare_access_modifier?
+          return unless register_offense?(node)
 
-          case style
-          when :around
-            return if empty_lines_around?(node)
-          when :only_before
-            return if allowed_only_before_style?(node)
-          end
-
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          message = message(node)
+          add_offense(node, message: message) do |corrector|
             line = range_by_whole_lines(node.source_range)
 
             corrector.insert_before(line, "\n") unless previous_line_empty?(node.first_line)
@@ -107,6 +98,19 @@ module RuboCop
 
         private
 
+        def register_offense?(node)
+          return false unless node.bare_access_modifier? && !node.parent.block_type?
+
+          case style
+          when :around
+            return false if empty_lines_around?(node)
+          when :only_before
+            return false if allowed_only_before_style?(node)
+          end
+
+          true
+        end
+
         def allowed_only_before_style?(node)
           if node.special_modifier?
             return true if processed_source[node.last_line] == 'end'

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

@@ -38,23 +38,22 @@ module RuboCop
       #     x: y
       #   )
       #
-      class EmptyLinesAroundArguments < Cop
+      class EmptyLinesAroundArguments < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Empty line detected around arguments.'
 
         def on_send(node)
           return if node.single_line? || node.arguments.empty?
 
-          extra_lines(node) { |range| add_offense(node, location: range) }
-        end
-        alias on_csend on_send
-
-        def autocorrect(node)
-          lambda do |corrector|
-            extra_lines(node) { |range| corrector.remove(range) }
+          extra_lines(node) do |range|
+            add_offense(range) do |corrector|
+              corrector.remove(range)
+            end
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -60,9 +60,10 @@ module RuboCop
       #   def do_something
       #   end
       #
-      class EmptyLinesAroundAttributeAccessor < Cop
+      class EmptyLinesAroundAttributeAccessor < Base
         include RangeHelp
         include AllowedMethods
+        extend AutoCorrector
 
         MSG = 'Add an empty line after attribute accessor.'
 
@@ -73,11 +74,7 @@ module RuboCop
           next_line_node = next_line_node(node)
           return unless require_empty_line?(next_line_node)
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             range = range_by_whole_lines(node.source_range)
 
             corrector.insert_after(range, "\n")
@@ -99,7 +96,7 @@ module RuboCop
         def next_line_node(node)
           return if node.parent.if_type?
 
-          node.parent.children[node.sibling_index + 1]
+          node.right_sibling
         end
 
         def allow_alias?(node)

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

@@ -21,8 +21,9 @@ module RuboCop
       #     # ...
       #
       #   end
-      class EmptyLinesAroundBeginBody < Cop
+      class EmptyLinesAroundBeginBody < Base
         include EmptyLinesAroundBody
+        extend AutoCorrector
 
         KIND = '`begin`'
 
@@ -30,10 +31,6 @@ module RuboCop
           check(node, nil)
         end
 
-        def autocorrect(node)
-          EmptyLineCorrector.correct(node)
-        end
-
         private
 
         def style