rubocop 0.78.0 → 1.13.0

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

@@ -32,29 +32,30 @@ module RuboCop
       #     true
       #   end
       #
-      class CommentIndentation < Cop
+      class CommentIndentation < Base
         include Alignment
+        extend AutoCorrector
 
         MSG = 'Incorrect indentation detected (column %<column>d ' \
           'instead of %<correct_comment_indentation>d).'
 
-        def investigate(processed_source)
-          processed_source.each_comment { |comment| check(comment) }
-        end
-
-        def autocorrect(comment)
-          corrections = autocorrect_preceding_comments(comment) <<
-                        autocorrect_one(comment)
-          ->(corrector) { corrections.each { |corr| corr.call(corrector) } }
+        def on_new_investigation
+          processed_source.comments.each { |comment| check(comment) }
         end
 
         private
 
+        def autocorrect(corrector, comment)
+          autocorrect_preceding_comments(corrector, comment)
+
+          autocorrect_one(corrector, comment)
+        end
+
         # Corrects all comment lines that occur immediately before the given
         # comment and have the same indentation. This is to avoid a long chain
         # of correcting, saving the file, parsing and inspecting again, and
         # then correcting one more line, and so on.
-        def autocorrect_preceding_comments(comment)
+        def autocorrect_preceding_comments(corrector, comment)
           comments = processed_source.comments
           index = comments.index(comment)
 
@@ -62,7 +63,7 @@ module RuboCop
             .reverse_each
             .each_cons(2)
             .take_while { |below, above| should_correct?(above, below) }
-            .map { |_, above| autocorrect_one(above) }
+            .map { |_, above| autocorrect_one(corrector, above) }
         end
 
         def should_correct?(preceding_comment, reference_comment)
@@ -71,8 +72,8 @@ module RuboCop
           loc.line == ref_loc.line - 1 && loc.column == ref_loc.column
         end
 
-        def autocorrect_one(comment)
-          AlignmentCorrector.correct(processed_source, comment, @column_delta)
+        def autocorrect_one(corrector, comment)
+          AlignmentCorrector.correct(corrector, processed_source, comment, @column_delta)
         end
 
         def check(comment)
@@ -93,23 +94,18 @@ module RuboCop
             return if column == correct_comment_indentation
           end
 
-          add_offense(
-            comment,
-            message: message(column, correct_comment_indentation)
-          )
+          add_offense(comment, message: message(column, correct_comment_indentation)) do |corrector|
+            autocorrect(corrector, comment)
+          end
         end
 
         def message(column, correct_comment_indentation)
-          format(
-            MSG,
-            column: column,
-            correct_comment_indentation: correct_comment_indentation
-          )
+          format(MSG, column: column, correct_comment_indentation: correct_comment_indentation)
         end
 
         def own_line_comment?(comment)
           own_line = processed_source.lines[comment.loc.line - 1]
-          own_line =~ /\A\s*#/
+          /\A\s*#/.match?(own_line)
         end
 
         def line_after_comment(comment)
@@ -129,11 +125,11 @@ module RuboCop
         end
 
         def less_indented?(line)
-          line =~ /^\s*(end\b|[)}\]])/
+          /^\s*(end\b|[)}\]])/.match?(line)
         end
 
         def two_alternatives?(line)
-          line =~ /^\s*(else|elsif|when|rescue|ensure)\b/
+          /^\s*(else|elsif|when|rescue|ensure)\b/.match?(line)
         end
       end
     end

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

@@ -22,7 +22,10 @@ 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`.'
 
         def on_if(node)
@@ -34,21 +37,26 @@ module RuboCop
         def on_while(node)
           check(node)
         end
-
-        def on_until(node)
-          check(node)
-        end
+        alias on_until on_while
 
         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.'
 
@@ -50,22 +51,20 @@ module RuboCop
           method_def = node.each_descendant(:def, :defs).first
           expr = node.source_range
 
-          line_start = range_between(expr.begin_pos,
-                                     method_def.loc.keyword.end_pos)
-          align_with = {
-            def: method_def.loc.keyword,
-            start_of_line: line_start
-          }
+          line_start = range_between(expr.begin_pos, method_def.loc.keyword.end_pos)
+          align_with = { def: method_def.loc.keyword, start_of_line: line_start }
 
           check_end_kw_alignment(method_def, align_with)
           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,38 +22,37 @@ 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)
 
-          if proper_dot_position?(node)
-            correct_style_detected
-          else
-            add_offense(node, location: :dot) { opposite_style_detected }
-          end
+          return correct_style_detected if proper_dot_position?(node)
+
+          opposite_style_detected
+          dot = node.loc.dot
+          message = message(dot)
+
+          add_offense(dot, message: message) { |corrector| autocorrect(corrector, dot, node) }
         end
         alias on_csend on_send
 
-        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.source_range, dot)
-            end
+        private
+
+        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
 
-        private
-
-        def message(node)
-          dot = node.loc.dot.source
-          "Place the #{dot} on the " +
+        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/else_alignment.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Layout
       # This cop checks the alignment of else keywords. Normally they should
-      # be aligned with an if/unless/while/until/begin/def keyword, but there
+      # be aligned with an if/unless/while/until/begin/def/rescue keyword, but there
       # are special cases when they should follow the same rules as the
       # alignment of end.
       #
@@ -29,10 +29,11 @@ module RuboCop
       #   else
       #     code
       #   end
-      class ElseAlignment < Cop
+      class ElseAlignment < Base
         include EndKeywordAlignment
         include Alignment
         include CheckAssignment
+        extend AutoCorrector
 
         MSG = 'Align `%<else_range>s` with `%<base_range>s`.'
 
@@ -59,12 +60,18 @@ module RuboCop
           check_alignment(node.when_branches.last.loc.keyword, node.loc.else)
         end
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
+        def on_case_match(node)
+          return unless node.else?
+
+          check_alignment(node.in_pattern_branches.last.loc.keyword, node.loc.else)
         end
 
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
         def check_nested(node, base)
           on_if(node, base)
           ignore_node(node)
@@ -85,7 +92,13 @@ module RuboCop
           case parent.type
           when :def, :defs then base_for_method_definition(parent)
           when :kwbegin then parent.loc.begin
-          when :block then parent.send_node.source_range
+          when :block
+            assignment_node = assignment_node(parent)
+            if same_line?(parent, assignment_node)
+              assignment_node.source_range
+            else
+              parent.send_node.source_range
+            end
           else node.loc.keyword
           end
         end
@@ -126,7 +139,16 @@ module RuboCop
             else_range: else_range.source,
             base_range: base_range.source[/^\S*/]
           )
-          add_offense(else_range, location: else_range, message: message)
+          add_offense(else_range, message: message) do |corrector|
+            autocorrect(corrector, else_range)
+          end
+        end
+
+        def assignment_node(node)
+          assignment_node = node.ancestors.first
+          return unless assignment_node&.assignment?
+
+          assignment_node
         end
       end
     end

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

@@ -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 && 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 =
-            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

@@ -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
@@ -46,30 +47,34 @@ module RuboCop
 
           if node.modifier_form? && last_argument_is_heredoc?(node)
             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 node.respond_to?(:heredoc?) && node.heredoc?
+                         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 +87,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,7 +119,7 @@ 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)
@@ -134,8 +152,7 @@ module RuboCop
 
         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,9 +163,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