rubocop 1.91.0 → 1.92.2

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

@@ -245,20 +245,30 @@ module RuboCop
             return if with_space.is?(operator.source)
 
             "Space around operator `#{operator.source}` detected."
-          elsif !/^\s.*\s$/.match?(with_space.source)
+          elsif missing_surrounding_space?(with_space)
             "Surrounding space missing for operator `#{operator.source}`."
-          elsif excess_leading_space?(type, operator, with_space) ||
+          elsif excess_leading_space?(type, operator, with_space, right_operand) ||
                 excess_trailing_space?(right_operand.source_range, with_space)
             "Operator `#{operator.source}` should be surrounded " \
               'by a single space.'
           end
         end
 
-        def excess_leading_space?(type, operator, with_space)
+        def missing_surrounding_space?(with_space)
+          return false if /\A\s.*\s\z/m.match?(with_space.source)
+
+          !with_space.source.start_with?(/\s/) || !line_continuation_after?(with_space)
+        end
+
+        def line_continuation_after?(range)
+          processed_source.buffer.source[range.end_pos, 2] == "\\\n"
+        end
+
+        def excess_leading_space?(type, operator, with_space, right_operand)
           return false unless allow_for_alignment?
           return false unless with_space.source.start_with?(EXCESSIVE_SPACE)
 
-          return !aligned_with_operator?(operator) unless grouped_alignment_type?(type)
+          return !aligned?(type, operator, right_operand) unless grouped_alignment_type?(type)
 
           token            = Token.new(operator, nil, operator.source)
           align_preceding  = aligned_with_preceding_equals_operator(token)
@@ -269,6 +279,23 @@ module RuboCop
           aligned_with_subsequent_equals_operator(token) != :yes
         end
 
+        def aligned?(type, operator, right_operand)
+          return true if aligned_with_operator?(operator)
+
+          type == :pair && aligned_with_another_hash_rocket?(right_operand)
+        end
+
+        def aligned_with_another_hash_rocket?(pair)
+          hash_rocket_columns(pair.parent)[pair.loc.operator.column] > 1
+        end
+
+        def hash_rocket_columns(hash_node)
+          @hash_rocket_columns ||= {}.compare_by_identity
+          @hash_rocket_columns[hash_node] ||= hash_node.pairs.select(&:hash_rocket?).map do |pair|
+            pair.loc.operator.column
+          end.tally
+        end
+
         def grouped_alignment_type?(type)
           type == :assignment || (type == :special_asgn && force_equal_sign_alignment?)
         end

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

@@ -49,8 +49,11 @@ module RuboCop
         MISSING_MSG = 'Space missing to the left of {.'
         DETECTED_MSG = 'Space detected to the left of {.'
 
+        # `Style/BlockDelimiters` decides whether to put a space before the `do`
+        # it writes by looking at the source before this cop removed the space,
+        # so the two corrections cannot be applied in the same pass.
         def self.autocorrect_incompatible_with
-          [Style::SymbolProc]
+          [Style::BlockDelimiters, Style::SymbolProc]
         end
 
         def on_block(node)
@@ -133,11 +136,23 @@ module RuboCop
 
         def autocorrect(corrector, range)
           case range.source
+          when /\n/ then remove_line_continuation(corrector, range)
           when /\s/ then corrector.remove(range)
           else           corrector.insert_before(range, ' ')
           end
         end
 
+        # When a heredoc body sits between the `\` and the brace, the newline before
+        # the brace ends the heredoc, and removing it would break the terminator.
+        def remove_line_continuation(corrector, range)
+          source = processed_source.buffer.source
+          return unless source[range.begin_pos - 1] == '\\'
+
+          begin_pos = range.begin_pos
+          begin_pos -= 1 while source[begin_pos - 1].match?(/[ \t\\]/)
+          corrector.remove(range_between(begin_pos, range.end_pos))
+        end
+
         def style_for_empty_braces
           case cop_config['EnforcedStyleForEmptyBraces']
           when 'space'    then :space

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

@@ -117,7 +117,7 @@ module RuboCop
           elsif style == :space
             SpaceCorrector.add_space(processed_source, corrector, left, right)
           else
-            compact_corrections(corrector, tokens, left, right)
+            compact_corrections(corrector, node, tokens, left, right)
           end
         end
 
@@ -178,6 +178,8 @@ module RuboCop
             space_offenses(node, left, nil, MSG, start_ok: start_ok, end_ok: true)
           end
 
+          return if closing_bracket_kept_apart?(node, tokens, left, right)
+
           if qualifies_for_compact?(tokens, right)
             compact_offense(node, right)
           elsif !multi_dimensional_array?(tokens, right)
@@ -212,13 +214,24 @@ module RuboCop
           end
         end
 
-        def compact_corrections(corrector, tokens, left, right)
+        # A closing bracket on its own line is only collapsed when the opening
+        # bracket ends up on the first element's line, so that the brackets
+        # stay symmetrical (see `Layout/MultilineArrayBraceLayout`).
+        def closing_bracket_kept_apart?(node, tokens, left, right)
+          end_has_own_line?(right) &&
+            !multi_dimensional_array?(tokens, left, side: :left) &&
+            !same_line?(left, node.children.first)
+        end
+
+        def compact_corrections(corrector, node, tokens, left, right)
           if multi_dimensional_array?(tokens, left, side: :left)
             compact(corrector, left, :right)
           elsif !left.space_after?
             corrector.insert_after(left.pos, ' ')
           end
 
+          return if closing_bracket_kept_apart?(node, tokens, left, right)
+
           if multi_dimensional_array?(tokens, right)
             compact(corrector, right, :left)
           elsif !right.space_before?

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

@@ -83,7 +83,7 @@ module RuboCop
         extend AutoCorrector
 
         def self.autocorrect_incompatible_with
-          [Style::BlockDelimiters]
+          [Layout::BlockAlignment, Style::BlockDelimiters]
         end
 
         def on_block(node)
@@ -153,7 +153,7 @@ module RuboCop
           else
             column = node.source_range.column
             return if multiline_block?(left_brace, right_brace) &&
-                      aligned_braces?(inner, right_brace, column)
+                      aligned_braces?(inner, right_brace, column, left_brace)
 
             space_inside_right_brace(inner, right_brace, column)
           end
@@ -163,14 +163,21 @@ module RuboCop
           left_brace.first_line != right_brace.first_line
         end
 
-        def aligned_braces?(inner, right_brace, column)
-          column == right_brace.column || column == inner_last_space_count(inner)
+        def aligned_braces?(inner, right_brace, column, left_brace)
+          column == right_brace.column ||
+            column == inner_last_space_count(inner) ||
+            aligned_with_opening_brace_line?(left_brace, right_brace)
         end
 
         def inner_last_space_count(inner)
           inner.split("\n").last.count(' ')
         end
 
+        def aligned_with_opening_brace_line?(left_brace, right_brace)
+          begins_its_line?(right_brace) &&
+            right_brace.column == left_brace.source_line[/\A\s*/].length
+        end
+
         def no_space_inside_left_brace(left_brace, args_delimiter)
           if pipe?(args_delimiter)
             if left_brace.end_pos == args_delimiter.begin_pos &&
@@ -197,9 +204,7 @@ module RuboCop
                       'Space between { and | detected.')
             end
           else
-            brace_with_space = range_with_surrounding_space(left_brace, side: :right)
-            space(brace_with_space.begin_pos + 1, brace_with_space.end_pos,
-                  'Space inside { detected.')
+            space_after_left_brace(left_brace)
           end
         end
 
@@ -207,6 +212,20 @@ module RuboCop
           args_delimiter&.is?('|')
         end
 
+        def space_after_left_brace(left_brace)
+          brace_with_space = range_with_surrounding_space(left_brace, side: :right)
+          return if brace_with_space.source.match?(/\R/)
+          return if comment_at?(brace_with_space.end_pos)
+
+          space(
+            brace_with_space.begin_pos + 1, brace_with_space.end_pos, 'Space inside { detected.'
+          )
+        end
+
+        def comment_at?(pos)
+          processed_source.comments.any? { |comment| comment.source_range.begin_pos == pos }
+        end
+
         def space_inside_right_brace(inner, right_brace, column)
           brace_with_space = range_with_surrounding_space(right_brace, side: :left)
           begin_pos = brace_with_space.begin_pos
@@ -216,7 +235,7 @@ module RuboCop
             begin_pos = end_pos - (right_brace.column - column)
           end
 
-          if inner.end_with?(']')
+          if closing_bracket_on_own_line?(inner)
             end_pos -= 1
             begin_pos = end_pos - (inner_last_space_count(inner) - column)
           end
@@ -224,6 +243,10 @@ module RuboCop
           space(begin_pos, end_pos, 'Space inside } detected.')
         end
 
+        def closing_bracket_on_own_line?(inner)
+          inner[/[^\n]*\z/].match?(/\A\s*\]\z/)
+        end
+
         def no_space(begin_pos, end_pos, msg)
           if style == :space
             offense(begin_pos, end_pos, msg)
@@ -241,7 +264,7 @@ module RuboCop
         end
 
         def offense(begin_pos, end_pos, msg, style_param = 'EnforcedStyle')
-          return if begin_pos > end_pos
+          return if begin_pos >= end_pos
 
           range = range_between(begin_pos, end_pos)
           add_offense(range, message: msg) do |corrector|

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

@@ -18,6 +18,7 @@ module RuboCop
       #   # good
       #   'a'..'z'
       class SpaceInsideRangeLiteral < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Space inside range literal.'
@@ -33,21 +34,38 @@ module RuboCop
         private
 
         def check(node)
-          expression = node.source
-          op = node.loc.operator.source
-          escaped_op = op.gsub('.', '\.')
-
-          # account for multiline range literals
-          expression.sub!(/#{escaped_op}\n\s*/, op)
-
-          return unless /(\s#{escaped_op})|(#{escaped_op}\s)/.match?(expression)
+          operator = node.loc.operator
+          spaces = [space_before(node, operator), space_after(node, operator)].compact
+          return if spaces.all? { |space| line_break_after_operator?(space, operator) }
 
           add_offense(node) do |corrector|
-            corrector.replace(
-              node, expression.sub(/\s+#{escaped_op}/, op).sub(/#{escaped_op}\s+/, op)
-            )
+            spaces.each do |space|
+              corrector.remove(space)
+            end
           end
         end
+
+        def space_before(node, operator)
+          return unless node.begin
+
+          whitespace_range(node.begin.source_range.end_pos, operator.begin_pos)
+        end
+
+        def space_after(node, operator)
+          return unless node.end
+
+          whitespace_range(operator.end_pos, node.end.source_range.begin_pos)
+        end
+
+        def line_break_after_operator?(space, operator)
+          space.begin_pos == operator.end_pos && space.source.start_with?("\n")
+        end
+
+        def whitespace_range(begin_pos, end_pos)
+          range = range_between(begin_pos, end_pos)
+
+          range if range.source.match?(/\A\s+\z/)
+        end
       end
     end
   end

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

@@ -108,14 +108,9 @@ module RuboCop
         end
 
         def left_ref_bracket(node, tokens)
-          current_token = tokens.reverse.find(&:left_ref_bracket?)
-          previous_token = previous_token(current_token)
+          bracket_pos = node.loc.selector.begin_pos
 
-          if node.method?(:[]=) || (previous_token && !previous_token.right_bracket?)
-            tokens.find(&:left_ref_bracket?)
-          else
-            current_token
-          end
+          tokens.find { |token| token.left_ref_bracket? && token.begin_pos == bracket_pos }
         end
 
         def closing_bracket(tokens, opening_bracket)
@@ -129,11 +124,6 @@ module RuboCop
           end
         end
 
-        def previous_token(current_token)
-          index = processed_source.tokens.index(current_token)
-          index.nil? || index.zero? ? nil : processed_source.tokens[index - 1]
-        end
-
         def empty_config
           cop_config['EnforcedStyleForEmptyBrackets']
         end

data/lib/rubocop/cop/lint/ambiguous_operator.rb

@@ -37,7 +37,7 @@ module RuboCop
                      'should be %<possible>s.'
 
         def self.autocorrect_incompatible_with
-          [Naming::BlockForwarding]
+          [Naming::BlockForwarding, Style::ArgumentsForwarding]
         end
 
         def on_new_investigation

data/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb

@@ -56,7 +56,8 @@ module RuboCop
         end
 
         def on_send(node)
-          return if node.parenthesized?
+          # `foo.*` is a regular method call, not a binary operator.
+          return if node.parenthesized? || node.loc.dot
 
           return unless (parent = node.parent)
           return unless operator?(parent)

data/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb

@@ -55,7 +55,8 @@ module RuboCop
           return node if first_argument_is_regexp?(node) || !node.parent
 
           if (node.parent.send_type? && node.receiver) ||
-             method_chain_to_regexp_receiver?(node, regexp_receiver)
+             method_chain_to_regexp_receiver?(node, regexp_receiver) ||
+             part_of_hash_argument?(node)
             node = find_offense_node(node.parent, regexp_receiver)
           end
 
@@ -72,6 +73,10 @@ module RuboCop
 
           parent.parent && parent_receiver.receiver == regexp_receiver
         end
+
+        def part_of_hash_argument?(node)
+          node.pair_type? || node.parent.pair_type? || (node.hash_type? && !node.braces?)
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/empty_conditional_body.rb

@@ -97,12 +97,14 @@ module RuboCop
         end
 
         def can_simplify_conditional?(node)
-          node.else_branch && node.loc.else.source == 'else'
+          !node.elsif? && node.else_branch && node.loc.else.source == 'else'
         end
 
         def remove_empty_branch(corrector, node)
           range = if empty_if_branch?(node) && else_branch?(node)
                     branch_range(node)
+                  elsif node.condition.last_line == node.loc.else.line
+                    node.source_range.with(end_pos: node.loc.else.begin_pos)
                   else
                     deletion_range(branch_range(node))
                   end

data/lib/rubocop/cop/lint/heredoc_method_call_position.rb

@@ -34,6 +34,10 @@ module RuboCop
 
         MSG = 'Put a method call with a HEREDOC receiver on the same line as the HEREDOC opening.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           heredoc = heredoc_node_descendent_receiver(node)
           return unless heredoc

data/lib/rubocop/cop/lint/interpolation_check.rb

@@ -41,26 +41,22 @@ module RuboCop
 
         private
 
-        # rubocop:disable-next Metrics/CyclomaticComplexity
         def check(node)
           return if node.parent&.regexp_type?
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
-          return unless node.loc.begin && node.loc.end
+          return unless single_quoted?(node)
           return unless valid_syntax?(node)
 
           add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
-        def autocorrect(corrector, node)
-          starting_token, ending_token = if node.source.include?('"')
-                                           ['%{', '}']
-                                         else
-                                           ['"', '"']
-                                         end
+        def single_quoted?(node)
+          node.loc.begin&.is?("'") && node.loc.end
+        end
 
-          corrector.replace(node.loc.begin, starting_token)
-          corrector.replace(node.loc.end, ending_token)
+        def autocorrect(corrector, node)
+          corrector.replace(node, interpolated_source(node))
         end
 
         def heredoc?(node)
@@ -68,15 +64,22 @@ module RuboCop
         end
 
         def valid_syntax?(node)
-          double_quoted_string = if node.source.include?('"')
-                                   node.source.sub(/\A'/, '%{').sub(/'\z/, '}')
-                                 else
-                                   node.source.gsub(/\A'|'\z/, '"')
-                                 end
-
-          processed_source = parse(double_quoted_string)
+          processed_source = parse(interpolated_source(node))
           processed_source.valid_syntax? && processed_source.ast.dstr_type?
         end
+
+        def interpolated_source(node)
+          content = node.source[1...-1]
+          return %("#{content}") unless content.include?('"')
+          return "%{#{content}}" unless continued_string_part?(node)
+
+          %("#{content.gsub(/\\.|"/) { |m| m == '"' ? '\"' : m }}")
+        end
+
+        # A percent literal right after another string part is parsed as the `%` operator.
+        def continued_string_part?(node)
+          node.parent&.dstr_type? && node.left_sibling
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/literal_as_condition.rb

@@ -98,6 +98,8 @@ module RuboCop
             end
           elsif node.condition.falsey_literal?
             add_offense(node.condition) do |corrector|
+              next if orphans_loop_control_keyword?(node)
+
               corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
             end
           end
@@ -127,6 +129,8 @@ module RuboCop
             end
           elsif node.condition.truthy_literal?
             add_offense(node.condition) do |corrector|
+              next if orphans_loop_control_keyword?(node)
+
               corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
             end
           end
@@ -175,6 +179,15 @@ module RuboCop
 
         private
 
+        # Unwrapping the body of a loop that runs once would leave a `break`,
+        # `next` or `redo` that belongs to it outside of any loop.
+        def orphans_loop_control_keyword?(node)
+          node.body.each_node(:next, :break, :redo).any? do |control|
+            inner = control.each_ancestor.take_while { |ancestor| !ancestor.equal?(node) }
+            inner.none? { |ancestor| ancestor.any_block_type? || ancestor.loop_keyword? }
+          end
+        end
+
         def void_value_expression?(node)
           node = node.children.last while node&.begin_type?
 
@@ -273,6 +286,8 @@ module RuboCop
                        "#{node.else_branch.source.sub('elsif', 'if')}\nend"
                      elsif node.else? || node.ternary?
                        node.else_branch.source
+                     elsif node.value_used?
+                       'nil'
                      else
                        '' # Equivalent to removing the node
                      end

data/lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -24,30 +24,16 @@ module RuboCop
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
-        # rubocop:disable-next Metrics/AbcSize
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
           return unless offending?(final_node)
-
-          # %W and %I split the content into words before expansion
-          # treating each interpolation as a word component, so
-          # interpolation should not be removed if the expanded value
-          # contains a space character.
-          expanded_value = autocorrected_value(final_node)
-          expanded_value = handle_special_regexp_chars(begin_node, expanded_value)
-
-          return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(expanded_value)
+          return unless (expanded_value = correctable_value(begin_node, final_node))
 
           add_offense(final_node) do |corrector|
             next if final_node.dstr_type? # nested, fixed in next iteration
+            next if follows_literal_interpolation?(begin_node)
 
-            replacement = if final_node.str_type? && !final_node.value.valid_encoding?
-                            final_node.source.delete_prefix('"').delete_suffix('"')
-                          else
-                            expanded_value
-                          end
-
-            corrector.replace(final_node.parent, replacement)
+            corrector.replace(final_node.parent, replacement(final_node, expanded_value))
           end
         end
 
@@ -73,6 +59,22 @@ module RuboCop
           node.array_type? && grandparent.regexp_type?
         end
 
+        def correctable_value(begin_node, final_node)
+          value = autocorrected_value(final_node)
+          value = handle_special_regexp_chars(begin_node, value)
+          return if starts_interpolation_after_hash_sign?(begin_node, value)
+
+          value = escape_trailing_hash_sign(begin_node, value)
+
+          # %W and %I split the content into words before expansion
+          # treating each interpolation as a word component, so
+          # interpolation should not be removed if the expanded value
+          # contains a space character.
+          return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(value)
+
+          value
+        end
+
         # rubocop:disable-next Metrics/MethodLength, Metrics/CyclomaticComplexity
         def autocorrected_value(node)
           case node.type
@@ -116,6 +118,17 @@ module RuboCop
           end
         end
 
+        def starts_interpolation_after_hash_sign?(begin_node, value)
+          source = processed_source.buffer.source
+          range = begin_node.source_range
+          # Removing an empty value puts the `#` right before what follows the interpolation.
+          following = "#{value}#{source[range.end_pos]}"
+          return false unless following.start_with?('{', '@', '$')
+          return false unless source[range.begin_pos - 1] == '#'
+
+          unescaped_hash_sign?(source[0...range.begin_pos])
+        end
+
         def autocorrected_value_for_string(node)
           return node.source.delete_prefix('"').delete_suffix('"') unless node.value.valid_encoding?
 
@@ -180,7 +193,9 @@ module RuboCop
         end
 
         def space_literal?(node)
-          node.str_type? && node.value.valid_encoding? && node.value.blank?
+          # `String#blank?` misses Unicode spaces such as U+3000 that
+          # `Layout/TrailingWhitespace` treats as trailing whitespace.
+          node.str_type? && node.value.valid_encoding? && node.value.match?(/\A[[:space:]]*\z/)
         end
 
         def ends_heredoc_line?(node)
@@ -188,7 +203,8 @@ module RuboCop
           return false unless grandparent&.dstr_type? && grandparent.heredoc?
 
           line = processed_source.lines[node.last_line - 1]
-          line.size == node.loc.last_column + 1
+
+          line.size == node.parent.source_range.last_column
         end
 
         def in_array_percent_literal?(node)
@@ -198,6 +214,34 @@ module RuboCop
           grandparent = parent.parent
           grandparent&.array_type? && grandparent.percent_literal?
         end
+
+        def escape_trailing_hash_sign(begin_node, value)
+          following = processed_source.buffer.source[begin_node.source_range.end_pos]
+          return value unless %w[{ @ $].include?(following) && unescaped_hash_sign?(value)
+
+          "#{value.delete_suffix('#')}\\#"
+        end
+
+        def unescaped_hash_sign?(text)
+          text.end_with?('#') && text.delete_suffix('#')[/\\*\z/].length.even?
+        end
+
+        # Each interpolation is checked against the original source, so correcting it in the
+        # same pass as a preceding one that leaves a `#` (or nothing) could join that `#` and
+        # a `{` from this one. It's left for the next iteration instead.
+        def follows_literal_interpolation?(begin_node)
+          previous = begin_node.left_sibling
+          return false unless previous&.begin_type? && offending?(previous.children.last)
+
+          value = correctable_value(previous, previous.children.last)
+          value && (value.empty? || value.end_with?('#'))
+        end
+
+        def replacement(node, expanded_value)
+          return expanded_value unless node.str_type? && !node.value.valid_encoding?
+
+          node.source.delete_prefix('"').delete_suffix('"')
+        end
       end
     end
   end