rubocop 1.41.1 → 1.57.1

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

@@ -48,11 +48,15 @@ module RuboCop
 
         MSG = 'Redundant line break detected.'
 
+        def on_lvasgn(node)
+          super unless end_with_percent_blank_string?(processed_source)
+        end
+
         def on_send(node)
           # Include "the whole expression".
-          node = node.parent while convertible_block?(node) ||
-                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode) ||
-                                   node.parent&.send_type?
+          node = node.parent while node.parent&.send_type? ||
+                                   convertible_block?(node) ||
+                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode)
 
           return unless offense?(node) && !part_of_ignored_node?(node)
 
@@ -61,6 +65,10 @@ module RuboCop
 
         private
 
+        def end_with_percent_blank_string?(processed_source)
+          processed_source.buffer.source.end_with?("%\n\n")
+        end
+
         def check_assignment(node, _rhs)
           return unless offense?(node)
 
@@ -69,15 +77,14 @@ module RuboCop
 
         def register_offense(node)
           add_offense(node) do |corrector|
-            corrector.replace(node.source_range, to_single_line(node.source).strip)
+            corrector.replace(node, to_single_line(node.source).strip)
           end
           ignore_node(node)
         end
 
         def offense?(node)
-          return false if configured_to_not_be_inspected?(node)
-
-          node.multiline? && !too_long?(node) && suitable_as_single_line?(node)
+          node.multiline? && !too_long?(node) && suitable_as_single_line?(node) &&
+            !configured_to_not_be_inspected?(node)
         end
 
         def configured_to_not_be_inspected?(node)
@@ -99,9 +106,9 @@ module RuboCop
 
         def suitable_as_single_line?(node)
           !comment_within?(node) &&
-            node.each_descendant(:if, :case, :kwbegin, :def).none? &&
-            node.each_descendant(:dstr, :str).none?(&:heredoc?) &&
-            node.each_descendant(:begin).none? { |b| !b.single_line? }
+            node.each_descendant(:if, :case, :kwbegin, :def, :defs).none? &&
+            node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
+            node.each_descendant(:begin, :sym).none? { |b| !b.single_line? }
         end
 
         def convertible_block?(node)
@@ -111,7 +118,9 @@ module RuboCop
         end
 
         def comment_within?(node)
-          processed_source.comments.map(&:loc).map(&:line).any? do |comment_line_number|
+          comment_line_numbers = processed_source.comments.map { |comment| comment.loc.line }
+
+          comment_line_numbers.any? do |comment_line_number|
             comment_line_number >= node.first_line && comment_line_number <= node.last_line
           end
         end

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

@@ -102,7 +102,7 @@ module RuboCop
               node.loc.name
             when :masgn
               mlhs_node, = *node
-              mlhs_node.loc.expression
+              mlhs_node.source_range
             else
               # It is a wrapper with access modifier.
               node.child_nodes.first.loc.name
@@ -196,7 +196,7 @@ module RuboCop
           if begin_end_alignment_style == 'start_of_line'
             start_line_range(alignment_node)
           else
-            alignment_node.loc.expression
+            alignment_node.source_range
           end
         end
 

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

@@ -24,7 +24,15 @@ module RuboCop
         end
 
         def kind(token)
-          'comma' if token.comma?
+          'comma' if token.comma? && !before_semicolon?(token)
+        end
+
+        private
+
+        def before_semicolon?(token)
+          tokens = processed_source.tokens
+
+          tokens[tokens.index(token) + 1].semicolon?
         end
       end
     end

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

@@ -31,7 +31,7 @@ module RuboCop
         private
 
         def whitespace_after_operator?(node)
-          node.receiver.loc.column - node.loc.column > 1
+          node.receiver.source_range.begin_pos - node.source_range.begin_pos > 1
         end
       end
     end

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

@@ -241,7 +241,7 @@ module RuboCop
         end
 
         def accept_namespace_operator?(range)
-          ACCEPT_NAMESPACE_OPERATOR == range.source
+          range.source == ACCEPT_NAMESPACE_OPERATOR
         end
 
         def safe_navigation_call?(range, pos)
@@ -256,7 +256,7 @@ module RuboCop
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them
           node.each_ancestor do |ancestor|
-            return true if ancestor.and_type? || ancestor.or_type?
+            return true if ancestor.and_type? || ancestor.or_type? || ancestor.range_type?
             return false unless ancestor.send_type?
             return true if ancestor.operator_method?
           end

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

@@ -19,7 +19,7 @@ module RuboCop
       #   foo &. bar
       #   foo &. bar&. buzz
       #   RuboCop:: Cop
-      #   RuboCop:: Cop:: Cop
+      #   RuboCop:: Cop:: Base
       #   :: RuboCop::Cop
       #
       #   # good
@@ -31,7 +31,7 @@ module RuboCop
       #   foo&.bar
       #   foo&.bar&.buzz
       #   RuboCop::Cop
-      #   RuboCop::Cop::Cop
+      #   RuboCop::Cop::Base
       #   ::RuboCop::Cop
       #
       class SpaceAroundMethodCallOperator < Base

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

@@ -153,7 +153,9 @@ module RuboCop
         private
 
         def regular_operator?(send_node)
-          !send_node.unary_operation? && !send_node.dot? && operator_with_regular_syntax?(send_node)
+          return false if send_node.unary_operation? || send_node.dot? || send_node.double_colon?
+
+          operator_with_regular_syntax?(send_node)
         end
 
         def operator_with_regular_syntax?(send_node)
@@ -177,7 +179,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, range)
-          if /\*\*/.match?(range.source) && !space_around_exponent_operator?
+          if range.source.include?('**') && !space_around_exponent_operator?
             corrector.replace(range, '**')
           elsif range.source.end_with?("\n")
             corrector.replace(range, " #{range.source.strip}\n")

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

@@ -34,6 +34,7 @@ module RuboCop
 
         def on_send(node)
           return unless regular_method_call_with_arguments?(node)
+          return if node.parenthesized?
 
           first_arg = node.first_argument.source_range
           first_arg_with_space = range_with_surrounding_space(first_arg, side: :left)
@@ -52,7 +53,6 @@ module RuboCop
         end
 
         def expect_params_after_method_name?(node)
-          return false if node.parenthesized?
           return true if no_space_between_method_name_and_first_argument?(node)
 
           first_arg = node.first_argument

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

@@ -64,8 +64,8 @@ module RuboCop
 
         def range_of_offense(node)
           range_between(
-            node.parent.loc.expression.begin_pos,
-            node.parent.arguments.loc.expression.end_pos
+            node.parent.source_range.begin_pos,
+            node.parent.arguments.source_range.end_pos
           )
         end
 

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

@@ -78,8 +78,11 @@ module RuboCop
         def on_array(node)
           return unless node.square_brackets?
 
-          left, right = array_brackets(node)
-          return empty_offenses(node, left, right, EMPTY_MSG) if empty_brackets?(left, right)
+          tokens, left, right = array_brackets(node)
+
+          if empty_brackets?(left, right, tokens: tokens)
+            return empty_offenses(node, left, right, EMPTY_MSG)
+          end
 
           start_ok = next_to_newline?(node, left)
           end_ok = node.single_line? ? false : end_has_own_line?(right)
@@ -90,9 +93,9 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          left, right = array_brackets(node)
+          tokens, left, right = array_brackets(node)
 
-          if empty_brackets?(left, right)
+          if empty_brackets?(left, right, tokens: tokens)
             SpaceCorrector.empty_corrections(processed_source, corrector, empty_config, left, right)
           elsif style == :no_space
             SpaceCorrector.remove_space(processed_source, corrector, left, right)
@@ -104,15 +107,12 @@ module RuboCop
         end
 
         def array_brackets(node)
-          [left_array_bracket(node), right_array_bracket(node)]
-        end
+          tokens = processed_source.tokens_within(node)
 
-        def left_array_bracket(node)
-          processed_source.tokens_within(node).find(&:left_array_bracket?)
-        end
+          left = tokens.find(&:left_array_bracket?)
+          right = tokens.reverse_each.find(&:right_bracket?)
 
-        def right_array_bracket(node)
-          processed_source.tokens_within(node).reverse.find(&:right_bracket?)
+          [tokens, left, right]
         end
 
         def empty_config
@@ -178,8 +178,6 @@ module RuboCop
         def multi_dimensional_array?(node, token, side: :right)
           offset = side == :right ? -1 : +1
           i = index_for(node, token) + offset
-          # TODO: change this type check once
-          # https://github.com/rubocop/rubocop-ast/pull/240 is merged
           i += offset while processed_source.tokens_within(node)[i].new_line?
           if side == :right
             processed_source.tokens_within(node)[i].right_bracket?

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

@@ -146,7 +146,7 @@ module RuboCop
           if single_line && /\S$/.match?(inner)
             no_space(right_brace.begin_pos, right_brace.end_pos, 'Space missing inside }.')
           else
-            column = node.loc.expression.column
+            column = node.source_range.column
             return if multiline_block?(left_brace, right_brace) &&
                       aligned_braces?(inner, right_brace, column)
 
@@ -236,6 +236,8 @@ module RuboCop
         end
 
         def offense(begin_pos, end_pos, msg, style_param = 'EnforcedStyle')
+          return if begin_pos > end_pos
+
           range = range_between(begin_pos, end_pos)
           add_offense(range, message: msg) do |corrector|
             case range.source

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

@@ -91,7 +91,7 @@ module RuboCop
             if !left_parens?(token1, token2) && !right_parens?(token1, token2)
               correct_missing_space(token1, token2)
             else
-              correct_extaneus_space_between_consecutive_parens(token1, token2)
+              correct_extraneous_space_between_consecutive_parens(token1, token2)
             end
           end
         end
@@ -112,7 +112,7 @@ module RuboCop
           end
         end
 
-        def correct_extaneus_space_between_consecutive_parens(token1, token2)
+        def correct_extraneous_space_between_consecutive_parens(token1, token2)
           return if range_between(token1.end_pos, token2.begin_pos).source != ' '
 
           range = range_between(token1.end_pos, token2.begin_pos)
@@ -168,7 +168,7 @@ module RuboCop
           # follows, and that the rules for space inside don't apply.
           return true if token2.comment?
 
-          return true unless same_line?(token1, token2) && !token1.space_after?
+          !same_line?(token1, token2) || token1.space_after?
         end
       end
     end

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

@@ -83,7 +83,7 @@ module RuboCop
         end
 
         def body_range(node)
-          node.location.expression.with(
+          node.source_range.with(
             begin_pos: node.location.begin.end_pos,
             end_pos: node.location.end.begin_pos
           )

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

@@ -35,7 +35,7 @@ module RuboCop
         def check(node)
           expression = node.source
           op = node.loc.operator.source
-          escaped_op = op.gsub(/\./, '\.')
+          escaped_op = op.gsub('.', '\.')
 
           # account for multiline range literals
           expression.sub!(/#{escaped_op}\n\s*/, op)

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

@@ -74,7 +74,7 @@ module RuboCop
 
           right_token = closing_bracket(tokens, left_token)
 
-          if empty_brackets?(left_token, right_token)
+          if empty_brackets?(left_token, right_token, tokens: tokens)
             return empty_offenses(node, left_token, right_token, EMPTY_MSG)
           end
 
@@ -90,9 +90,9 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          left, right = reference_brackets(node)
+          tokens, left, right = reference_brackets(node)
 
-          if empty_brackets?(left, right)
+          if empty_brackets?(left, right, tokens: tokens)
             SpaceCorrector.empty_corrections(processed_source, corrector, empty_config, left, right)
           elsif style == :no_space
             SpaceCorrector.remove_space(processed_source, corrector, left, right)
@@ -104,7 +104,7 @@ module RuboCop
         def reference_brackets(node)
           tokens = processed_source.tokens_within(node)
           left = left_ref_bracket(node, tokens)
-          [left, closing_bracket(tokens, left)]
+          [tokens, left, closing_bracket(tokens, left)]
         end
 
         def left_ref_bracket(node, tokens)

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

@@ -31,13 +31,14 @@ module RuboCop
         def on_interpolation(begin_node)
           return if begin_node.multiline?
 
-          delims = delimiters(begin_node)
-          return if empty_brackets?(*delims)
+          tokens = processed_source.tokens_within(begin_node)
+          left, right = delimiters(begin_node)
+          return if empty_brackets?(left, right, tokens: tokens)
 
           if style == :no_space
-            no_space_offenses(begin_node, *delims, NO_SPACE_MSG)
+            no_space_offenses(begin_node, left, right, NO_SPACE_MSG)
           else
-            space_offenses(begin_node, *delims, SPACE_MSG)
+            space_offenses(begin_node, left, right, SPACE_MSG)
           end
         end
 

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

@@ -51,6 +51,7 @@ module RuboCop
           # there could be good reasons why it needs to end with a certain
           # number of newlines.
           return if ends_in_end?(processed_source)
+          return if end_with_percent_blank_string?(processed_source)
 
           whitespace_at_end = buffer.source[/\s*\Z/]
           blank_lines = whitespace_at_end.count("\n") - 1
@@ -86,6 +87,10 @@ module RuboCop
           extra&.strip&.start_with?('__END__')
         end
 
+        def end_with_percent_blank_string?(processed_source)
+          processed_source.buffer.source.end_with?("%\n\n")
+        end
+
         def message(wanted_blank_lines, blank_lines)
           case blank_lines
           when -1

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

@@ -47,7 +47,6 @@ module RuboCop
         MSG = 'Trailing whitespace detected.'
 
         def on_new_investigation
-          @heredocs = extract_heredocs(processed_source.ast)
           processed_source.lines.each_with_index do |line, index|
             next unless line.end_with?(' ', "\t")
 
@@ -94,7 +93,7 @@ module RuboCop
         end
 
         def static?(heredoc)
-          heredoc.loc.expression.source.end_with? "'"
+          heredoc.source.end_with? "'"
         end
 
         def skip_heredoc?
@@ -102,10 +101,14 @@ module RuboCop
         end
 
         def find_heredoc(line_number)
-          @heredocs.each { |node, r| return node if r.include?(line_number) }
+          heredocs.each { |node, r| return node if r.include?(line_number) }
           nil
         end
 
+        def heredocs
+          @heredocs ||= extract_heredocs(processed_source.ast)
+        end
+
         def extract_heredocs(ast)
           return [] unless ast
 

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

@@ -52,6 +52,8 @@ module RuboCop
       #   expect { do_something }.to not_change { object.attribute }
       #
       class AmbiguousBlockAssociation < Base
+        extend AutoCorrector
+
         include AllowedMethods
         include AllowedPattern
 
@@ -68,7 +70,9 @@ module RuboCop
 
           message = message(node)
 
-          add_offense(node, message: message)
+          add_offense(node, message: message) do |corrector|
+            wrap_in_parentheses(corrector, node)
+          end
         end
         alias on_csend on_send
 
@@ -89,6 +93,14 @@ module RuboCop
 
           format(MSG, param: block_param.source, method: block_param.send_node.source)
         end
+
+        def wrap_in_parentheses(corrector, node)
+          range = node.loc.selector.end.join(node.first_argument.source_range.begin)
+
+          corrector.remove(range)
+          corrector.insert_before(range, '(')
+          corrector.insert_after(node.last_argument, ')')
+        end
       end
     end
   end

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

@@ -38,6 +38,10 @@ module RuboCop
                      'a whitespace to the right of the `%<operator>s` if it ' \
                      'should be %<possible>s.'
 
+        def self.autocorrect_incompatible_with
+          [Naming::BlockForwarding]
+        end
+
         def on_new_investigation
           processed_source.diagnostics.each do |diagnostic|
             next unless diagnostic.reason == :ambiguous_prefix

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

@@ -68,7 +68,7 @@ module RuboCop
         PATTERN
 
         def on_const(node)
-          return if !unqualified_const?(node) || node.parent&.defined_module
+          return if !unqualified_const?(node) || node.parent&.defined_module || node.loc.nil?
 
           add_offense(node)
         end

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

@@ -68,7 +68,7 @@ module RuboCop
         MSG = 'Remove debugger entry point `%<source>s`.'
 
         def on_send(node)
-          return unless debugger_method?(node)
+          return if !debugger_method?(node) || assumed_usage_context?(node)
 
           add_offense(node)
         end
@@ -82,44 +82,41 @@ module RuboCop
         def debugger_methods
           @debugger_methods ||= begin
             config = cop_config.fetch('DebuggerMethods', [])
-            values = config.is_a?(Array) ? config : config.values.flatten
-            values.map do |v|
-              next unless v
-
-              *receiver, method_name = v.split('.')
-              {
-                receiver: receiver.empty? ? nil : receiver.map(&:to_sym),
-                method_name: method_name.to_sym
-              }
-            end.compact
+            config.is_a?(Array) ? config : config.values.flatten
           end
         end
 
         def debugger_method?(send_node)
-          method_name = send_node.method_name
+          return false if send_node.parent&.send_type? && send_node.parent.receiver == send_node
+
+          debugger_methods.include?(chained_method_name(send_node))
+        end
 
-          debugger_methods.any? do |method|
-            next unless method[:method_name] == method_name
+        def assumed_usage_context?(node)
+          # Basically, debugger methods are not used as a method argument without arguments.
+          return false unless node.arguments.empty? && node.each_ancestor(:send, :csend).any?
+          return true if assumed_argument?(node)
 
-            if method[:receiver].nil?
-              send_node.receiver.nil?
-            else
-              method[:receiver] == receiver_chain(send_node)
-            end
+          node.each_ancestor.none? do |ancestor|
+            ancestor.block_type? || ancestor.numblock_type? || ancestor.lambda_or_proc?
           end
         end
 
-        def receiver_chain(send_node)
-          receivers = []
+        def chained_method_name(send_node)
+          chained_method_name = send_node.method_name.to_s
           receiver = send_node.receiver
-
           while receiver
-            name = receiver.send_type? ? receiver.method_name : receiver.const_name&.to_sym
-            receivers.unshift(name)
+            name = receiver.send_type? ? receiver.method_name : receiver.const_name
+            chained_method_name = "#{name}.#{chained_method_name}"
             receiver = receiver.receiver
           end
+          chained_method_name
+        end
+
+        def assumed_argument?(node)
+          parent = node.parent
 
-          receivers
+          parent.call_type? || parent.literal? || parent.pair_type?
         end
       end
     end