rubocop 1.30.1 → 1.64.0

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

@@ -8,14 +8,31 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #   %i( foo bar baz )
+      #
       #   # good
       #   %i(foo bar baz)
       #
       #   # bad
       #   %w( foo bar baz )
       #
+      #   # good
+      #   %w(foo bar baz)
+      #
       #   # bad
       #   %x(  ls -l )
+      #
+      #   # good
+      #   %x(ls -l)
+      #
+      #   # bad
+      #   %w( )
+      #   %w(
+      #   )
+      #
+      #   # good
+      #   %w()
       class SpaceInsidePercentLiteralDelimiters < Base
         include MatchRange
         include PercentLiteral
@@ -34,11 +51,21 @@ module RuboCop
         end
 
         def on_percent_literal(node)
+          add_offenses_for_blank_spaces(node)
           add_offenses_for_unnecessary_spaces(node)
         end
 
         private
 
+        def add_offenses_for_blank_spaces(node)
+          range = body_range(node)
+          return if range.source.empty? || !range.source.strip.empty?
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
         def add_offenses_for_unnecessary_spaces(node)
           return unless node.single_line?
 
@@ -54,6 +81,13 @@ module RuboCop
             each_match_range(contents_range(node), regex, &blk)
           end
         end
+
+        def body_range(node)
+          node.source_range.with(
+            begin_pos: node.location.begin.end_pos,
+            end_pos: node.location.end.begin_pos
+          )
+        end
       end
     end
   end

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

@@ -38,6 +38,8 @@ module RuboCop
       #   # bad
       #   foo[ ]
       #   foo[     ]
+      #   foo[
+      #   ]
       #
       #   # good
       #   foo[]
@@ -49,6 +51,8 @@ module RuboCop
       #   # bad
       #   foo[]
       #   foo[    ]
+      #   foo[
+      #   ]
       #
       #   # good
       #   foo[ ]
@@ -64,18 +68,18 @@ module RuboCop
         RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
-          return if node.multiline?
-
           tokens = processed_source.tokens_within(node)
           left_token = left_ref_bracket(node, tokens)
           return unless left_token
 
           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
 
+          return if node.multiline?
+
           if style == :no_space
             no_space_offenses(node, left_token, right_token, MSG)
           else
@@ -86,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)
@@ -100,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
@@ -79,13 +80,17 @@ module RuboCop
         def ends_in_end?(processed_source)
           buffer = processed_source.buffer
 
-          return true if buffer.source.strip.start_with?('__END__')
+          return true if buffer.source.match?(/\s*__END__/)
           return false if processed_source.tokens.empty?
 
           extra = buffer.source[processed_source.tokens.last.end_pos..]
           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")
 
@@ -89,12 +88,12 @@ module RuboCop
         end
 
         def whitespace_only?(range)
-          source = range_with_surrounding_space(range: range).source
+          source = range_with_surrounding_space(range).source
           source.start_with?("\n") && source.end_with?("\n")
         end
 
         def static?(heredoc)
-          heredoc.loc.expression.source.end_with? "'"
+          heredoc.source.end_with? "'"
         end
 
         def skip_heredoc?
@@ -102,17 +101,25 @@ 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
 
-          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
+          heredocs = []
+          ast.each_node(:str, :dstr, :xstr) do |node|
+            next unless node.heredoc?
+
             body = node.location.heredoc_body
-            [node, body.first_line...body.last_line]
+            heredocs << [node, body.first_line...body.last_line]
           end
+          heredocs
         end
 
         def offense_range(lineno, line)

data/lib/rubocop/cop/legacy/corrections_proxy.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Legacy
       # Legacy support for Corrector#corrections
-      # See https://docs.rubocop.org/rubocop/cop_api_v1_changelog.html
+      # See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
       class CorrectionsProxy
         def initialize(corrector)
           @corrector = corrector

data/lib/rubocop/cop/legacy/corrector.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Legacy
       # Legacy Corrector for v0 API support.
-      # See https://docs.rubocop.org/rubocop/cop_api_v1_changelog.html
+      # See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
       class Corrector < RuboCop::Cop::Corrector
         # Support legacy second argument
         def initialize(source, corr = [])

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

@@ -6,7 +6,8 @@ module RuboCop
       # Checks for ambiguous block association with method
       # when param passed without parentheses.
       #
-      # This cop can customize ignored methods with `IgnoredMethods`.
+      # This cop can customize allowed methods with `AllowedMethods`.
+      # By default, there are no methods to allowed.
       #
       # @example
       #
@@ -29,12 +30,32 @@ module RuboCop
       #   # Lambda arguments require no disambiguation
       #   foo = ->(bar) { bar.baz }
       #
-      # @example IgnoredMethods: [change]
+      # @example AllowedMethods: [] (default)
+      #
+      #   # bad
+      #   expect { do_something }.to change { object.attribute }
+      #
+      # @example AllowedMethods: [change]
       #
       #   # good
       #   expect { do_something }.to change { object.attribute }
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   expect { do_something }.to change { object.attribute }
+      #
+      # @example AllowedPatterns: ['change']
+      #
+      #   # good
+      #   expect { do_something }.to change { object.attribute }
+      #   expect { do_something }.to not_change { object.attribute }
+      #
       class AmbiguousBlockAssociation < Base
-        include IgnoredMethods
+        extend AutoCorrector
+
+        include AllowedMethods
+        include AllowedPattern
 
         MSG = 'Parenthesize the param `%<param>s` to make sure that the ' \
               'block will be associated with the `%<method>s` method ' \
@@ -44,12 +65,14 @@ module RuboCop
           return unless node.arguments?
 
           return unless ambiguous_block_association?(node)
-          return if node.parenthesized? || node.last_argument.lambda? || node.last_argument.proc? ||
-                    allowed_method?(node)
+          return if node.parenthesized? || node.last_argument.lambda_or_proc? ||
+                    allowed_method_pattern?(node)
 
           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
 
@@ -59,9 +82,10 @@ module RuboCop
           send_node.last_argument.block_type? && !send_node.last_argument.send_node.arguments?
         end
 
-        def allowed_method?(node)
+        def allowed_method_pattern?(node)
           node.assignment? || node.operator_method? || node.method?(:[]) ||
-            ignored_method?(node.last_argument.send_node.source)
+            allowed_method?(node.last_argument.method_name) ||
+            matches_allowed_pattern?(node.last_argument.send_node.source)
         end
 
         def message(send_node)
@@ -69,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/assignment_in_condition.rb

@@ -11,30 +11,36 @@ module RuboCop
       # an assignment to indicate "I know I'm using an assignment
       # as a condition. It's not a mistake."
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because it assumes that
+      #   the author meant to use an assignment result as a condition.
+      #
       # @example
       #   # bad
-      #   if some_var = true
+      #   if some_var = value
       #     do_something
       #   end
       #
       #   # good
-      #   if some_var == true
+      #   if some_var == value
       #     do_something
       #   end
       #
       # @example AllowSafeAssignment: true (default)
       #   # good
-      #   if (some_var = true)
+      #   if (some_var = value)
       #     do_something
       #   end
       #
       # @example AllowSafeAssignment: false
       #   # bad
-      #   if (some_var = true)
+      #   if (some_var = value)
       #     do_something
       #   end
       #
       class AssignmentInCondition < Base
+        extend AutoCorrector
+
         include SafeAssignment
 
         MSG_WITH_SAFE_ASSIGNMENT_ALLOWED =
@@ -44,7 +50,7 @@ module RuboCop
         MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED =
           'Use `==` if you meant to do a comparison or move the assignment ' \
           'up out of the condition.'
-        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send].freeze
+        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send, :csend].freeze
 
         def on_if(node)
           return if node.condition.block_type?
@@ -53,7 +59,11 @@ module RuboCop
             next :skip_children if skip_children?(asgn_node)
             next if allowed_construct?(asgn_node)
 
-            add_offense(asgn_node.loc.operator)
+            add_offense(asgn_node.loc.operator) do |corrector|
+              next unless safe_assignment_allowed?
+
+              corrector.wrap(asgn_node, '(', ')')
+            end
           end
         end
         alias on_while on_if
@@ -78,7 +88,7 @@ module RuboCop
         end
 
         def skip_children?(asgn_node)
-          (asgn_node.send_type? && !asgn_node.assignment_method?) ||
+          (asgn_node.call_type? && !asgn_node.assignment_method?) ||
             empty_condition?(asgn_node) ||
             (safe_assignment_allowed? && safe_assignment?(asgn_node))
         end

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

@@ -6,10 +6,10 @@ module RuboCop
       # Checks for places where binary operator has identical operands.
       #
       # It covers arithmetic operators: `-`, `/`, `%`;
-      # comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, `<=`;
+      # comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, ``<=``;
       # bitwise operators: `|`, `^`, `&`;
       # boolean operators: `&&`, `||`
-      # and "spaceship" operator - `<=>`.
+      # and "spaceship" operator - ``<=>``.
       #
       # Simple arithmetic operations are allowed by this cop: `+`, `*`, `**`, `<<` and `>>`.
       # Although these can be rewritten in a different way, it should not be necessary to

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for overwriting an exception with an exception result by use ``rescue =>``.
+      #
+      # You intended to write as `rescue StandardError`.
+      # However, you have written `rescue => StandardError`.
+      # In that case, the result of `rescue` will overwrite `StandardError`.
+      #
+      # @example
+      #
+      #   # bad
+      #   begin
+      #     something
+      #   rescue => StandardError
+      #   end
+      #
+      #   # good
+      #   begin
+      #     something
+      #   rescue StandardError
+      #   end
+      #
+      class ConstantOverwrittenInRescue < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = '`%<constant>s` is overwritten by `rescue =>`.'
+
+        # @!method overwritten_constant(node)
+        def_node_matcher :overwritten_constant, <<~PATTERN
+          (resbody nil? (casgn nil? $_) nil?)
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [Naming::RescuedExceptionsVariableName, Style::RescueStandardError]
+        end
+
+        def on_resbody(node)
+          return unless (constant = overwritten_constant(node))
+
+          add_offense(node.loc.assoc, message: format(MSG, constant: constant)) do |corrector|
+            corrector.remove(range_between(node.loc.keyword.end_pos, node.loc.assoc.end_pos))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,6 +16,10 @@ module RuboCop
       # using the same name a namespace and a class. To avoid too many unnecessary
       # offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
       #
+      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled to prevent
+      # conflicting rules. Because it respects user configurations that want to enable
+      # this cop which is disabled by default.
+      #
       # @example
       #   # By default checks every constant
       #
@@ -64,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

@@ -15,9 +15,24 @@ module RuboCop
       # [source,yaml]
       # ----
       # Lint/Debugger:
-      #   WebConsole: ~
+      #   DebuggerMethods:
+      #     WebConsole: ~
       # ----
       #
+      # You can also add your own methods by adding a new category:
+      #
+      # [source,yaml]
+      # ----
+      # Lint/Debugger:
+      #   DebuggerMethods:
+      #     MyDebugger:
+      #       MyDebugger.debug_this
+      # ----
+      #
+      # Some gems also ship files that will start a debugging session when required,
+      # for example `require 'debug/start'` from `ruby/debug`. These requires can
+      # be configured through `DebuggerRequires`. It has the same structure as
+      # `DebuggerMethods`, which you can read about above.
       #
       # @example
       #
@@ -54,26 +69,20 @@ module RuboCop
       #   def some_method
       #     my_debugger
       #   end
+      #
+      # @example DebuggerRequires: [my_debugger/start]
+      #
+      #   # bad (ok during development)
+      #
+      #   require 'my_debugger/start'
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
-
-        # @!method kernel?(node)
-        def_node_matcher :kernel?, <<~PATTERN
-          (const {nil? cbase} :Kernel)
-        PATTERN
-
-        # @!method valid_receiver?(node, arg1)
-        def_node_matcher :valid_receiver?, <<~PATTERN
-          {
-            (const {nil? cbase} %1)
-            (send {nil? #kernel?} %1)
-          }
-        PATTERN
+        BLOCK_TYPES = %i[block numblock kwbegin].freeze
 
         def on_send(node)
-          return unless debugger_method?(node)
+          return if assumed_usage_context?(node)
 
-          add_offense(node)
+          add_offense(node) if debugger_method?(node) || debugger_require?(node)
         end
 
         private
@@ -85,29 +94,55 @@ 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.join.to_sym,
-                method_name: method_name.to_sym
-              }
-            end.compact
+            config.is_a?(Array) ? config : config.values.flatten
+          end
+        end
+
+        def debugger_requires
+          @debugger_requires ||= begin
+            config = cop_config.fetch('DebuggerRequires', [])
+            config.is_a?(Array) ? config : config.values.flatten
           end
         end
 
         def debugger_method?(send_node)
-          debugger_methods.any? do |method|
-            next unless method[:method_name] == send_node.method_name
-
-            if method[:receiver].nil?
-              send_node.receiver.nil?
-            else
-              valid_receiver?(send_node.receiver, method[:receiver])
-            end
+          return false if send_node.parent&.send_type? && send_node.parent.receiver == send_node
+
+          debugger_methods.include?(chained_method_name(send_node))
+        end
+
+        def debugger_require?(send_node)
+          return false unless send_node.method?(:require) && send_node.arguments.one?
+          return false unless (argument = send_node.first_argument).str_type?
+
+          debugger_requires.include?(argument.value)
+        end
+
+        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)
+
+          node.each_ancestor.none? do |ancestor|
+            BLOCK_TYPES.include?(ancestor.type) || ancestor.lambda_or_proc?
+          end
+        end
+
+        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
+            chained_method_name = "#{name}.#{chained_method_name}"
+            receiver = receiver.receiver
           end
+          chained_method_name
+        end
+
+        def assumed_argument?(node)
+          parent = node.parent
+
+          parent.call_type? || parent.literal? || parent.pair_type?
         end
       end
     end