rubocop 1.79.2 → 1.81.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f846b1bf660549b8197375e32c8219bff1e42888b925976bd3514cd9b32c1d3b
-  data.tar.gz: 4e862ade4bbe0c24c7734427695733316c893b5278f9868aa88c44255d03461c
+  metadata.gz: 2e194323f7062efb4f5777f4039ff475256dfa86b6e95dd63f42f682b3e59a55
+  data.tar.gz: 533b2e1fe940252958b245c2d492e0e4b39e37babd9e918fbc3ee505faf030ac
 SHA512:
-  metadata.gz: 05ff2343d4ddcdd26cf94325a5b9026fb7468f456b5714da5108030c39fb0fcfb7218848596d07b04817052af53bc225e66b1f81c53f18adb780c2b4bd417012
-  data.tar.gz: 9c2ce30fbd9467d85bed0aa581beaa225f3e5b032f0e7a5b09130c8eb2918b25e452f3704a9774e8199c1b9e1ccb1b7d10e558a710c7a73d9f9bd86940475ebf
+  metadata.gz: c4bbe12c2a1c627b8f4938a3cc52cd3e4c51ee334b8f1d3b2c373dd109c20741721c090b9152ef2e3f8a908f95c90cc7d8021ba48a1354884361219880153581
+  data.tar.gz: 0ee2973781e011caf6069a9072f8f6a59196d0430fe3d90af740bc2795423d4ead9fc62ddbe11bfe2be8230b769446e734eebcf461c494bb2921a3fb16135c7c

data/README.md

@@ -51,7 +51,7 @@ To prevent an unwanted RuboCop update you might want to use a conservative versi
 in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 1.79', require: false
+gem 'rubocop', '~> 1.81', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.

data/config/default.yml

@@ -3341,6 +3341,12 @@ Style/ArrayIntersect:
   Safe: false
   VersionAdded: '1.40'
 
+Style/ArrayIntersectWithSingleElement:
+  Description: 'Use `include?(element)` instead of `intersect?([element])`.'
+  Enabled: 'pending'
+  Safe: false
+  VersionAdded: '1.81'
+
 Style/ArrayJoin:
   Description: 'Use Array#join instead of Array#*.'
   StyleGuide: '#array-join'
@@ -5844,10 +5850,14 @@ Style/TrailingCommaInArguments:
   # parenthesized method calls where each argument is on its own line.
   # If `consistent_comma`, the cop requires a comma after the last argument,
   # for all parenthesized method calls with arguments.
+  # If `diff_comma`, the cop requires a comma after the last argument, but only
+  # when that argument is followed by an immediate newline, even if
+  # there is an inline comment.
   EnforcedStyleForMultiline: no_comma
   SupportedStylesForMultiline:
     - comma
     - consistent_comma
+    - diff_comma
     - no_comma
 
 Style/TrailingCommaInArrayLiteral:

data/exe/rubocop

@@ -12,13 +12,6 @@ if RuboCop::Server.running?
   exit_status = RuboCop::Server::ClientCommand::Exec.new.run
 else
   require 'rubocop'
-
-  cli = RuboCop::CLI.new
-
-  time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-  exit_status = cli.run
-  elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - time_start
-
-  puts "Finished in #{elapsed_time} seconds" if cli.options[:debug] || cli.options[:display_time]
+  exit_status = RuboCop::CLI.new.run
 end
 exit exit_status

data/lib/rubocop/cli/command/auto_generate_config.rb

@@ -83,7 +83,7 @@ module RuboCop
           execute_runner
           @options.delete(:only)
           @config_store = ConfigStore.new
-          @config_store.options_config = @options[:config] if @options[:config]
+          @config_store.apply_options!(@options)
           # Save the todo configuration of the LineLength cop.
           File.read(AUTO_GENERATED_FILE).lines.drop_while { |line| line.start_with?('#') }.join
         end
@@ -99,7 +99,7 @@ module RuboCop
 
         def reset_config_and_auto_gen_file
           @config_store = ConfigStore.new
-          @config_store.options_config = @options[:config] if @options[:config]
+          @config_store.apply_options!(@options)
           File.open(AUTO_GENERATED_FILE, 'w') {} # create or truncate if exists
           add_inheritance_from_auto_generated_file(@options[:config])
         end

data/lib/rubocop/cli.rb

@@ -37,6 +37,8 @@ module RuboCop
     #
     # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def run(args = ARGV)
+      time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
       @options, paths = Options.new.parse(args)
       @env = Environment.new(@options, @config_store, paths)
 
@@ -72,6 +74,9 @@ module RuboCop
       warn e.message
       warn e.backtrace
       STATUS_ERROR
+    ensure
+      elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - time_start
+      puts "Finished in #{elapsed_time} seconds" if @options[:debug] || @options[:display_time]
     end
     # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
@@ -159,8 +164,7 @@ module RuboCop
       set_options_to_pending_cops_reporter
       handle_editor_mode
 
-      @config_store.options_config = @options[:config] if @options[:config]
-      @config_store.force_default_config! if @options[:force_default_config]
+      @config_store.apply_options!(@options)
 
       handle_exiting_options
 

data/lib/rubocop/config_loader.rb

@@ -75,7 +75,9 @@ module RuboCop
 
         puts "configuration from #{absolute_path}" if debug?
 
-        raise(TypeError, "Malformed configuration in #{absolute_path}") unless hash.is_a?(Hash)
+        unless hash.is_a?(Hash)
+          raise(ValidationError, "Malformed configuration in #{absolute_path}")
+        end
 
         hash
       end

data/lib/rubocop/config_store.rb

@@ -25,6 +25,11 @@ module RuboCop
       @validated = true
     end
 
+    def apply_options!(options)
+      self.options_config = options[:config] if options[:config]
+      force_default_config! if options[:force_default_config]
+    end
+
     def options_config=(options_config)
       loaded_config = ConfigLoader.load_file(options_config)
       @options_config = ConfigLoader.merge_with_default(loaded_config, options_config)

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -35,8 +35,8 @@ module RuboCop
         # `false` is the same as `disabled` for backward compatibility.
         return false if ['disabled', false].include?(cop_config['AutoCorrect'])
 
-        # When LSP is enabled, it is considered as editing source code,
-        # and autocorrection with `AutoCorrect: contextual` will not be performed.
+        # When LSP is enabled or the `--editor-mode` option is on, it is considered as editing
+        # source code, and autocorrection with `AutoCorrect: contextual` will not be performed.
         return false if contextual_autocorrect? && LSP.enabled?
 
         # :safe_autocorrect is a derived option based on several command-line
@@ -94,7 +94,7 @@ module RuboCop
       end
 
       def surrounding_heredoc?(node)
-        node.type?(:str, :dstr, :xstr) && node.heredoc?
+        node.any_str_type? && node.heredoc?
       end
 
       def heredoc_range(node)
@@ -106,7 +106,7 @@ module RuboCop
       end
 
       def string_continuation?(node)
-        node.type?(:str, :dstr, :xstr) && node.source.match?(/\\\s*$/)
+        node.any_str_type? && node.source.match?(/\\\s*$/)
       end
 
       def multiline_string?(node)

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

@@ -29,10 +29,13 @@ module RuboCop
         def align_end(corrector, processed_source, node, align_to)
           @processed_source = processed_source
           whitespace = whitespace_range(node)
-          return false unless whitespace.source.strip.empty?
-
           column = alignment_column(align_to)
-          corrector.replace(whitespace, ' ' * column)
+
+          if whitespace.source.strip.empty?
+            corrector.replace(whitespace, ' ' * column)
+          else
+            corrector.insert_after(whitespace, "\n#{' ' * column}")
+          end
         end
 
         private
@@ -54,7 +57,7 @@ module RuboCop
         def inside_string_ranges(node)
           return [] unless node.is_a?(Parser::AST::Node)
 
-          node.each_node(:str, :dstr, :xstr).filter_map { |n| inside_string_range(n) }
+          node.each_node(:any_str).filter_map { |n| inside_string_range(n) }
         end
 
         def inside_string_range(node)

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

@@ -6,7 +6,7 @@ module RuboCop
     class ForToEachCorrector
       extend NodePattern::Macros
 
-      CORRECTION = '%<collection>s.each do |%<argument>s|'
+      CORRECTION = '%<collection>s%<dot>seach do |%<argument>s|'
 
       def initialize(for_node)
         @for_node        = for_node
@@ -25,7 +25,12 @@ module RuboCop
       attr_reader :for_node, :variable_node, :collection_node
 
       def correction
-        format(CORRECTION, collection: collection_source, argument: variable_node.source)
+        format(
+          CORRECTION,
+          collection: collection_source,
+          dot: collection_node.csend_type? ? '&.' : '.',
+          argument: variable_node.source
+        )
       end
 
       def collection_source

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

@@ -30,6 +30,8 @@ module RuboCop
           any_block: %i[block numblock itblock],
           any_def: %i[def defs],
           any_match_pattern: %i[match_pattern match_pattern_p],
+          any_str: %i[str dstr xstr],
+          any_sym: %i[sym dsym],
           argument: %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg forward_arg shadowarg],
           boolean: %i[true false],
           call: %i[send csend],
@@ -210,7 +212,7 @@ module RuboCop
         # A heredoc can be a `dstr` without interpolation, but if there is interpolation
         # there'll be a `begin` node, in which case, we cannot evaluate the pattern.
         def acceptable_heredoc?(node)
-          node.type?(:str, :dstr) && node.heredoc? && node.each_child_node(:begin).none?
+          node.any_str_type? && node.heredoc? && node.each_child_node(:begin).none?
         end
 
         def process_pattern(pattern_node)

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

@@ -76,7 +76,7 @@ module RuboCop
         end
 
         def on_send(node) # rubocop:disable InternalAffairs/OnSendWithoutOnCSend
-          new_identifier = node.first_argument
+          return unless (new_identifier = node.first_argument)
           return unless new_identifier.basic_literal?
 
           new_identifier = new_identifier.value

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

@@ -357,7 +357,7 @@ module RuboCop
         end
 
         def find_heredoc(node)
-          node.each_node(:str, :dstr, :xstr).find(&:heredoc?)
+          node.each_node(:any_str).find(&:heredoc?)
         end
 
         def buffer

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

@@ -120,7 +120,7 @@ module RuboCop
         end
 
         def heredoc?(node)
-          node.type?(:str, :dstr) && node.heredoc?
+          node.any_str_type? && node.heredoc?
         end
 
         def end_range(node)

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

@@ -76,28 +76,40 @@ module RuboCop
       #   # good
       #   class ErrorA < BaseError; end
       #   class ErrorB < BaseError; end
-      #   class ErrorC < BaseError; end
       #
       #   # good
       #   class ErrorA < BaseError; end
       #
       #   class ErrorB < BaseError; end
       #
-      #   class ErrorC < BaseError; end
+      #   # good - DefLikeMacros: [memoize]
+      #   memoize :attribute_a
+      #   memoize :attribute_b
+      #
+      #   # good
+      #   memoize :attribute_a
+      #
+      #   memoize :attribute_b
       #
       # @example AllowAdjacentOneLineDefs: false
       #
       #   # bad
       #   class ErrorA < BaseError; end
       #   class ErrorB < BaseError; end
-      #   class ErrorC < BaseError; end
       #
       #   # good
       #   class ErrorA < BaseError; end
       #
       #   class ErrorB < BaseError; end
       #
-      #   class ErrorC < BaseError; end
+      #   # bad - DefLikeMacros: [memoize]
+      #   memoize :attribute_a
+      #   memoize :attribute_b
+      #
+      #   # good
+      #   memoize :attribute_a
+      #
+      #   memoize :attribute_b
       #
       class EmptyLineBetweenDefs < Base
         include RangeHelp
@@ -158,6 +170,8 @@ module RuboCop
         def def_location(correction_node)
           if correction_node.any_block_type?
             correction_node.source_range.join(correction_node.children.first.source_range)
+          elsif correction_node.send_type?
+            correction_node.source_range
           else
             correction_node.loc.keyword.join(correction_node.loc.name)
           end
@@ -175,8 +189,14 @@ module RuboCop
         end
 
         def macro_candidate?(node)
-          node.any_block_type? && node.children.first.macro? &&
-            empty_line_between_macros.include?(node.children.first.method_name)
+          macro_candidate = if node.any_block_type?
+                              node.send_node
+                            elsif node.send_type?
+                              node
+                            end
+          return false unless macro_candidate
+
+          macro_candidate.macro? && empty_line_between_macros.include?(macro_candidate.method_name)
         end
 
         def method_candidate?(node)
@@ -240,7 +260,9 @@ module RuboCop
         end
 
         def def_start(node)
-          if node.any_block_type? && node.children.first.send_type?
+          node = node.send_node if node.any_block_type?
+
+          if node.send_type?
             node.source_range.line
           else
             node.loc.keyword.line
@@ -252,11 +274,7 @@ module RuboCop
         end
 
         def end_loc(node)
-          if node.any_def_type? && node.endless?
-            node.source_range.end
-          else
-            node.loc.end
-          end
+          node.source_range.end
         end
 
         def autocorrect_remove_lines(corrector, newline_pos, count)

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

@@ -38,7 +38,7 @@ module RuboCop
         RESTRICT_ON_SEND = MODULE_INCLUSION_METHODS
 
         def on_send(node)
-          return if node.receiver
+          return if node.receiver || node.arguments.empty?
           return if node.parent&.type?(:send, :any_block)
 
           return if next_line_empty_or_enable_directive_comment?(node.last_line)

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

@@ -134,6 +134,7 @@ module RuboCop
 
         def check_for_breakable_block(block_node)
           return unless block_node.single_line?
+          return if receiver_contains_heredoc?(block_node)
 
           line_index = block_node.loc.line - 1
           range = breakable_block_range(block_node)
@@ -321,7 +322,7 @@ module RuboCop
         def extract_heredocs(ast)
           return [] unless ast
 
-          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
+          ast.each_node(:any_str).select(&:heredoc?).map do |node|
             body = node.location.heredoc_body
             delimiter = node.location.heredoc_end.source.strip
             [body.first_line...body.last_line, delimiter]
@@ -341,6 +342,13 @@ module RuboCop
           heredocs.any? { |range, _delimiter| range.cover?(line_number) }
         end
 
+        def receiver_contains_heredoc?(node)
+          return false unless (receiver = node.receiver)
+          return true if receiver.any_str_type? && receiver.heredoc?
+
+          receiver.each_descendant(:any_str).any?(&:heredoc?)
+        end
+
         def check_directive_line(line, line_index)
           length_without_directive = line_length_without_directive(line)
           return if length_without_directive <= max

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

@@ -10,6 +10,8 @@ module RuboCop
       # condition, an explicit `return` statement, etc. In other contexts, the second operand should
       # be indented regardless of enforced style.
       #
+      # In both styles, operators should be aligned when an assignment begins on the next line.
+      #
       # @example EnforcedStyle: aligned (default)
       #   # bad
       #   if a +
@@ -100,10 +102,12 @@ module RuboCop
             return true if begins_its_line?(assignment_rhs.source_range)
           end
 
-          given_style == :aligned &&
-            (kw_node_with_special_indentation(node) ||
-             assignment_node ||
-             argument_in_method_call(node, :with_or_without_parentheses))
+          return false unless given_style == :aligned
+          return true if kw_node_with_special_indentation(node) || assignment_node
+
+          node = argument_in_method_call(node, :with_or_without_parentheses)
+
+          node.respond_to?(:def_modifier?) && !node.def_modifier?
         end
 
         def message(node, lhs, rhs)

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

@@ -194,6 +194,14 @@ module RuboCop
         def alignment_location(alignment_node)
           if begin_end_alignment_style == 'start_of_line'
             start_line_range(alignment_node)
+          elsif alignment_node.any_block_type?
+            # If the alignment node is a block, the `rescue`/`ensure` keyword should
+            # be aligned to the start of the block. It is possible that the block's
+            # `send_node` spans multiple lines, in which case it should align to the
+            # start of the last line.
+            send_node = alignment_node.send_node
+            range = processed_source.buffer.line_range(send_node.last_line)
+            range.adjust(begin_pos: range.source =~ /\S/)
           else
             alignment_node.source_range
           end

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

@@ -113,7 +113,7 @@ module RuboCop
           return [] unless ast
 
           heredocs = []
-          ast.each_node(:str, :dstr, :xstr) do |node|
+          ast.each_node(:any_str) do |node|
             next unless node.heredoc?
 
             body = node.location.heredoc_body

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

@@ -118,8 +118,11 @@ module RuboCop
 
         def replacement_args(node)
           algorithm_constant, = algorithm_const(node)
-          algorithm_name = algorithm_name(algorithm_constant)
+          if algorithm_constant.source == 'OpenSSL::Cipher::Cipher'
+            return node.first_argument.source
+          end
 
+          algorithm_name = algorithm_name(algorithm_constant)
           if openssl_class(algorithm_constant) == 'OpenSSL::Cipher'
             build_cipher_arguments(node, algorithm_name, node.arguments.empty?)
           else

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

@@ -24,8 +24,6 @@ module RuboCop
 
         MSG_REPEATED_ELEMENT = 'Duplicate element inside regexp character class'
 
-        OCTAL_DIGITS_AFTER_ESCAPE = 2
-
         def on_regexp(node)
           each_repeated_character_class_element_loc(node) do |loc|
             add_offense(loc, message: MSG_REPEATED_ELEMENT) do |corrector|
@@ -40,9 +38,9 @@ module RuboCop
 
             seen = Set.new
             group_expressions(node, expr.expressions) do |group|
-              group_source = group.map(&:to_s).join
+              group_source = group.to_s
 
-              yield source_range(group) if seen.include?(group_source)
+              yield group.expression if seen.include?(group_source)
 
               seen << group_source
             end
@@ -52,40 +50,13 @@ module RuboCop
         private
 
         def group_expressions(node, expressions)
-          # Create a mutable list to simplify state tracking while we iterate.
-          expressions = expressions.to_a
-
-          until expressions.empty?
-            # With we may need to compose a group of multiple expressions.
-            group = [expressions.shift]
-            next if within_interpolation?(node, group.first)
-
-            # With regexp_parser < 2.7 escaped octal sequences may be up to 3
-            # separate expressions ("\\0", "0", "1").
-            pop_octal_digits(group, expressions) if escaped_octal?(group.first.to_s)
-
-            yield(group)
-          end
-        end
-
-        def pop_octal_digits(current_child, expressions)
-          OCTAL_DIGITS_AFTER_ESCAPE.times do
-            next_child = expressions.first
-            break unless octal?(next_child.to_s)
+          expressions.each do |expression|
+            next if within_interpolation?(node, expression)
 
-            current_child << expressions.shift
+            yield(expression)
           end
         end
 
-        def source_range(children)
-          return children.first.expression if children.size == 1
-
-          range_between(
-            children.first.expression.begin_pos,
-            children.last.expression.begin_pos + children.last.to_s.length
-          )
-        end
-
         def skip_expression?(expr)
           expr.type != :set || expr.token == :intersection
         end
@@ -99,14 +70,6 @@ module RuboCop
           interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
         end
 
-        def escaped_octal?(string)
-          string.length == 2 && string[0] == '\\' && octal?(string[1])
-        end
-
-        def octal?(char)
-          ('0'..'7').cover?(char)
-        end
-
         def interpolation_locs(node)
           @interpolation_locs ||= {}
 

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

@@ -52,10 +52,9 @@ module RuboCop
           each_missing_enable do |cop, line_range|
             next if acceptable_range?(cop, line_range)
 
-            range = source_range(processed_source.buffer, line_range.min, 0..0)
             comment = processed_source.comment_at_line(line_range.begin)
 
-            add_offense(range, message: message(cop, comment))
+            add_offense(comment, message: message(cop, comment))
           end
         end
 

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

@@ -45,7 +45,7 @@ module RuboCop
           return if allow_rbs_inline_annotation? && rbs_inline_annotation?(node.receiver)
 
           if node.method?(:[]=)
-            handle_key_assignment(node) if node.arguments.size == 2
+            handle_key_assignment(node)
           elsif node.assignment_method?
             handle_attribute_assignment(node) if node.arguments.size == 1
           end
@@ -105,12 +105,13 @@ module RuboCop
         end
 
         def handle_key_assignment(node)
-          value_node = node.arguments[1]
+          value_node = node.last_argument
+          node_arguments = node.arguments[0...-1]
 
           if value_node.send_type? && value_node.method?(:[]) &&
              node.receiver == value_node.receiver &&
-             !node.first_argument.call_type? &&
-             node.first_argument == value_node.first_argument
+             node_arguments.none?(&:call_type?) &&
+             node_arguments == value_node.arguments
             add_offense(node)
           end
         end

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

@@ -125,13 +125,13 @@ module RuboCop
             next false if assignment_node.shorthand_asgn?
             next false unless assignment_node.parent
 
-            node_within_block_or_conditional =
-              node_within_block_or_conditional?(assignment_node.parent, argument.scope.node)
+            conditional_assignment =
+              conditional_assignment?(assignment_node.parent, argument.scope.node)
 
             unless uses_var?(assignment_node, argument.name)
               # It's impossible to decide whether a branch or block is executed,
               # so the precise reassignment location is undecidable.
-              next false if node_within_block_or_conditional
+              next false if conditional_assignment
 
               yield(assignment.node, location_known)
               break
@@ -147,13 +147,13 @@ module RuboCop
           node.source_range.begin_pos
         end
 
-        # Check whether the given node is nested into block or conditional.
+        # Check whether the given node is always executed or not
         #
-        def node_within_block_or_conditional?(node, stop_search_node)
+        def conditional_assignment?(node, stop_search_node)
           return false if node == stop_search_node
 
-          node.conditional? || node.block_type? ||
-            node_within_block_or_conditional?(node.parent, stop_search_node)
+          node.conditional? || node.type?(:block, :rescue) ||
+            conditional_assignment?(node.parent, stop_search_node)
         end
 
         # Get argument references without assignments' references

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

@@ -17,6 +17,7 @@ module RuboCop
       #
       #   # good
       #   CGI.escape('http://example.com')
+      #   URI.encode_uri_component(uri) # Since Ruby 3.1
       #   URI.encode_www_form([['example', 'param'], ['lang', 'en']])
       #   URI.encode_www_form(page: 10, locale: 'en')
       #   URI.encode_www_form_component('http://example.com')
@@ -27,6 +28,7 @@ module RuboCop
       #
       #   # good
       #   CGI.unescape(enc_uri)
+      #   URI.decode_uri_component(uri) # Since Ruby 3.1
       #   URI.decode_www_form(enc_uri)
       #   URI.decode_www_form_component(enc_uri)
       class UriEscapeUnescape < Base