rubocop 0.52.1 → 0.93.1

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

@@ -6,12 +6,12 @@ module RuboCop
       # This cop checks whether method definitions are
       # separated by one empty line.
       #
-      # `NumberOfEmptyLines` can be and integer (e.g. 1 by default) or
-      # an array (e.g. [1, 2]) to specificy a minimum and a maximum of
-      # empty lines.
+      # `NumberOfEmptyLines` can be an integer (default is 1) or
+      # an array (e.g. [1, 2]) to specify a minimum and maximum
+      # number of empty lines permitted.
       #
-      # `AllowAdjacentOneLineDefs` can be used to configure is adjacent
-      # one line methods definitions are an offense
+      # `AllowAdjacentOneLineDefs` configures whether adjacent
+      # one-line method definitions are considered an offense.
       #
       # @example
       #
@@ -29,8 +29,11 @@ module RuboCop
       #
       #   def b
       #   end
-      class EmptyLineBetweenDefs < Cop
-        MSG = 'Use empty lines between method definitions.'.freeze
+      class EmptyLineBetweenDefs < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use empty lines between method definitions.'
 
         def self.autocorrect_incompatible_with
           [Layout::EmptyLines]
@@ -54,23 +57,27 @@ module RuboCop
           return if nodes.all?(&:single_line?) &&
                     cop_config['AllowAdjacentOneLineDefs']
 
-          add_offense(nodes.last, location: :keyword)
+          location = nodes.last.loc.keyword.join(nodes.last.loc.name)
+          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
 
@@ -78,6 +85,7 @@ module RuboCop
 
         def def_node?(node)
           return unless node
+
           node.def_type? || node.defs_type?
         end
 
@@ -86,6 +94,7 @@ module RuboCop
           blank_start = lines.each_index.select { |i| lines[i].blank? }.max
           non_blank_end = lines.each_index.reject { |i| lines[i].blank? }.min
           return false if blank_start.nil? || non_blank_end.nil?
+
           blank_start > non_blank_end
         end
 
@@ -106,16 +115,12 @@ module RuboCop
           Array(cop_config['NumberOfEmptyLines']).last
         end
 
-        def prev_node(node)
-          return nil unless node.sibling_index > 0
-
-          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)
@@ -126,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

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Layout
-      # This cops checks for two or more consecutive blank lines.
+      # This cop checks for two or more consecutive blank lines.
       #
       # @example
       #
@@ -20,27 +18,28 @@ module RuboCop
       #   # one empty line
       #   some_method
       #
-      class EmptyLines < Cop
-        MSG = 'Extra blank line detected.'.freeze
+      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
-          processed_source.tokens.each do |token|
+          processed_source.each_token do |token|
             lines << token.line
           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

@@ -5,7 +5,7 @@ module RuboCop
     module Layout
       # Access modifiers should be surrounded by blank lines.
       #
-      # @example
+      # @example EnforcedStyle: around (default)
       #
       #   # bad
       #   class Foo
@@ -22,83 +22,191 @@ module RuboCop
       #
       #     def baz; end
       #   end
-      class EmptyLinesAroundAccessModifier < Cop
-        MSG_AFTER = 'Keep a blank line after `%s`.'.freeze
-        MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after `%<node>s`.'
-                               .freeze
+      #
+      # @example EnforcedStyle: only_before
+      #
+      #   # bad
+      #   class Foo
+      #     def bar; end
+      #     private
+      #     def baz; end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def bar; end
+      #
+      #     private
+      #     def baz; end
+      #   end
+      #
+      class EmptyLinesAroundAccessModifier < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
 
-        def on_send(node)
-          return unless node.access_modifier?
+        MSG_AFTER = 'Keep a blank line after `%<modifier>s`.'
+        MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after ' \
+                               '`%<modifier>s`.'
+
+        MSG_BEFORE_FOR_ONLY_BEFORE = 'Keep a blank line before `%<modifier>s`.'
+        MSG_AFTER_FOR_ONLY_BEFORE = 'Remove a blank line after `%<modifier>s`.'
+
+        def initialize(config = nil, options = nil)
+          super
+
+          @block_line = nil
+        end
+
+        def on_class(node)
+          @class_or_module_def_first_line = if node.parent_class
+                                              node.parent_class.first_line
+                                            else
+                                              node.source_range.first_line
+                                            end
+          @class_or_module_def_last_line = node.source_range.last_line
+        end
+
+        def on_module(node)
+          @class_or_module_def_first_line = node.source_range.first_line
+          @class_or_module_def_last_line = node.source_range.last_line
+        end
 
-          return if empty_lines_around?(node)
+        def on_sclass(node)
+          @class_or_module_def_first_line =
+            node.identifier.source_range.first_line
+          @class_or_module_def_last_line =
+            node.source_range.last_line
+        end
 
-          add_offense(node)
+        def on_block(node)
+          @block_line = node.source_range.first_line
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            send_line = node.first_line
-            previous_line = processed_source[send_line - 2]
-            next_line = processed_source[send_line]
+        def on_send(node)
+          return unless node.bare_access_modifier? && !node.parent&.block_type?
+          return if expected_empty_lines?(node)
+
+          message = message(node)
+          add_offense(node, message: message) do |corrector|
             line = range_by_whole_lines(node.source_range)
 
-            unless previous_line_empty?(previous_line)
-              corrector.insert_before(line, "\n")
-            end
+            corrector.insert_before(line, "\n") unless previous_line_empty?(node.first_line)
 
-            unless next_line_empty?(next_line)
-              corrector.insert_after(line, "\n")
-            end
+            correct_next_line_if_denied_style(corrector, node, line)
           end
         end
 
         private
 
+        def expected_empty_lines?(node)
+          case style
+          when :around
+            return true if empty_lines_around?(node)
+          when :only_before
+            return true if allowed_only_before_style?(node)
+          end
+
+          false
+        end
+
+        def allowed_only_before_style?(node)
+          if node.special_modifier?
+            return true if processed_source[node.last_line] == 'end'
+            return false if next_line_empty?(node.last_line)
+          end
+
+          previous_line_empty?(node.first_line)
+        end
+
+        def correct_next_line_if_denied_style(corrector, node, line)
+          case style
+          when :around
+            corrector.insert_after(line, "\n") unless next_line_empty?(node.last_line)
+          when :only_before
+            if next_line_empty?(node.last_line)
+              range = next_empty_line_range(node)
+
+              corrector.remove(range)
+            end
+          end
+        end
+
         def previous_line_ignoring_comments(processed_source, send_line)
           processed_source[0..send_line - 2].reverse.find do |line|
             !comment_line?(line)
           end
         end
 
-        def previous_line_empty?(previous_line)
-          block_start?(previous_line) ||
-            class_def?(previous_line) ||
+        def previous_line_empty?(send_line)
+          previous_line = previous_line_ignoring_comments(processed_source,
+                                                          send_line)
+
+          block_start?(send_line) ||
+            class_def?(send_line) ||
             previous_line.blank?
         end
 
-        def next_line_empty?(next_line)
-          body_end?(next_line) || next_line.blank?
+        def next_line_empty?(last_send_line)
+          next_line = processed_source[last_send_line]
+
+          body_end?(last_send_line) || next_line.blank?
         end
 
         def empty_lines_around?(node)
-          send_line = node.first_line
-          previous_line = previous_line_ignoring_comments(processed_source,
-                                                          send_line)
-          next_line = processed_source[send_line]
-
-          previous_line_empty?(previous_line) && next_line_empty?(next_line)
+          previous_line_empty?(node.first_line) &&
+            next_line_empty?(node.last_line)
         end
 
         def class_def?(line)
-          line =~ /^\s*(class|module)/
+          return false unless @class_or_module_def_first_line
+
+          line == @class_or_module_def_first_line + 1
         end
 
         def block_start?(line)
-          line.match(/ (do|{)( \|.*?\|)?\s?$/)
+          return false unless @block_line
+
+          line == @block_line + 1
         end
 
         def body_end?(line)
-          line =~ /^\s*end/
+          return false unless @class_or_module_def_last_line
+
+          line == @class_or_module_def_last_line - 1
+        end
+
+        def next_empty_line_range(node)
+          source_range(processed_source.buffer, node.last_line + 1, 0)
         end
 
         def message(node)
-          previous_line = processed_source[node.first_line - 2]
+          case style
+          when :around
+            message_for_around_style(node)
+          when :only_before
+            message_for_only_before_style(node)
+          end
+        end
+
+        def message_for_around_style(node)
+          send_line = node.first_line
+
+          if block_start?(send_line) ||
+             class_def?(send_line)
+            format(MSG_AFTER, modifier: node.loc.selector.source)
+          else
+            format(MSG_BEFORE_AND_AFTER, modifier: node.loc.selector.source)
+          end
+        end
+
+        def message_for_only_before_style(node)
+          modifier = node.loc.selector.source
 
-          if block_start?(previous_line) ||
-             class_def?(previous_line)
-            format(MSG_AFTER, node.loc.selector.source)
+          if next_line_empty?(node.last_line)
+            format(MSG_AFTER_FOR_ONLY_BEFORE, modifier: modifier)
           else
-            format(MSG_BEFORE_AND_AFTER, node: node.loc.selector.source)
+            format(MSG_BEFORE_FOR_ONLY_BEFORE, modifier: modifier)
           end
         end
       end