rubocop 1.9.1 → 1.22.3

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

@@ -68,6 +68,7 @@ module RuboCop
 
         MSG = '%<current>s is not aligned with %<prefer>s%<alt_prefer>s.'
 
+        # @!method block_end_align_target?(node, child)
         def_node_matcher :block_end_align_target?, <<~PATTERN
           {assignment?
            splat
@@ -100,21 +101,19 @@ module RuboCop
         def block_end_align_target(node)
           lineage = [node, *node.ancestors]
 
-          target = lineage.each_cons(2) do |current, parent|
-            break current if end_align_target?(current, parent)
+          lineage.each_cons(2) do |current, parent|
+            return current if end_align_target?(current, parent)
           end
 
-          target || lineage.last
+          lineage.last
         end
 
         def end_align_target?(node, parent)
-          disqualified_parent?(parent, node) ||
-            !block_end_align_target?(parent, node)
+          disqualified_parent?(parent, node) || !block_end_align_target?(parent, node)
         end
 
         def disqualified_parent?(parent, node)
-          parent&.loc && parent.first_line != node.first_line &&
-            !parent.masgn_type?
+          parent&.loc && parent.first_line != node.first_line && !parent.masgn_type?
         end
 
         def check_block_alignment(start_node, block_node)
@@ -122,19 +121,12 @@ module RuboCop
           return unless begins_its_line?(end_loc)
 
           start_loc = start_node.source_range
-          return unless start_loc.column != end_loc.column ||
-                        style == :start_of_block
+          return unless start_loc.column != end_loc.column || style == :start_of_block
 
-          do_source_line_column =
-            compute_do_source_line_column(block_node, end_loc)
+          do_source_line_column = compute_do_source_line_column(block_node, end_loc)
           return unless do_source_line_column
 
-          register_offense(
-            block_node,
-            start_loc,
-            end_loc,
-            do_source_line_column
-          )
+          register_offense(block_node, start_loc, end_loc, do_source_line_column)
         end
 
         def register_offense(block_node,
@@ -173,9 +165,7 @@ module RuboCop
                            error_source_line_column)
           format(
             MSG,
-            current: format_source_line_column(
-              loc_to_source_line_column(end_loc)
-            ),
+            current: format_source_line_column(loc_to_source_line_column(end_loc)),
             prefer: format_source_line_column(error_source_line_column),
             alt_prefer: alt_start_msg(start_loc, do_source_line_column)
           )
@@ -191,8 +181,7 @@ module RuboCop
           # blocks.
           match = /\S.*/.match(do_loc.source_line)
           indentation_of_do_line = match.begin(0)
-          return unless end_loc.column != indentation_of_do_line ||
-                        style == :start_of_line
+          return unless end_loc.column != indentation_of_do_line || style == :start_of_line
 
           {
             source: match[0],
@@ -221,7 +210,7 @@ module RuboCop
 
         def format_source_line_column(source_line_column)
           "`#{source_line_column[:source]}` at #{source_line_column[:line]}, " \
-          "#{source_line_column[:column]}"
+            "#{source_line_column[:column]}"
         end
 
         def compute_start_col(ancestor_node, node)

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

@@ -24,8 +24,9 @@ module RuboCop
       #   blah { |i|
       #     foo(i)
       #   }
-      class BlockEndNewline < Cop
+      class BlockEndNewline < Base
         include Alignment
+        extend AutoCorrector
 
         MSG = 'Expression at %<line>d, %<column>d should be on its own line.'
 
@@ -35,13 +36,8 @@ module RuboCop
           # If the end is on its own line, there is no offense
           return if begins_its_line?(node.loc.end)
 
-          add_offense(node, location: :end)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(delimiter_range(node),
-                              "\n#{node.loc.end.source}#{offset(node)}")
+          add_offense(node.loc.end, message: message(node)) do |corrector|
+            corrector.replace(delimiter_range(node), "\n#{node.loc.end.source}#{offset(node)}")
           end
         end
 

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

@@ -3,10 +3,10 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks how the ``when``s of a `case` expression
+      # This cop checks how the `when` and `in`s of a `case` expression
       # are indented in relation to its `case` or `end` keyword.
       #
-      # It will register a separate offense for each misaligned `when`.
+      # It will register a separate offense for each misaligned `when` and `in`.
       #
       # @example
       #   # If Layout/EndAlignment is set to keyword style (default)
@@ -22,6 +22,13 @@ module RuboCop
       #       y / 3
       #   end
       #
+      #   case n
+      #     in pattern
+      #       x * 2
+      #     else
+      #       y / 3
+      #   end
+      #
       #   # good for all styles
       #   case n
       #   when 0
@@ -30,6 +37,13 @@ module RuboCop
       #     y / 3
       #   end
       #
+      #   case n
+      #   in pattern
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
       # @example EnforcedStyle: case (default)
       #   # if EndAlignment is set to other style such as
       #   # start_of_line (as shown below), then *when* alignment
@@ -43,6 +57,13 @@ module RuboCop
       #     y / 3
       #   end
       #
+      #   a = case n
+      #   in pattern
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
       #   # good
       #   a = case n
       #       when 0
@@ -51,6 +72,13 @@ module RuboCop
       #         y / 3
       #   end
       #
+      #   a = case n
+      #       in pattern
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
       # @example EnforcedStyle: end
       #   # bad
       #   a = case n
@@ -60,6 +88,13 @@ module RuboCop
       #         y / 3
       #   end
       #
+      #   a = case n
+      #       in pattern
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
       #   # good
       #   a = case n
       #   when 0
@@ -67,32 +102,43 @@ module RuboCop
       #   else
       #     y / 3
       #   end
+      #
+      #   a = case n
+      #   in pattern
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
       class CaseIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Indent `when` %<depth>s `%<base>s`.'
+        MSG = 'Indent `%<branch_type>s` %<depth>s `%<base>s`.'
 
         def on_case(case_node)
           return if case_node.single_line?
 
-          case_node.each_when do |when_node|
-            check_when(when_node)
-          end
+          case_node.each_when { |when_node| check_when(when_node, 'when') }
+        end
+
+        def on_case_match(case_match_node)
+          return if case_match_node.single_line?
+
+          case_match_node.each_in_pattern { |in_pattern_node| check_when(in_pattern_node, 'in') }
         end
 
         private
 
-        def check_when(when_node)
+        def check_when(when_node, branch_type)
           when_column = when_node.loc.keyword.column
           base_column = base_column(when_node.parent, style)
 
           if when_column == base_column + indentation_width
             correct_style_detected
           else
-            incorrect_style(when_node)
+            incorrect_style(when_node, branch_type)
           end
         end
 
@@ -104,9 +150,9 @@ module RuboCop
           indent_one_step? ? configured_indentation_width : 0
         end
 
-        def incorrect_style(when_node)
+        def incorrect_style(when_node, branch_type)
           depth = indent_one_step? ? 'one step more than' : 'as deep as'
-          message = format(MSG, depth: depth, base: style)
+          message = format(MSG, branch_type: branch_type, depth: depth, base: style)
 
           add_offense(when_node.loc.keyword, message: message) do |corrector|
             detect_incorrect_style(when_node)
@@ -143,7 +189,7 @@ module RuboCop
         end
 
         def replacement(node)
-          case_node = node.each_ancestor(:case).first
+          case_node = node.each_ancestor(:case, :case_match).first
           base_type = cop_config[style_parameter_name] == 'end' ? :end : :case
 
           column = base_column(case_node, base_type)

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

@@ -144,9 +144,9 @@ module RuboCop
           sclass: :class_singleton
         }.freeze
 
-        MSG = '`%<category>s` is supposed to appear before ' \
-              '`%<previous>s`.'
+        MSG = '`%<category>s` is supposed to appear before `%<previous>s`.'
 
+        # @!method dynamic_constant?(node)
         def_node_matcher :dynamic_constant?, <<~PATTERN
           (casgn nil? _ (send ...))
         PATTERN
@@ -158,11 +158,8 @@ module RuboCop
           walk_over_nested_class_definition(class_node) do |node, category|
             index = expected_order.index(category)
             if index < previous
-              message = format(MSG, category: category,
-                                    previous: expected_order[previous])
-              add_offense(node, message: message) do |corrector|
-                autocorrect(corrector, node)
-              end
+              message = format(MSG, category: category, previous: expected_order[previous])
+              add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
             end
             previous = index
           end
@@ -253,9 +250,7 @@ module RuboCop
           classification = classify(node)
           sibling_class = classify(sibling)
 
-          ignore?(sibling_class) ||
-            classification == sibling_class ||
-            dynamic_constant?(node)
+          ignore?(sibling_class) || classification == sibling_class || dynamic_constant?(node)
         end
 
         def humanize_node(node)
@@ -269,7 +264,8 @@ module RuboCop
 
         def source_range_with_comment(node)
           begin_pos, end_pos =
-            if node.def_type? && !node.method?(:initialize) || node.send_type? && node.def_modifier?
+            if (node.def_type? && !node.method?(:initialize)) ||
+               (node.send_type? && node.def_modifier?)
               start_node = find_visibility_start(node) || node
               end_node = find_visibility_end(node) || node
               [begin_pos_with_comment(start_node),
@@ -294,12 +290,16 @@ module RuboCop
           (node.first_line - 1).downto(1) do |annotation_line|
             break unless (comment = processed_source.comment_at_line(annotation_line))
 
-            first_comment = comment
+            first_comment = comment if whole_line_comment_at_line?(annotation_line)
           end
 
           start_line_position(first_comment || node)
         end
 
+        def whole_line_comment_at_line?(line)
+          /\A\s*#/.match?(processed_source.lines[line - 1])
+        end
+
         def start_line_position(node)
           buffer.line_range(node.loc.line).begin_pos - 1
         end

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

@@ -68,8 +68,9 @@ module RuboCop
       #   )
       #
       #
-      class ClosingParenthesisIndentation < Cop
+      class ClosingParenthesisIndentation < Base
         include Alignment
+        extend AutoCorrector
 
         MSG_INDENT = 'Indent `)` to column %<expected>d (not %<actual>d)'
 
@@ -89,12 +90,12 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, @column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
         def check(node, elements)
           if elements.empty?
             check_for_no_elements(node)
@@ -115,11 +116,10 @@ module RuboCop
 
           return if @column_delta.zero?
 
-          add_offense(right_paren,
-                      location: right_paren,
-                      message:  message(correct_column,
-                                        left_paren,
-                                        right_paren))
+          message = message(correct_column, left_paren, right_paren)
+          add_offense(right_paren, message: message) do |corrector|
+            autocorrect(corrector, right_paren)
+          end
         end
 
         def check_for_no_elements(node)
@@ -135,17 +135,15 @@ module RuboCop
           # select the first one of candidates to determine a specification.
           correct_column = candidates.first
           @column_delta = correct_column - right_paren.column
-          add_offense(right_paren,
-                      location: right_paren,
-                      message:  message(correct_column,
-                                        left_paren,
-                                        right_paren))
+          message = message(correct_column, left_paren, right_paren)
+          add_offense(right_paren, message: message) do |corrector|
+            autocorrect(corrector, right_paren)
+          end
         end
 
         def expected_column(left_paren, elements)
           if line_break_after_left_paren?(left_paren, elements)
-            source_indent = processed_source
-                            .line_indentation(first_argument_line(elements))
+            source_indent = processed_source.line_indentation(first_argument_line(elements))
             new_indent    = source_indent - indentation_width
 
             new_indent.negative? ? 0 : new_indent
@@ -157,17 +155,17 @@ module RuboCop
         end
 
         def all_elements_aligned?(elements)
-          elements
-            .map { |e| e.loc.column }
-            .uniq
-            .count == 1
+          elements.flat_map do |e|
+            if e.hash_type?
+              e.each_pair.map { |pair| pair.loc.column }
+            else
+              e.loc.column
+            end
+          end.uniq.count == 1
         end
 
         def first_argument_line(elements)
-          elements
-            .first
-            .loc
-            .first_line
+          elements.first.loc.first_line
         end
 
         def correct_column_candidates(node, left_paren)
@@ -182,11 +180,7 @@ module RuboCop
           if correct_column == left_paren.column
             MSG_ALIGN
           else
-            format(
-              MSG_INDENT,
-              expected: correct_column,
-              actual: right_paren.column
-            )
+            format(MSG_INDENT, expected: correct_column, actual: right_paren.column)
           end
         end
 

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).'
+              'instead of %<correct_comment_indentation>d).'
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.comments.each { |comment| check(comment) }
         end
 
-        def autocorrect(comment)
-          corrections = autocorrect_preceding_comments(comment) <<
-                        autocorrect_one(comment)
-          ->(corrector) { corrections.each { |corr| corr.call(corrector) } }
-        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,18 +94,13 @@ 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)

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

@@ -51,12 +51,8 @@ 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.

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

@@ -24,6 +24,7 @@ module RuboCop
       #     method
       class DotPosition < Base
         include ConfigurableEnforcedStyle
+        include RangeHelp
         extend AutoCorrector
 
         def on_send(node)
@@ -35,16 +36,19 @@ module RuboCop
           dot = node.loc.dot
           message = message(dot)
 
-          add_offense(dot, message: message) do |corrector|
-            autocorrect(corrector, dot, node)
-          end
+          add_offense(dot, message: message) { |corrector| autocorrect(corrector, dot, node) }
         end
         alias on_csend on_send
 
         private
 
         def autocorrect(corrector, dot, node)
-          corrector.remove(dot)
+          dot_range = if processed_source[dot.line - 1].strip == '.'
+                        range_by_whole_lines(dot, include_final_newline: true)
+                      else
+                        dot
+                      end
+          corrector.remove(dot_range)
           case style
           when :leading
             corrector.insert_before(selector_range(node), dot.source)
@@ -64,19 +68,22 @@ module RuboCop
         end
 
         def proper_dot_position?(node)
-          receiver_line = node.receiver.source_range.end.line
-          selector_line = selector_range(node).line
+          selector_range = selector_range(node)
 
-          # receiver and selector are on the same line
-          return true if selector_line == receiver_line
+          return true if same_line?(selector_range, end_range(node.receiver))
 
+          selector_line = selector_range.line
+          receiver_line = receiver_end_line(node.receiver)
           dot_line = node.loc.dot.line
 
           # don't register an offense if there is a line comment between the
           # dot and the selector otherwise, we might break the code while
           # "correcting" it (even if there is just an extra blank line, treat
           # it the same)
-          return true if line_between?(selector_line, dot_line)
+          # Also, in the case of a heredoc, the receiver will end after the dot,
+          # because the heredoc body is on subsequent lines, so use the highest
+          # line to compare to.
+          return true if line_between?(selector_line, [receiver_line, dot_line].max)
 
           correct_dot_position_style?(dot_line, selector_line)
         end
@@ -92,7 +99,33 @@ module RuboCop
           end
         end
 
+        def receiver_end_line(node)
+          if (line = last_heredoc_line(node))
+            line
+          else
+            node.source_range.end.line
+          end
+        end
+
+        def last_heredoc_line(node)
+          if node.send_type?
+            node.arguments.select { |arg| heredoc?(arg) }.map { |arg| arg.loc.heredoc_end.line }.max
+          elsif heredoc?(node)
+            node.loc.heredoc_end.line
+          end
+        end
+
+        def heredoc?(node)
+          (node.str_type? || node.dstr_type?) && node.heredoc?
+        end
+
+        def end_range(node)
+          node.source_range.end
+        end
+
         def selector_range(node)
+          return node unless node.call_type?
+
           # l.(1) has no selector, so we use the opening parenthesis instead
           node.loc.selector || node.loc.begin
         end

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

@@ -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`.'
 
@@ -62,17 +63,15 @@ module RuboCop
         def on_case_match(node)
           return unless node.else?
 
-          check_alignment(
-            node.in_pattern_branches.last.loc.keyword, node.loc.else
-          )
-        end
-
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
+          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)
@@ -140,7 +139,9 @@ 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)