rubocop 0.89.1 → 0.90.0

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

@@ -133,8 +133,9 @@ module RuboCop
       #   end
       #
       # @see https://rubystyle.guide#consistent-classes
-      class ClassStructure < Cop
+      class ClassStructure < Base
         include VisibilityHelp
+        extend AutoCorrector
 
         HUMANIZED_NODE_TYPE = {
           casgn: :constants,
@@ -155,14 +156,18 @@ module RuboCop
             if index < previous
               message = format(MSG, category: category,
                                     previous: expected_order[previous])
-              add_offense(node, message: message)
+              add_offense(node, message: message) do |corrector|
+                autocorrect(corrector, node)
+              end
             end
             previous = index
           end
         end
 
+        private
+
         # Autocorrect by swapping between two nodes autocorrecting them
-        def autocorrect(node)
+        def autocorrect(corrector, node)
           node_classification = classify(node)
           previous = left_siblings_of(node).find do |sibling|
             classification = classify(sibling)
@@ -172,14 +177,10 @@ module RuboCop
           current_range = source_range_with_comment(node)
           previous_range = source_range_with_comment(previous)
 
-          lambda do |corrector|
-            corrector.insert_before(previous_range, current_range.source)
-            corrector.remove(current_range)
-          end
+          corrector.insert_before(previous_range, current_range.source)
+          corrector.remove(current_range)
         end
 
-        private
-
         # Classifies a node to match with something in the {expected_order}
         # @param node to be analysed
         # @return String when the node type is a `:block` then

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

@@ -46,8 +46,9 @@ module RuboCop
       #         Hi
       #       EOS
       #
-      class ClosingHeredocIndentation < Cop
+      class ClosingHeredocIndentation < Base
         include Heredoc
+        extend AutoCorrector
 
         SIMPLE_HEREDOC = '<<'
         MSG = '`%<closing>s` is not aligned with `%<opening>s`.'
@@ -59,11 +60,8 @@ module RuboCop
                     opening_indentation(node) == closing_indentation(node) ||
                     argument_indentation_correct?(node)
 
-          add_offense(node, location: :heredoc_end)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          message = message(node)
+          add_offense(node.loc.heredoc_end, message: message) do |corrector|
             corrector.replace(node.loc.heredoc_end, indented_end(node))
           end
         end

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

@@ -22,8 +22,9 @@ module RuboCop
       #   if some_condition
       #     do_something
       #   end
-      class ConditionPosition < Cop
+      class ConditionPosition < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Place the condition on the same line as `%<keyword>s`.'
 
@@ -38,27 +39,24 @@ module RuboCop
         end
         alias on_until on_while
 
-        def autocorrect(node)
-          lambda do |corrector|
-            range = range_by_whole_lines(
-              node.source_range, include_final_newline: true
-            )
-
-            corrector.insert_after(node.parent.loc.keyword, " #{node.source}")
-            corrector.remove(range)
-          end
-        end
-
         private
 
         def check(node)
           return if node.modifier_form? || node.single_line_condition?
 
-          add_offense(node.condition)
+          condition = node.condition
+          message = message(condition)
+
+          add_offense(condition, message: message) do |corrector|
+            range = range_by_whole_lines(condition.source_range, include_final_newline: true)
+
+            corrector.insert_after(condition.parent.loc.keyword, " #{condition.source}")
+            corrector.remove(range)
+          end
         end
 
-        def message(node)
-          format(MSG, keyword: node.parent.keyword)
+        def message(condition)
+          format(MSG, keyword: condition.parent.keyword)
         end
       end
     end

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

@@ -33,9 +33,10 @@ module RuboCop
       #
       #   private def foo
       #           end
-      class DefEndAlignment < Cop
+      class DefEndAlignment < Base
         include EndKeywordAlignment
         include RangeHelp
+        extend AutoCorrector
 
         MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'
 
@@ -61,11 +62,13 @@ module RuboCop
           ignore_node(method_def) # Don't check the same `end` again.
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           if style == :start_of_line && node.parent && node.parent.send_type?
-            AlignmentCorrector.align_end(processed_source, node, node.parent)
+            AlignmentCorrector.align_end(corrector, processed_source, node, node.parent)
           else
-            AlignmentCorrector.align_end(processed_source, node, node)
+            AlignmentCorrector.align_end(corrector, processed_source, node, node)
           end
         end
       end

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

@@ -22,8 +22,9 @@ module RuboCop
       #   # good
       #   something.
       #     method
-      class DotPosition < Cop
+      class DotPosition < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         def on_send(node)
           return unless node.dot? || ampersand_dot?(node)
@@ -31,29 +32,32 @@ module RuboCop
           if proper_dot_position?(node)
             correct_style_detected
           else
-            add_offense(node, location: :dot) { opposite_style_detected }
-          end
-        end
-        alias on_csend on_send
+            return unless opposite_style_detected
 
-        def autocorrect(node)
-          lambda do |corrector|
-            dot = node.loc.dot.source
-            corrector.remove(node.loc.dot)
-            case style
-            when :leading
-              corrector.insert_before(selector_range(node), dot)
-            when :trailing
-              corrector.insert_after(node.receiver, dot)
+            dot = node.loc.dot
+            message = message(dot)
+
+            add_offense(dot, message: message) do |corrector|
+              autocorrect(corrector, dot, node)
             end
           end
         end
+        alias on_csend on_send
 
         private
 
-        def message(node)
-          dot = node.loc.dot.source
-          "Place the #{dot} on the " +
+        def autocorrect(corrector, dot, node)
+          corrector.remove(dot)
+          case style
+          when :leading
+            corrector.insert_before(selector_range(node), dot.source)
+          when :trailing
+            corrector.insert_after(node.receiver, dot.source)
+          end
+        end
+
+        def message(dot)
+          "Place the #{dot.source} on the " +
             case style
             when :leading
               'next line, together with the method name.'

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

@@ -60,47 +60,54 @@ 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) do |corrector|
+                autocorrect(corrector, comment)
+              end
             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 && 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)
+        end
 
         def concat_consecutive_comments(comments)
           consecutive_comments =

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

@@ -35,8 +35,9 @@ module RuboCop
       #       return if need_return?
       #     end
       #   end
-      class EmptyLineAfterGuardClause < Cop
+      class EmptyLineAfterGuardClause < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Add empty line after guard clause.'
         END_OF_HEREDOC_LINE = 1
@@ -49,27 +50,29 @@ module RuboCop
 
             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)
 
-            add_offense(node, location: offense_location(node))
+            add_offense(offense_location(node)) do |corrector|
+              autocorrect(corrector, node)
+            end
           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
 
-            corrector.insert_after(node_range, "\n")
-          end
-        end
+        def autocorrect(corrector, node)
+          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
+          corrector.insert_after(node_range, "\n")
+        end
 
         def correct_style?(node)
           !contains_guard_clause?(node) ||
@@ -146,9 +149,9 @@ module RuboCop
 
         def offense_location(node)
           if node.loc.respond_to?(:end) && node.loc.end
-            :end
+            node.loc.end
           else
-            :expression
+            node
           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,144 @@
+# 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
+        include RescueNode
+        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) unless next_sibling_empty?(node)
+          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 if next_sibling_empty?(node)
+
+          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)
+          _body, *resbodies, _else = *node
+
+          resbodies.each do |resbody|
+            rescued_exceptions = rescued_exceptions(resbody)
+            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 next_sibling_empty?(node)
+          next_sibling = node.parent.children[node.sibling_index + 1]
+          next_sibling.nil?
+        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