rubocop 0.80.0 → 1.42.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks empty comment.
+      # Checks empty comment.
       #
       # @example
       #   # bad
@@ -60,51 +60,53 @@ module RuboCop
       #   class Foo
       #   end
       #
-      class EmptyComment < Cop
+      class EmptyComment < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Source code comment is empty.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           if allow_margin_comment?
             comments = concat_consecutive_comments(processed_source.comments)
 
-            comments.each do |comment|
-              next unless empty_comment_only?(comment[0])
-
-              comment[1].each do |offense_comment|
-                add_offense(offense_comment)
-              end
-            end
+            investigate(comments)
           else
             processed_source.comments.each do |comment|
               next unless empty_comment_only?(comment_text(comment))
 
-              add_offense(comment)
+              add_offense(comment) { |corrector| autocorrect(corrector, comment) }
             end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            previous_token = previous_token(node)
-            range = if previous_token && node.loc.line == previous_token.line
-                      range_with_surrounding_space(range: node.loc.expression,
-                                                   newlines: false)
-                    else
-                      range_by_whole_lines(node.loc.expression,
-                                           include_final_newline: true)
-                    end
-
-            corrector.remove(range)
+        private
+
+        def investigate(comments)
+          comments.each do |comment|
+            next unless empty_comment_only?(comment[0])
+
+            comment[1].each do |offense_comment|
+              add_offense(offense_comment) do |corrector|
+                autocorrect(corrector, offense_comment)
+              end
+            end
           end
         end
 
-        private
+        def autocorrect(corrector, node)
+          previous_token = previous_token(node)
+          range = if previous_token && same_line?(node, previous_token)
+                    range_with_surrounding_space(node.loc.expression, newlines: false)
+                  else
+                    range_by_whole_lines(node.loc.expression, include_final_newline: true)
+                  end
+
+          corrector.remove(range)
+        end
 
         def concat_consecutive_comments(comments)
-          consecutive_comments =
-            comments.chunk_while { |i, j| i.loc.line.succ == j.loc.line }
+          consecutive_comments = comments.chunk_while { |i, j| i.loc.line.succ == j.loc.line }
 
           consecutive_comments.map do |chunk|
             joined_text = chunk.map { |c| comment_text(c) }.join
@@ -119,7 +121,7 @@ module RuboCop
                                     /\A(#+\n)+\z/
                                   end
 
-          !(comment_text =~ empty_comment_pattern).nil?
+          empty_comment_pattern.match?(comment_text)
         end
 
         def comment_text(comment)
@@ -135,9 +137,7 @@ module RuboCop
         end
 
         def current_token(comment)
-          processed_source.find_token do |token|
-            token.pos == comment.loc.expression
-          end
+          processed_source.find_token { |token| token.pos == comment.loc.expression }
         end
 
         def previous_token(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop enforces empty line after guard clause
+      # Enforces empty line after guard clause
       #
       # @example
       #
@@ -35,41 +35,47 @@ module RuboCop
       #       return if need_return?
       #     end
       #   end
-      class EmptyLineAfterGuardClause < Cop
+      class EmptyLineAfterGuardClause < Base
         include RangeHelp
+        extend AutoCorrector
+        extend Util
 
         MSG = 'Add empty line after guard clause.'
         END_OF_HEREDOC_LINE = 1
 
         def on_if(node)
           return if correct_style?(node)
+          return if multiple_statements_on_line?(node)
 
-          if node.modifier_form? && last_argument_is_heredoc?(node)
-            heredoc_node = last_heredoc_argument(node)
+          if node.modifier_form? && (heredoc_node = last_heredoc_argument(node))
+            return if next_line_empty_or_enable_directive_comment?(heredoc_line(node, heredoc_node))
 
-            return if next_line_empty?(heredoc_line(node, heredoc_node))
-
-            add_offense(heredoc_node, location: :heredoc_end)
+            add_offense(heredoc_node.loc.heredoc_end) do |corrector|
+              autocorrect(corrector, heredoc_node)
+            end
           else
-            return if next_line_empty?(node.last_line)
+            return if next_line_empty_or_enable_directive_comment?(node.last_line)
 
-            add_offense(node, location: offense_location(node))
+            add_offense(offense_location(node)) { |corrector| autocorrect(corrector, node) }
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            node_range = if node.respond_to?(:heredoc?) && node.heredoc?
-                           range_by_whole_lines(node.loc.heredoc_body)
-                         else
-                           range_by_whole_lines(node.source_range)
-                         end
+        private
+
+        def autocorrect(corrector, node)
+          node_range = if heredoc?(node)
+                         range_by_whole_lines(node.loc.heredoc_body)
+                       else
+                         range_by_whole_lines(node.source_range)
+                       end
 
-            corrector.insert_after(node_range, "\n")
+          next_line = node_range.last_line + 1
+          if next_line_enable_directive_comment?(next_line)
+            node_range = processed_source.comment_at_line(next_line)
           end
-        end
 
-        private
+          corrector.insert_after(node_range, "\n")
+        end
 
         def correct_style?(node)
           !contains_guard_clause?(node) ||
@@ -82,17 +88,30 @@ module RuboCop
           node.if_branch&.guard_clause?
         end
 
+        def next_line_empty_or_enable_directive_comment?(line)
+          return true if next_line_empty?(line)
+
+          next_line = line + 1
+          next_line_enable_directive_comment?(next_line) && next_line_empty?(next_line)
+        end
+
         def next_line_empty?(line)
           processed_source[line].blank?
         end
 
+        def next_line_enable_directive_comment?(line)
+          return false unless (comment = processed_source.comment_at_line(line))
+
+          DirectiveComment.new(comment).enabled?
+        end
+
         def next_line_rescue_or_ensure?(node)
           parent = node.parent
           parent.nil? || parent.rescue_type? || parent.ensure_type?
         end
 
         def next_sibling_parent_empty_or_else?(node)
-          next_sibling = node.parent.children[node.sibling_index + 1]
+          next_sibling = node.right_sibling
           return true if next_sibling.nil?
 
           parent = next_sibling.parent
@@ -101,25 +120,14 @@ module RuboCop
         end
 
         def next_sibling_empty_or_guard_clause?(node)
-          next_sibling = node.parent.children[node.sibling_index + 1]
+          next_sibling = node.right_sibling
           return true if next_sibling.nil?
 
           next_sibling.if_type? && contains_guard_clause?(next_sibling)
         end
 
-        def last_argument_is_heredoc?(node)
-          last_children = node.if_branch
-          return false unless last_children&.send_type?
-
-          heredoc?(last_heredoc_argument(node))
-        end
-
         def last_heredoc_argument(node)
-          n = if node.respond_to?(:if_branch)
-                node.if_branch.children.last
-              else
-                node
-              end
+          n = last_heredoc_argument_node(node)
 
           return n if heredoc?(n)
           return unless n.respond_to?(:arguments)
@@ -132,10 +140,19 @@ module RuboCop
           return last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
         end
 
+        def last_heredoc_argument_node(node)
+          return node unless node.respond_to?(:if_branch)
+
+          if node.if_branch.and_type?
+            node.if_branch.children.first
+          else
+            node.if_branch.children.last
+          end
+        end
+
         def heredoc_line(node, heredoc_node)
           heredoc_body = heredoc_node.loc.heredoc_body
-          num_of_heredoc_lines =
-            heredoc_body.last_line - heredoc_body.first_line
+          num_of_heredoc_lines = heredoc_body.last_line - heredoc_body.first_line
 
           node.last_line + num_of_heredoc_lines + END_OF_HEREDOC_LINE
         end
@@ -146,11 +163,18 @@ module RuboCop
 
         def offense_location(node)
           if node.loc.respond_to?(:end) && node.loc.end
-            :end
+            node.loc.end
           else
-            :expression
+            node
           end
         end
+
+        def multiple_statements_on_line?(node)
+          parent = node.parent
+          return false unless parent
+
+          parent.begin_type? && parent.single_line?
+        end
       end
     end
   end

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