rubocop 0.76.0 → 1.50.0

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks whether the end keyword of `begin` is aligned properly.
+      #
+      # Two modes are supported through the `EnforcedStyleAlignWith` configuration
+      # parameter. If it's set to `start_of_line` (which is the default), the
+      # `end` shall be aligned with the start of the line where the `begin`
+      # keyword is. If it's set to `begin`, the `end` shall be aligned with the
+      # `begin` keyword.
+      #
+      # `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
+      # by default. On the other hand, `||= begin` that this cop targets tends to
+      # align with the start of the line, it defaults to `EnforcedStyleAlignWith: start_of_line`.
+      # These style can be configured by each cop.
+      #
+      # @example EnforcedStyleAlignWith: start_of_line (default)
+      #   # bad
+      #   foo ||= begin
+      #             do_something
+      #           end
+      #
+      #   # good
+      #   foo ||= begin
+      #     do_something
+      #   end
+      #
+      # @example EnforcedStyleAlignWith: begin
+      #   # bad
+      #   foo ||= begin
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   foo ||= begin
+      #             do_something
+      #           end
+      #
+      class BeginEndAlignment < Base
+        include EndKeywordAlignment
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'
+
+        def on_kwbegin(node)
+          check_begin_alignment(node)
+        end
+
+        private
+
+        def check_begin_alignment(node)
+          align_with = { begin: node.loc.begin, start_of_line: start_line_range(node) }
+          check_end_kw_alignment(node, align_with)
+        end
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.align_end(corrector, processed_source, node, alignment_node(node))
+        end
+
+        def alignment_node(node)
+          case style
+          when :begin
+            node
+          else
+            start_line_range(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether the end keywords are aligned properly for do
+      # Checks whether the end keywords are aligned properly for do
       # end blocks.
       #
       # Three modes are supported through the `EnforcedStyleAlignWith`
@@ -22,23 +22,24 @@ module RuboCop
       #   # bad
       #
       #   foo.bar
-      #      .each do
-      #        baz
-      #          end
+      #     .each do
+      #       baz
+      #         end
       #
       #   # good
       #
-      #   variable = lambda do |i|
-      #     i
+      #   foo.bar
+      #     .each do
+      #       baz
       #   end
       #
       # @example EnforcedStyleAlignWith: start_of_block
       #   # bad
       #
       #   foo.bar
-      #      .each do
-      #        baz
-      #          end
+      #     .each do
+      #       baz
+      #         end
       #
       #   # good
       #
@@ -51,22 +52,25 @@ module RuboCop
       #   # bad
       #
       #   foo.bar
-      #      .each do
-      #        baz
-      #          end
+      #     .each do
+      #       baz
+      #         end
       #
       #   # good
       #
       #   foo.bar
       #     .each do
-      #        baz
+      #       baz
       #   end
-      class BlockAlignment < Cop
+      #
+      class BlockAlignment < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         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
@@ -80,23 +84,12 @@ module RuboCop
           check_block_alignment(start_for_block_node(node), node)
         end
 
+        alias on_numblock on_block
+
         def style_parameter_name
           'EnforcedStyleAlignWith'
         end
 
-        def autocorrect(node)
-          ancestor_node = start_for_block_node(node)
-          start_col = compute_start_col(ancestor_node, node)
-          loc_end = node.loc.end
-          delta = start_col - loc_end.column
-
-          if delta.positive?
-            add_space_before(loc_end, delta)
-          elsif delta.negative?
-            remove_space_before(loc_end.begin_pos, -delta)
-          end
-        end
-
         private
 
         def start_for_block_node(block_node)
@@ -112,21 +105,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)
@@ -134,19 +125,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,
@@ -163,16 +147,29 @@ module RuboCop
           message = format_message(start_loc, end_loc, do_source_line_column,
                                    error_source_line_column)
 
-          add_offense(block_node, location: end_loc, message: message)
+          add_offense(end_loc, message: message) do |corrector|
+            autocorrect(corrector, block_node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          ancestor_node = start_for_block_node(node)
+          start_col = compute_start_col(ancestor_node, node)
+          loc_end = node.loc.end
+          delta = start_col - loc_end.column
+
+          if delta.positive?
+            add_space_before(corrector, loc_end, delta)
+          elsif delta.negative?
+            remove_space_before(corrector, loc_end.begin_pos, -delta)
+          end
         end
 
         def format_message(start_loc, end_loc, do_source_line_column,
                            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)
           )
@@ -188,8 +185,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],
@@ -207,19 +203,18 @@ module RuboCop
         end
 
         def alt_start_msg(start_loc, source_line_column)
-          if style != :either
-            ''
-          elsif start_loc.line == source_line_column[:line] &&
-                start_loc.column == source_line_column[:column]
+          if style != :either ||
+             (start_loc.line == source_line_column[:line] &&
+                 start_loc.column == source_line_column[:column])
             ''
           else
-            ' or ' + format_source_line_column(source_line_column)
+            " or #{format_source_line_column(source_line_column)}"
           end
         end
 
         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)
@@ -230,13 +225,14 @@ module RuboCop
           (ancestor_node || node).source_range.column
         end
 
-        def add_space_before(loc, delta)
-          ->(corrector) { corrector.insert_before(loc, ' ' * delta) }
+        def add_space_before(corrector, loc, delta)
+          corrector.insert_before(loc, ' ' * delta)
         end
 
-        def remove_space_before(end_pos, delta)
+        def remove_space_before(corrector, end_pos, delta)
           range = range_between(end_pos - delta, end_pos)
-          ->(corrector) { corrector.remove(range) }
+
+          corrector.remove(range)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether the end statement of a do..end block
+      # Checks whether the end statement of a do..end block
       # is on its own line.
       #
       # @example
@@ -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,26 +36,45 @@ 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
+          offense_range = offense_range(node)
+          return if offense_range.source.lstrip.start_with?(';')
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(delimiter_range(node),
-                              "\n#{node.loc.end.source}#{offset(node)}")
-          end
+          register_offense(node, offense_range)
         end
 
+        alias on_numblock on_block
+
         private
 
+        def register_offense(node, offense_range)
+          add_offense(node.loc.end, message: message(node)) do |corrector|
+            replacement = "\n#{offense_range.source.lstrip}"
+
+            if (heredoc = last_heredoc_argument(node.body))
+              corrector.remove(offense_range)
+              corrector.insert_after(heredoc.loc.heredoc_end, replacement)
+            else
+              corrector.replace(offense_range, replacement)
+            end
+          end
+        end
+
         def message(node)
           format(MSG, line: node.loc.end.line, column: node.loc.end.column + 1)
         end
 
-        def delimiter_range(node)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.children.last.loc.expression.end_pos,
-                                    node.loc.expression.end_pos)
+        def last_heredoc_argument(node)
+          return unless node&.call_type?
+          return unless (arguments = node&.arguments)
+
+          heredoc = arguments.reverse.detect { |arg| arg.str_type? && arg.heredoc? }
+          return heredoc if heredoc
+
+          last_heredoc_argument(node.children.first)
+        end
+
+        def offense_range(node)
+          node.children.compact.last.source_range.end.join(node.loc.end)
         end
       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
-      # are indented in relation to its *case* or *end* keyword.
+      # 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,41 +102,59 @@ module RuboCop
       #   else
       #     y / 3
       #   end
-      class CaseIndentation < Cop
+      #
+      #   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?
+          return if enforced_style_end? && end_and_last_conditional_same_line?(case_node)
 
-          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 autocorrect(node)
-          whitespace = whitespace_range(node)
+        def on_case_match(case_match_node)
+          return if case_match_node.single_line?
+          return if enforced_style_end? && end_and_last_conditional_same_line?(case_match_node)
 
-          return false unless whitespace.source.strip.empty?
-
-          lambda do |corrector|
-            corrector.replace(whitespace, replacement(node))
-          end
+          case_match_node.each_in_pattern { |in_pattern_node| check_when(in_pattern_node, 'in') }
         end
 
         private
 
-        def check_when(when_node)
+        def end_and_last_conditional_same_line?(node)
+          end_line = node.loc.end&.line
+          last_conditional_line = if node.loc.else
+                                    node.loc.else.line
+                                  else
+                                    node.child_nodes.last.loc.begin&.line
+                                  end
+          end_line && last_conditional_line && end_line == last_conditional_line
+        end
+
+        def enforced_style_end?
+          cop_config[style_parameter_name] == 'end'
+        end
+
+        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
 
@@ -113,23 +166,28 @@ module RuboCop
           indent_one_step? ? configured_indentation_width : 0
         end
 
-        def incorrect_style(when_node)
-          when_column = when_node.loc.keyword.column
-          base_column = base_column(when_node.parent, alternative_style)
+        def incorrect_style(when_node, branch_type)
+          depth = indent_one_step? ? 'one step more than' : 'as deep as'
+          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)
 
-          add_offense(when_node, location: :keyword, message: message(style)) do
-            if when_column == base_column
-              opposite_style_detected
-            else
-              unrecognized_style_detected
-            end
+            whitespace = whitespace_range(when_node)
+
+            corrector.replace(whitespace, replacement(when_node)) if whitespace.source.strip.empty?
           end
         end
 
-        def message(base)
-          depth = indent_one_step? ? 'one step more than' : 'as deep as'
+        def detect_incorrect_style(when_node)
+          when_column = when_node.loc.keyword.column
+          base_column = base_column(when_node.parent, alternative_style)
 
-          format(MSG, depth: depth, base: base)
+          if when_column == base_column
+            opposite_style_detected
+          else
+            unrecognized_style_detected
+          end
         end
 
         def base_column(case_node, base)
@@ -147,7 +205,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)