rubocop 1.87.0 → 1.88.1

data/lib/rubocop/cop/bundler/gem_comment.rb

@@ -128,8 +128,8 @@ module RuboCop
         end
 
         def ignored_gem?(node)
-          ignored_gems = Array(cop_config['IgnoredGems'])
-          ignored_gems.include?(node.first_argument.value)
+          allowed_gems = Array(cop_config['AllowedGems'])
+          allowed_gems.include?(node.first_argument.value)
         end
 
         def checked_options_present?(node)
@@ -163,7 +163,9 @@ module RuboCop
         def gem_options(node)
           return [] unless node.last_argument&.hash_type?
 
-          node.last_argument.keys.map(&:value)
+          # Only literal keys carry an option name to check; a non-literal key
+          # (e.g. a variable or method call) has no `value` and must be skipped.
+          node.last_argument.keys.filter_map { |key| key.value if key.type?(:sym, :str) }
         end
       end
     end

data/lib/rubocop/cop/correctors/each_to_for_corrector.rb

@@ -27,7 +27,7 @@ module RuboCop
         if block_node.arguments?
           format(CORRECTION_WITH_ARGUMENTS,
                  collection: collection_node.source,
-                 variables: argument_node.children.first.source)
+                 variables: argument_node.children.map(&:source).join(', '))
         else
           format(CORRECTION_WITHOUT_ARGUMENTS, enumerable: collection_node.source)
         end

data/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb

@@ -86,7 +86,13 @@ module RuboCop
       end
 
       def lambda_arg_string
-        arguments.children.map(&:source).join(', ')
+        # Block-local (shadow) arguments are separated from regular arguments by a
+        # `;`; joining everything with `,` would turn them into extra parameters
+        # and change the lambda's arity.
+        regular, shadow = arguments.children.partition { |arg| !arg.shadowarg_type? }
+        arg_string = regular.map(&:source).join(', ')
+        arg_string += "; #{shadow.map(&:source).join(', ')}" unless shadow.empty?
+        arg_string
       end
 
       def needs_separating_space?

data/lib/rubocop/cop/correctors/ordered_gem_corrector.rb

@@ -18,7 +18,14 @@ module RuboCop
           current_range = declaration_with_comment(node)
           previous_range = declaration_with_comment(previous_declaration)
 
-          ->(corrector) { corrector.swap(current_range, previous_range) }
+          lambda do |corrector|
+            if current_range.source.end_with?("\n")
+              corrector.swap(current_range, previous_range)
+            else
+              corrector.insert_before(previous_range, "#{current_range.source}\n")
+              corrector.remove(current_range)
+            end
+          end
         end
 
         private

data/lib/rubocop/cop/gemspec/development_dependencies.rb

@@ -95,7 +95,7 @@ module RuboCop
         private
 
         def forbidden_gem?(gem_name)
-          !cop_config['AllowedGems'].include?(gem_name)
+          !Array(cop_config['AllowedGems']).include?(gem_name)
         end
 
         def message(_range)

data/lib/rubocop/cop/gemspec/require_mfa.rb

@@ -143,7 +143,10 @@ module RuboCop
             #{block_var}.metadata['rubygems_mfa_required'] = 'true'
           RUBY
 
-          if (last_assignment = metadata_assignment(processed_source.ast).to_a.last)
+          # Scope the search to the current spec block. Searching the whole file
+          # would, for a second `Gem::Specification.new` block, insert the directive
+          # into the first block, leaving this block uncorrected and looping forever.
+          if (last_assignment = metadata_assignment(node).to_a.last)
             corrector.insert_after(last_assignment, "\n#{require_mfa_directive}")
           else
             corrector.insert_before(node.loc.end, "#{require_mfa_directive}\n")

data/lib/rubocop/cop/internal_affairs/redundant_let_rubocop_config_new.rb

@@ -46,8 +46,7 @@ module RuboCop
 
         def on_block(node)
           return unless let_rubocop_config_new?(node)
-
-          describe = find_describe_method_node(node)
+          return unless (describe = find_describe_method_node(node))
 
           unless (exist_config = describe.last_argument.source == ':config')
             additional_message = ' and specify `:config` in `describe`'
@@ -65,7 +64,10 @@ module RuboCop
         private
 
         def find_describe_method_node(block_node)
-          block_node.ancestors.find { |node| node.block_type? && node.method?(:describe) }.send_node
+          describe = block_node.ancestors.find do |ancestor|
+            ancestor.block_type? && ancestor.method?(:describe)
+          end
+          describe&.send_node
         end
       end
     end

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

@@ -18,6 +18,10 @@ module RuboCop
       # `either` (which is the default) : the `end` is allowed to be in either
       # location. The autocorrect will default to `start_of_line`.
       #
+      # When the `do` or `{` appears on a continuation line of multiline
+      # method arguments, the start of the line where the method is called
+      # is used as the alignment target instead of that continuation line.
+      #
       # @example EnforcedStyleAlignWith: either (default)
       #   # bad
       #
@@ -116,6 +120,7 @@ module RuboCop
           end_loc = block_node.loc.end
           return unless begins_its_line?(end_loc)
 
+          start_node = start_for_line_node(block_node) if style == :start_of_line
           start_loc = start_node.source_range
           return unless start_loc.column != end_loc.column || style == :start_of_block
 
@@ -196,23 +201,34 @@ module RuboCop
 
         def compute_do_source_line_column(node, end_loc)
           do_loc = node.loc.begin # Actually it's either do or {.
+          anchor_loc = do_line_anchor_loc(node, do_loc)
 
           # We've found that "end" is not aligned with the start node (which
           # can be a block, a variable assignment, etc). But we also allow
           # the "end" to be aligned with the start of the line where the "do"
           # is, which is a style some people use in multi-line chains of
           # blocks.
-          match = /\S.*/.match(do_loc.source_line)
+          match = /\S.*/.match(anchor_loc.source_line)
           indentation_of_do_line = match.begin(0)
-          return unless end_loc.column != indentation_of_do_line || style == :start_of_line
+          permitted_columns = permitted_do_line_columns(do_loc, indentation_of_do_line)
+          return if permitted_columns.include?(end_loc.column) && style != :start_of_line
 
           {
             source: match[0],
-            line: do_loc.line,
+            line: anchor_loc.line,
             column: indentation_of_do_line
           }
         end
 
+        # `end` aligned with an argument continuation line that holds the `do`
+        # was accepted before the anchor moved to the method dispatch line;
+        # keep accepting it so that such code does not become an offense.
+        def permitted_do_line_columns(do_loc, indentation_of_do_line)
+          columns = [indentation_of_do_line]
+          columns << (do_loc.source_line =~ /\S/) if style == :either
+          columns
+        end
+
         def loc_to_source_line_column(loc)
           {
             source: loc.source.lines.to_a.first.chomp,
@@ -239,7 +255,7 @@ module RuboCop
         def compute_start_col(ancestor_node, node)
           if style == :start_of_block
             do_loc = node.loc.begin
-            return do_loc.source_line =~ /\S/
+            return do_line_anchor_loc(node, do_loc).source_line =~ /\S/
           end
           (ancestor_node || node).source_range.column
         end
@@ -253,6 +269,44 @@ module RuboCop
 
           corrector.remove(range)
         end
+
+        # When the `do` or `{` is on a continuation line of multiline method
+        # arguments, the indentation of that line is not a meaningful
+        # alignment target; anchor on the method dispatch position instead.
+        def do_line_anchor_loc(node, do_loc)
+          if do_line_begins_inside_argument?(node, do_loc)
+            node.send_node.selector || node.send_node.source_range
+          else
+            do_loc
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def do_line_begins_inside_argument?(node, do_loc)
+          line_begin_pos = do_loc.begin_pos - do_loc.column
+          first_char_pos = line_begin_pos + (do_loc.source_line =~ /\S/)
+          return false unless inside_parentheses?(node, first_char_pos)
+
+          (node.send_node.arguments + node.arguments).any? do |argument|
+            argument.source_range.begin_pos <= first_char_pos &&
+              first_char_pos < argument.source_range.end_pos
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # The continuation line indentation is only an unmeaningful alignment target when
+        # it is dictated by an opening delimiter, i.e. the line begins inside `(` or `[`.
+        # For a bare argument list without parentheses the indentation is the author's
+        # deliberate alignment, so the anchor must not move to the method dispatch line.
+        def inside_parentheses?(node, pos)
+          preceding_tokens = processed_source.tokens.select do |token|
+            token.begin_pos >= node.source_range.begin_pos && token.begin_pos < pos
+          end
+          opens = preceding_tokens.count { |token| token.left_parens? || token.left_bracket? }
+          closes = preceding_tokens.count { |token| token.right_parens? || token.right_bracket? }
+
+          opens > closes
+        end
       end
     end
   end

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

@@ -278,10 +278,14 @@ module RuboCop
 
           return [] unless class_def
 
-          if class_def.type?(:def, :send)
-            [class_def]
-          else
+          # Only a multi-statement body (`begin`/`kwbegin`) wraps several elements; any
+          # single statement (`def`, `send`, `csend`, `if`, ...) is itself the sole element.
+          # Exploding such a node into its children would yield non-node values (e.g. a
+          # method-name `Symbol` from a `csend`) and crash later checks.
+          if class_def.type?(:begin, :kwbegin)
             class_def.children.compact
+          else
+            [class_def]
           end
         end
 

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

@@ -44,16 +44,26 @@ module RuboCop
           message = message(condition)
 
           add_offense(condition, message: message) do |corrector|
-            range = range_by_whole_lines(condition.source_range, include_final_newline: true)
-
             corrector.insert_after(condition.parent.loc.keyword, " #{condition.source}")
-            corrector.remove(range)
+            corrector.remove(removal_range(node, condition))
           end
         end
 
         def message(condition)
           format(MSG, keyword: condition.parent.keyword)
         end
+
+        # When a body statement shares the condition's line (e.g. `while\n cond; body\nend`),
+        # removing the whole line would delete the body too. In that case only remove the
+        # condition and its trailing separator, preserving the body statement.
+        def removal_range(node, condition)
+          body = node.body
+          if body && body.source_range.line == condition.source_range.last_line
+            range_between(condition.source_range.begin_pos, body.source_range.begin_pos)
+          else
+            range_by_whole_lines(condition.source_range, include_final_newline: true)
+          end
+        end
       end
     end
   end

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

@@ -95,8 +95,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          previous_token = previous_token(node)
-          range = if previous_token && same_line?(node, previous_token)
+          range = if inline_comment?(node)
                     range_with_surrounding_space(node.source_range, newlines: false)
                   else
                     range_by_whole_lines(node.source_range, include_final_newline: true)
@@ -138,14 +137,13 @@ module RuboCop
           cop_config['AllowMarginComment']
         end
 
-        def current_token(comment)
-          processed_source.tokens.find { |token| token.pos == comment.source_range }
-        end
-
-        def previous_token(node)
-          current_token = current_token(node)
-          index = processed_source.tokens.index(current_token)
-          index.zero? ? nil : processed_source.tokens[index - 1]
+        # A comment is inline when code precedes it on the same line. Detecting this
+        # from the source (rather than the token stream) is required because, for a
+        # comment trailing a heredoc opener, the preceding token is the heredoc end on
+        # a later line, which would wrongly trigger whole-line removal of the opener.
+        def inline_comment?(comment)
+          preceding_source = processed_source.lines[comment.loc.line - 1][0...comment.loc.column]
+          !preceding_source.strip.empty?
         end
       end
     end

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

@@ -274,7 +274,20 @@ module RuboCop
         end
 
         def end_loc(node)
-          node.source_range.end
+          end_location = node.source_range.end
+          trailing_heredoc_end(node, end_location) || end_location
+        end
+
+        # For an endless method whose body is a heredoc (e.g. `def a = <<~TEXT`), the
+        # node's source range ends at the heredoc opening line, before the heredoc body.
+        # Use the heredoc's closing delimiter so the def's real end is located after the
+        # heredoc and blank-line insertion does not land inside the heredoc body.
+        def trailing_heredoc_end(node, end_location)
+          heredocs = node.each_descendant(:any_str).select(&:heredoc?)
+          return if heredocs.empty?
+
+          heredoc_end = heredocs.map { |heredoc| heredoc.loc.heredoc_end }.max_by(&:end_pos)
+          heredoc_end if heredoc_end.end_pos > end_location.end_pos
         end
 
         def autocorrect_remove_lines(corrector, newline_pos, count)

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

@@ -28,10 +28,10 @@ module RuboCop
       #   # bad
       #   hash = {
       #     key: :value
-      #   }
-      #   and_in_a_method_call({
-      #     no: :difference
-      #                        })
+      #          }
+      #   in_a_method_call({
+      #     foo: :bar
+      #   })
       #   takes_multi_pairs_hash(x: {
       #     a: 1,
       #     b: 2
@@ -42,13 +42,12 @@ module RuboCop
       #                          })
       #
       #   # good
-      #   special_inside_parentheses
       #   hash = {
       #     key: :value
       #   }
-      #   but_in_a_method_call({
-      #                          its_like: :this
-      #                        })
+      #   in_a_method_call({
+      #                      foo: :bar
+      #                    })
       #   takes_multi_pairs_hash(x: {
       #                            a: 1,
       #                            b: 2
@@ -67,17 +66,17 @@ module RuboCop
       #   # bad
       #   hash = {
       #     key: :value
-      #   }
-      #   but_in_a_method_call({
-      #                          its_like: :this
-      #                         })
+      #          }
+      #   in_a_method_call({
+      #                     foo: :bar
+      #                   })
       #
       #   # good
       #   hash = {
       #     key: :value
       #   }
-      #   and_in_a_method_call({
-      #     no: :difference
+      #   in_a_method_call({
+      #     foo: :bar
       #   })
       #
       #

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

@@ -25,6 +25,17 @@ module RuboCop
       #     end
       #   end
       #
+      # @example
+      #   # bad
+      #   value = (
+      #   foo - bar
+      #   )
+      #
+      #   # good
+      #   value = (
+      #     foo - bar
+      #   )
+      #
       # @example AllowedPatterns: ['^\s*module']
       #   # bad
       #   module A
@@ -95,6 +106,16 @@ module RuboCop
           check_indentation(node.loc.end, node.children.first)
         end
 
+        def on_begin(node)
+          # Only a parenthesized grouping expression (e.g. `(\n  foo\n)`) has
+          # explicit delimiters. Indent the body one step from the line
+          # the opening parenthesis is on, but only when the closing parenthesis is
+          # first on its line (a body on the opening line is skipped downstream).
+          return unless parentheses?(node) && begins_its_line?(node.loc.end)
+
+          check_indentation(opening_line_start(node.loc.begin), node.children.first)
+        end
+
         def on_block(node)
           end_loc = node.loc.end
 
@@ -188,6 +209,13 @@ module RuboCop
           AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
         end
 
+        # Returns a range at the first non-space column of the line the opening parenthesis is on,
+        # used as the base to indent the body from.
+        def opening_line_start(begin_loc)
+          column = begin_loc.source_line =~ /\S/
+          source_range(processed_source.buffer, begin_loc.line, column)
+        end
+
         def check_members(base, members)
           check_indentation(base, select_check_member(members.first))
 

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

@@ -204,10 +204,14 @@ module RuboCop
 
         def autocorrect(corrector, range, right_operand)
           range_source = range.source
+          # Match the operator exactly, not by substring, so compound assignments
+          # like `**=` and `/=` are not mistaken for `**` and `/` (which would drop
+          # the `=` and silently change the program's behavior).
+          operator = range_source.strip
 
-          if range_source.include?('**') && !space_around_exponent_operator?
+          if operator == '**' && !space_around_exponent_operator?
             corrector.replace(range, '**')
-          elsif range_source.include?('/') && !space_around_slash_operator?(right_operand)
+          elsif operator == '/' && !space_around_slash_operator?(right_operand)
             corrector.replace(range, '/')
           elsif range_source.end_with?("\n")
             corrector.replace(range, " #{range_source.strip}\n")

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

@@ -28,7 +28,7 @@ module RuboCop
         MISTAKES = { '=-' => '-=', '=+' => '+=', '=*' => '*=', '=!' => '!=' }.freeze
 
         def on_asgn(node)
-          return unless (rhs = rhs(node))
+          return unless (rhs = node.expression)
 
           range = range_between(node.loc.operator.end_pos - 1, rhs.source_range.begin_pos + 1)
           source = range.source
@@ -38,16 +38,6 @@ module RuboCop
         end
 
         SIMPLE_ASSIGNMENT_TYPES.each { |asgn_type| alias_method :"on_#{asgn_type}", :on_asgn }
-
-        private
-
-        def rhs(node)
-          if node.casgn_type?
-            node.children[2]
-          else
-            node.children[1]
-          end
-        end
       end
     end
   end

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

@@ -44,13 +44,6 @@ module RuboCop
         RESTRICT_ON_SEND = PRECEDENCE.flatten.freeze
         MSG = 'Wrap expressions with varying precedence with parentheses to avoid ambiguity.'
 
-        def on_new_investigation
-          # Cache the precedence of each node being investigated
-          # so that we only need to calculate it once
-          @node_precedences = {}
-          super
-        end
-
         def on_and(node)
           return unless (parent = node.parent)
 
@@ -77,9 +70,7 @@ module RuboCop
         private
 
         def precedence(node)
-          @node_precedences.fetch(node) do
-            PRECEDENCE.index { |operators| operators.include?(operator_name(node)) }
-          end
+          PRECEDENCE.index { |operators| operators.include?(operator_name(node)) }
         end
 
         def operator?(node)

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

@@ -78,13 +78,25 @@ module RuboCop
         end
 
         def allowed_construct?(asgn_node)
-          asgn_node.begin_type? || conditional_assignment?(asgn_node)
+          return true if asgn_node.begin_type?
+
+          conditional_assignment?(asgn_node) || discarded_assignment?(asgn_node)
         end
 
         def conditional_assignment?(asgn_node)
           !asgn_node.loc.operator
         end
 
+        # An assignment that is a statement of a multi-statement `begin`
+        # (e.g. `(foo = bar; baz)`) has its value discarded, so it is not used
+        # as the condition. Wrapping it in parentheses would only conflict with
+        # `Style/RedundantParentheses`, so it is left alone.
+        def discarded_assignment?(asgn_node)
+          parent = asgn_node.parent
+
+          parent&.begin_type? && parent.children.size > 1
+        end
+
         def skip_children?(asgn_node)
           (asgn_node.call_type? && !asgn_node.assignment_method?) ||
             empty_condition?(asgn_node) ||

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

@@ -80,7 +80,6 @@ module RuboCop
           check_assignment_chain(arg_name, arg_value)
         end
 
-        # rubocop:disable Metrics/AbcSize
         def check_assignment_chain(arg_name, node)
           return unless node.lvasgn_type?
 
@@ -88,7 +87,7 @@ module RuboCop
           current_node = node
 
           while current_node.lvasgn_type?
-            seen_variables << current_node.children.first if current_node.lvasgn_type?
+            seen_variables << current_node.children.first
             current_node = current_node.children.last
           end
 
@@ -99,7 +98,6 @@ module RuboCop
 
           add_offense(current_node, message: format(MSG, arg_name: arg_name))
         end
-        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -73,7 +73,6 @@ module RuboCop
       #   require 'my_debugger/start'
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
-        BLOCK_TYPES = %i[block numblock itblock kwbegin].freeze
 
         def on_send(node)
           return if assumed_usage_context?(node)

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

@@ -49,7 +49,7 @@ module RuboCop
           #        Maybe further investigation of RuboCop AST will lead to an essential solution.
           return unless node.loc
 
-          constant = node.absolute? ? constant_name(node, node.short_name) : node.source
+          constant = node.source.delete_prefix('::')
           return unless (deprecated_constant = deprecated_constants[constant])
 
           alternative = deprecated_constant['Alternative']
@@ -63,12 +63,6 @@ module RuboCop
 
         private
 
-        def constant_name(node, nested_constant_name)
-          return nested_constant_name.to_s unless node.namespace.const_type?
-
-          constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
-        end
-
         def message(good, bad, deprecated_version)
           deprecated_message = ", deprecated since Ruby #{deprecated_version}" if deprecated_version
 

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

@@ -77,7 +77,7 @@ module RuboCop
           return false unless processed_source.contains_comment?(node.source_range)
 
           line_comment = processed_source.comment_at_line(node.source_range.line)
-          !line_comment || !comment_disables_cop?(line_comment.source)
+          !line_comment || !comment_disables_cop?(line_comment)
         end
 
         def allow_empty_lambdas?
@@ -85,8 +85,8 @@ module RuboCop
         end
 
         def comment_disables_cop?(comment)
-          regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
-          Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
+          directive = DirectiveComment.new(comment)
+          directive.disabled? && directive.cop_names.include?(cop_name)
         end
       end
     end

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

@@ -43,7 +43,25 @@ module RuboCop
         MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)
-          node.branch&.each_node(:return) { |return_node| add_offense(return_node) }
+          node.branch&.each_node(:return) do |return_node|
+            next if return_from_inner_scope?(return_node, node)
+
+            add_offense(return_node)
+          end
+        end
+
+        private
+
+        # A `return` inside a nested method definition or lambda within the
+        # `ensure` returns from that inner scope, not from the method whose
+        # `ensure` this is, so it is not an offense. A `return` inside a plain
+        # block (or `proc`) does propagate out, so it remains an offense.
+        def return_from_inner_scope?(return_node, ensure_node)
+          return_node.each_ancestor do |ancestor|
+            break if ancestor == ensure_node
+            return true if ancestor.any_def_type? || (ancestor.any_block_type? && ancestor.lambda?)
+          end
+          false
         end
       end
     end

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

@@ -148,7 +148,9 @@ module RuboCop
           arguments = node.arguments
           overridden_kwargs = kwargs.dup
 
-          overridden_kwargs[0] = "trim_mode: #{arguments[2].source}" if arguments[2]
+          if arguments[2] && !arguments[2].hash_type?
+            overridden_kwargs[0] = "trim_mode: #{arguments[2].source}"
+          end
 
           if arguments[3] && !arguments[3].hash_type?
             overridden_kwargs[1] = "eoutvar: #{arguments[3].source}"

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

@@ -104,6 +104,7 @@ module RuboCop
 
         def literal_safe?(node)
           return false unless node
+          return literal_safe?(node.children.first) if node.begin_type?
 
           (node.numeric_type? && node.value.zero?) || node.nil_type?
         end