rubocop 1.79.2 → 1.82.0

data/lib/rubocop/cop/style/safe_navigation.rb

@@ -142,6 +142,7 @@ module RuboCop
         # @!method strip_begin(node)
         def_node_matcher :strip_begin, '{ (begin $!begin) $!(begin) }'
 
+        # rubocop:disable Metrics/AbcSize
         def on_if(node)
           return if allowed_if_condition?(node)
 
@@ -155,9 +156,11 @@ module RuboCop
           removal_ranges = [begin_range(node, body), end_range(node, body)]
 
           report_offense(node, method_chain, method_call, *removal_ranges) do |corrector|
+            corrector.replace(receiver, checked_variable.source) if checked_variable.csend_type?
             corrector.insert_before(method_call.loc.dot, '&') unless method_call.safe_navigation?
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def on_and(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
           collect_and_clauses(node).each do |(lhs, lhs_operator_range), (rhs, _rhs_operator_range)|
@@ -259,8 +262,14 @@ module RuboCop
         end
 
         def dotless_operator_call?(method_call)
+          return true if dotless_operator_method?(method_call)
+
           method_call = method_call.parent while method_call.parent.send_type?
 
+          dotless_operator_method?(method_call)
+        end
+
+        def dotless_operator_method?(method_call)
           return false if method_call.loc.dot
 
           method_call.method?(:[]) || method_call.method?(:[]=) || method_call.operator_method?
@@ -335,8 +344,16 @@ module RuboCop
 
         def matching_call_nodes?(left, right)
           return false unless left && right.respond_to?(:call_type?)
+          return false unless left.call_type? && right.call_type?
+
+          # Compare receiver and method name, but ignore the difference between
+          # safe navigation method call (`&.`) and dot method call (`.`).
+          left_receiver, left_method, *left_args = left.children
+          right_receiver, right_method, *right_args = right.children
 
-          left.call_type? && right.call_type? && left.children == right.children
+          left_method == right_method &&
+            matching_nodes?(left_receiver, right_receiver) &&
+            left_args == right_args
         end
 
         def chain_length(method_chain, method)

data/lib/rubocop/cop/style/semicolon.rb

@@ -69,10 +69,11 @@ module RuboCop
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            semicolon_pos = semicolon_position(tokens)
+            next unless (semicolon_pos = semicolon_position(tokens))
+
             after_expr_pos = semicolon_pos == -1 ? -2 : semicolon_pos
 
-            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos] if semicolon_pos
+            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos]
           end
         end
 
@@ -119,6 +120,7 @@ module RuboCop
           tokens[1]&.type == :tSTRING_DBEG && tokens[2]&.semicolon?
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
           range = source_range(processed_source.buffer, line, column)
 
@@ -130,14 +132,19 @@ module RuboCop
               # without parentheses.
               # See: https://github.com/rubocop/rubocop/issues/10791
               if token_before_semicolon&.regexp_dots?
-                range_node = find_range_node(token_before_semicolon)
-                corrector.wrap(range_node, '(', ')') if range_node
+                node = find_node(range_nodes, token_before_semicolon)
+              elsif token_before_semicolon&.type == :tLABEL
+                node = find_node(value_omission_pair_nodes, token_before_semicolon).parent
+                space = node.parent.loc.selector.end.join(node.source_range.begin)
+                corrector.remove(space)
               end
 
+              corrector.wrap(node, '(', ')') if node
               corrector.remove(range)
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         def expressions_per_line(exprs)
           # create a map matching lines to the number of expressions on them
@@ -153,9 +160,9 @@ module RuboCop
           end
         end
 
-        def find_range_node(token_before_semicolon)
-          range_nodes.detect do |range_node|
-            range_node.source_range.contains?(token_before_semicolon.pos)
+        def find_node(nodes, token_before_semicolon)
+          nodes.detect do |node|
+            node.source_range.overlaps?(token_before_semicolon.pos)
           end
         end
 
@@ -166,6 +173,15 @@ module RuboCop
           @range_nodes = ast.range_type? ? [ast] : []
           @range_nodes.concat(ast.each_descendant(:range).to_a)
         end
+
+        def value_omission_pair_nodes
+          if instance_variable_defined?(:@value_omission_pair_nodes)
+            return @value_omission_pair_nodes
+          end
+
+          ast = processed_source.ast
+          @value_omission_pair_nodes = ast.each_descendant(:pair).to_a.select(&:value_omission?)
+        end
       end
     end
   end

data/lib/rubocop/cop/style/sole_nested_conditional.rb

@@ -129,6 +129,7 @@ module RuboCop
           corrector.remove(range_with_surrounding_space(range, newlines: false))
         end
 
+        # rubocop:disable Metrics/AbcSize
         def correct_for_basic_condition_style(corrector, node, if_branch)
           range = range_between(
             node.condition.source_range.end_pos, if_branch.condition.source_range.begin_pos
@@ -137,8 +138,14 @@ module RuboCop
 
           corrector.replace(if_branch.condition, chainable_condition(if_branch))
 
-          corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
+          end_range = if same_line?(node.loc.end, node.if_branch.loc.end)
+                        node.loc.end
+                      else
+                        range_by_whole_lines(node.loc.end, include_final_newline: true)
+                      end
+          corrector.remove(end_range)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def autocorrect_outer_condition_modify_form(corrector, node, if_branch)
           correct_node(corrector, if_branch)

data/lib/rubocop/cop/style/string_concatenation.rb

@@ -100,7 +100,7 @@ module RuboCop
           node.receiver.str_type? &&
             node.first_argument.str_type? &&
             node.multiline? &&
-            node.source =~ /\+\s*\n/
+            node.source.match?(/\+\s*\n/)
         end
 
         def find_topmost_plus_node(node)
@@ -141,22 +141,26 @@ module RuboCop
         end
 
         def replacement(parts)
-          interpolated_parts = parts.map do |part|
-            case part.type
-            when :str
-              adjust_str(part)
-            when :dstr
-              part.children.all?(&:str_type?) ? adjust_str(part) : part.value
-            else
-              "\#{#{part.source}}"
-            end
-          end
+          interpolated_parts = parts.map { |part| adjust_str(part) }
 
           "\"#{handle_quotes(interpolated_parts).join}\""
         end
 
-        def adjust_str(node)
-          single_quoted?(node) ? node.value.gsub(/(\\|")/, '\\\\\&') : node.value.inspect[1..-2]
+        def adjust_str(part)
+          case part.type
+          when :str
+            if single_quoted?(part)
+              part.value.gsub(/(\\|"|#\{|#@|#\$)/, '\\\\\&')
+            else
+              part.value.inspect[1..-2]
+            end
+          when :dstr, :begin
+            part.children.map do |child|
+              adjust_str(child)
+            end.join
+          else
+            "\#{#{part.source}}"
+          end
         end
 
         def handle_quotes(parts)

data/lib/rubocop/cop/style/super_arguments.rb

@@ -109,7 +109,7 @@ module RuboCop
 
           def_args.zip(super_args).each do |def_arg, super_arg|
             next if positional_arg_same?(def_arg, super_arg)
-            next if positional_rest_arg_same(def_arg, super_arg)
+            next if positional_rest_arg_same?(def_arg, super_arg)
             next if keyword_arg_same?(def_arg, super_arg)
             next if keyword_rest_arg_same?(def_arg, super_arg)
             next if block_arg_same?(def_node, super_node, def_arg, super_arg)
@@ -147,7 +147,7 @@ module RuboCop
           def_arg.name == super_arg.children.first
         end
 
-        def positional_rest_arg_same(def_arg, super_arg)
+        def positional_rest_arg_same?(def_arg, super_arg)
           return false unless def_arg.restarg_type?
           # anonymous forwarding
           return true if def_arg.name.nil? && super_arg.forwarded_restarg_type?

data/lib/rubocop/cop/style/symbol_array.rb

@@ -81,7 +81,7 @@ module RuboCop
 
             content = *sym
             content = content.map { |c| c.is_a?(AST::Node) ? c.source : c }.join
-            content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s\(\)]*\))/, '')
+            content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s()]*\))/, '')
 
             content.include?(' ') || DELIMITERS.any? do |delimiter|
               content_without_delimiter_pairs.include?(delimiter)

data/lib/rubocop/cop/style/trailing_comma_in_arguments.rb

@@ -10,6 +10,9 @@ module RuboCop
       # for all parenthesized multi-line method calls with arguments.
       # * `comma`: Requires a comma after the last argument, but only for
       # parenthesized method calls where each argument is on its own line.
+      # * `diff_comma`: 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 on the same line.
       # * `no_comma`: Requires that there is no comma after the last
       # argument.
       #
@@ -75,6 +78,48 @@ module RuboCop
       #     2,
       #   )
       #
+      # @example EnforcedStyleForMultiline: diff_comma
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # good
+      #   method(1, 2)
+      #
+      #   # good
+      #   method(
+      #     1, 2,
+      #     3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1, 2, 3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1,
+      #     2,
+      #   )
+      #
+      #   # bad
+      #   method(1, [
+      #     2,
+      #   ],)
+      #
+      #   # good
+      #   method(1, [
+      #     2,
+      #   ])
+      #
+      #   # bad
+      #   object[1, 2,
+      #          3, 4,]
+      #
+      #   # good
+      #   object[1, 2,
+      #          3, 4]
+      #
       # @example EnforcedStyleForMultiline: no_comma (default)
       #   # bad
       #   method(1, 2,)

data/lib/rubocop/cop/style/trailing_underscore_variable.rb

@@ -7,26 +7,26 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   a, b, _ = foo()
-      #   a, b, _, = foo()
-      #   a, _, _ = foo()
-      #   a, _, _, = foo()
+      #   a, b, _ = foo
+      #   a, b, _, = foo
+      #   a, _, _ = foo
+      #   a, _, _, = foo
       #
       #   # good
-      #   a, b, = foo()
-      #   a, = foo()
-      #   *a, b, _ = foo()
+      #   a, b, = foo
+      #   a, = foo
+      #   *a, b, _ = foo
       #   # => We need to know to not include 2 variables in a
-      #   a, *b, _ = foo()
-      #   # => The correction `a, *b, = foo()` is a syntax error
+      #   a, *b, _ = foo
+      #   # => The correction `a, *b, = foo` is a syntax error
       #
       # @example AllowNamedUnderscoreVariables: true (default)
       #   # good
-      #   a, b, _something = foo()
+      #   a, b, _something = foo
       #
       # @example AllowNamedUnderscoreVariables: false
       #   # bad
-      #   a, b, _something = foo()
+      #   a, b, _something = foo
       #
       class TrailingUnderscoreVariable < Base
         include SurroundingSpace

data/lib/rubocop/cop/style/unless_else.rb

@@ -20,7 +20,6 @@ module RuboCop
       #     # do a different thing...
       #   end
       class UnlessElse < Base
-        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Do not use `unless` with `else`. Rewrite these with the positive case first.'
@@ -29,25 +28,27 @@ module RuboCop
           return unless node.unless? && node.else?
 
           add_offense(node) do |corrector|
-            body_range = range_between_condition_and_else(node, node.condition)
-            else_range = range_between_else_and_end(node)
-
             next if part_of_ignored_node?(node)
 
             corrector.replace(node.loc.keyword, 'if')
-            corrector.replace(body_range, else_range.source)
-            corrector.replace(else_range, body_range.source)
+
+            body_range = range_between_condition_and_else(node)
+            else_range = range_between_else_and_end(node)
+
+            corrector.swap(body_range, else_range)
           end
 
           ignore_node(node)
         end
 
-        def range_between_condition_and_else(node, condition)
-          range_between(condition.source_range.end_pos, node.loc.else.begin_pos)
+        def range_between_condition_and_else(node)
+          range = node.loc.begin ? node.loc.begin.end : node.condition.source_range
+
+          range.end.join(node.loc.else.begin)
         end
 
         def range_between_else_and_end(node)
-          range_between(node.loc.else.end_pos, node.loc.end.begin_pos)
+          node.loc.else.end.join(node.loc.end.begin)
         end
       end
     end

data/lib/rubocop/cop/util.rb

@@ -117,10 +117,9 @@ module RuboCop
       # with calls chained to the end of it.
       def first_part_of_call_chain(node)
         while node
-          case node.type
-          when :send
+          if node.call_type?
             node = node.receiver
-          when :block
+          elsif node.any_block_type?
             node = node.send_node
           else
             break

data/lib/rubocop/cop/utils/format_string.rb

@@ -71,6 +71,16 @@ module RuboCop
             name && @source.include?('{')
           end
 
+          def variable_width?
+            !!width&.start_with?('*')
+          end
+
+          def variable_width_argument_number
+            return unless variable_width?
+
+            width == '*' ? 1 : width.match(DIGIT_DOLLAR)['arg_number'].to_i
+          end
+
           # Number of arguments required for the format sequence
           def arity
             @source.scan('*').count + 1

data/lib/rubocop/cop/variable_force/variable.rb

@@ -79,7 +79,7 @@ module RuboCop
           parent = parent.parent if parent&.begin_type?
           return false if parent.nil?
 
-          parent.type?(:if, :while, :until) && parent.modifier_form?
+          parent.basic_conditional? && parent.modifier_form?
         end
 
         def capture_with_block!

data/lib/rubocop/cop/variable_force.rb

@@ -238,11 +238,16 @@ module RuboCop
       end
 
       def process_loop(node)
-        if POST_CONDITION_LOOP_TYPES.include?(node.type)
+        if node.post_condition_loop?
           # See the comment at the end of file for this behavior.
           condition_node, body_node = *node
           process_node(body_node)
           process_node(condition_node)
+        elsif node.for_type?
+          # In `for item in items` the rightmost expression is evaluated first.
+          process_node(node.collection)
+          process_node(node.variable)
+          process_node(node.body) if node.body
         else
           process_children(node)
         end
@@ -356,17 +361,14 @@ module RuboCop
       end
 
       def reference_assignments(loop_assignments, loop_node)
-        node = loop_assignments.first.node
-
         # If inside a branching statement, mark all as referenced.
         # Otherwise, mark only the last assignment as referenced.
         # Note that `rescue` must be considered as branching because of
         # the `retry` keyword.
-        if node.each_ancestor(*BRANCH_NODES).any? || node.parent.each_descendant(*BRANCH_NODES).any?
-          loop_assignments.each { |assignment| assignment.reference!(loop_node) }
-        else
-          loop_assignments.last&.reference!(loop_node)
+        loop_assignments.each do |assignment|
+          assignment.reference!(loop_node) if assignment.node.each_ancestor(*BRANCH_NODES).any?
         end
+        loop_assignments.last&.reference!(loop_node)
       end
 
       def scanned_node?(node)

data/lib/rubocop/cops_documentation_generator.rb

@@ -194,10 +194,10 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
 
   def configurations(department, cop, cop_config)
     header = ['Name', 'Default value', 'Configurable values']
-    configs = cop_config
-              .each_key
-              .reject { |key| key.start_with?('Supported') }
-              .reject { |key| key.start_with?('AllowMultipleStyles') }
+    configs = cop_config.each_key.reject do |key|
+      key == 'AllowMultipleStyles' ||
+        (key != 'SupportedTypes' && key.start_with?('Supported'))
+    end
     return '' if configs.empty?
 
     content = configs.map do |name|

data/lib/rubocop/directive_comment.rb

@@ -14,11 +14,17 @@ module RuboCop
     # @api private
     COP_NAME_PATTERN = '([A-Za-z]\w+/)*(?:[A-Za-z]\w+)'
     # @api private
+    COP_NAME_PATTERN_NC = '(?:[A-Za-z]\w+/)*[A-Za-z]\w+'
+    # @api private
+    COP_NAMES_PATTERN_NC = "(?:#{COP_NAME_PATTERN_NC} , )*#{COP_NAME_PATTERN_NC}"
+    # @api private
     COP_NAMES_PATTERN = "(?:#{COP_NAME_PATTERN} , )*#{COP_NAME_PATTERN}"
     # @api private
     COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})"
     # @api private
-    AVAILABLE_MODES = %w[disable enable todo].freeze
+    PUSH_POP_ARGS_PATTERN = "([+\\-]#{COP_NAME_PATTERN_NC}(?:\\s+[+\\-]#{COP_NAME_PATTERN_NC})*)"
+    # @api private
+    AVAILABLE_MODES = %w[disable enable todo push pop].freeze
     # @api private
     DIRECTIVE_MARKER_PATTERN = '# rubocop : '
     # @api private
@@ -27,7 +33,7 @@ module RuboCop
     DIRECTIVE_HEADER_PATTERN = "#{DIRECTIVE_MARKER_PATTERN}((?:#{AVAILABLE_MODES.join('|')}))\\b"
     # @api private
     DIRECTIVE_COMMENT_REGEXP = Regexp.new(
-      "#{DIRECTIVE_HEADER_PATTERN} #{COPS_PATTERN}"
+      "#{DIRECTIVE_HEADER_PATTERN}(?:\\s+#{COPS_PATTERN}|\\s+#{PUSH_POP_ARGS_PATTERN})?"
         .gsub(' ', '\s*')
     )
     # @api private
@@ -58,6 +64,7 @@ module RuboCop
     # Checks if the comment is malformed as a `# rubocop:` directive
     def malformed?
       return true if !start_with_marker? || @match_data.nil?
+      return true if missing_cop_name?
 
       tail = @match_data.post_match.lstrip
       !(tail.empty? || tail.start_with?(TRAILING_COMMENT_MARKER))
@@ -65,6 +72,8 @@ module RuboCop
 
     # Checks if the directive comment is missing a cop name
     def missing_cop_name?
+      return false if push? || pop?
+
       MALFORMED_DIRECTIVE_WITHOUT_COP_NAME_REGEXP.match?(comment.text)
     end
 
@@ -88,7 +97,13 @@ module RuboCop
 
     # Returns match captures to directive comment pattern
     def match_captures
-      @match_captures ||= @match_data&.captures
+      @match_captures ||= @match_data && begin
+        captures = @match_data.captures
+        mode = captures[0]
+        # COPS_PATTERN is at captures[1], PUSH_POP_ARGS_PATTERN is at captures[4]
+        cops = captures[1] || captures[4]
+        [mode, cops]
+      end
     end
 
     # Checks if this directive disables cops
@@ -101,6 +116,21 @@ module RuboCop
       mode == 'enable'
     end
 
+    # Checks if this directive is a push
+    def push?
+      mode == 'push'
+    end
+
+    # Checks if this directive is a pop
+    def pop?
+      mode == 'pop'
+    end
+
+    # Returns the push arguments as a hash of cop names with their operations
+    def push_args
+      @push_args ||= parse_push_args
+    end
+
     # Checks if this directive enables all cops
     def enabled_all?
       !disabled? && all_cops?
@@ -176,5 +206,18 @@ module RuboCop
     def exclude_lint_department_cops(cops)
       cops - [LINT_REDUNDANT_DIRECTIVE_COP, LINT_SYNTAX_COP]
     end
+
+    def parse_push_args
+      return {} unless push? && cops
+
+      args = {}
+      cops.split.each do |cop_spec|
+        op = cop_spec[0]
+        cop_name = cop_spec[1..]
+        args[op] ||= []
+        args[op] << cop_name
+      end
+      args
+    end
   end
 end

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Formatter
     # This formatter displays a YAML configuration file where all cops that
     # detected any offenses are configured to not detect the offense.
-    class DisabledConfigFormatter < BaseFormatter
+    class DisabledConfigFormatter < BaseFormatter # rubocop:disable Metrics/ClassLength
       include PathUtil
 
       HEADING = <<~COMMENTS
@@ -17,6 +17,23 @@ module RuboCop
         # versions of RuboCop, may require this file to be generated again.
       COMMENTS
 
+      EXCLUDED_CONFIG_KEYS = %w[
+        AutoCorrect
+        Description
+        Enabled
+        Exclude
+        Include
+        Reference
+        References
+        Safe
+        SafeAutoCorrect
+        Severity
+        StyleGuide
+        VersionAdded
+        VersionChanged
+        VersionRemoved
+      ].freeze
+
       @config_to_allow_offenses = {}
       @detected_styles = {}
 
@@ -163,10 +180,7 @@ module RuboCop
       end
 
       def cop_config_params(default_cfg, cfg)
-        default_cfg.keys -
-          %w[Description StyleGuide Reference References Enabled Exclude Safe
-             SafeAutoCorrect VersionAdded VersionChanged VersionRemoved] -
-          cfg.keys
+        default_cfg.keys - EXCLUDED_CONFIG_KEYS - cfg.keys
       end
 
       def output_cop_param_comments(output_buffer, params, default_cfg)

data/lib/rubocop/lsp/diagnostic.rb

@@ -45,11 +45,11 @@ module RuboCop
           range: LanguageServer::Protocol::Interface::Range.new(
             start: LanguageServer::Protocol::Interface::Position.new(
               line: @offense.line - 1,
-              character: highlighted.begin_pos
+              character: to_position_character(highlighted.begin_pos)
             ),
             end: LanguageServer::Protocol::Interface::Position.new(
               line: @offense.line - 1,
-              character: highlighted.end_pos
+              character: to_position_character(highlighted.end_pos)
             )
           ),
           data: {
@@ -107,11 +107,11 @@ module RuboCop
             range: LanguageServer::Protocol::Interface::Range.new(
               start: LanguageServer::Protocol::Interface::Position.new(
                 line: range.line - 1,
-                character: range.column
+                character: to_position_character(range.column)
               ),
               end: LanguageServer::Protocol::Interface::Position.new(
                 line: range.last_line - 1,
-                character: range.last_column
+                character: to_position_character(range.last_column)
               )
             ),
             new_text: replacement
@@ -149,7 +149,7 @@ module RuboCop
 
         eol = LanguageServer::Protocol::Interface::Position.new(
           line: @offense.line - 1,
-          character: length_of_line(@offense.source_line)
+          character: to_position_character(@offense.source_line.length)
         )
 
         # TODO: fails for multiline strings - may be preferable to use block
@@ -162,16 +162,12 @@ module RuboCop
         [inline_comment]
       end
 
-      def length_of_line(line)
-        if @document_encoding == Encoding::UTF_16LE
-          line_length = 0
-          line.codepoints.each do |codepoint|
-            line_length += 1
-            line_length += 1 if codepoint > RubyLsp::Document::Scanner::SURROGATE_PAIR_START
-          end
-          line_length
+      def to_position_character(utf8_index)
+        str = @offense.source_line[0, utf8_index]
+        if @document_encoding == Encoding::UTF_16LE || @document_encoding.nil?
+          str.length + str.b.count("\xf0-\xff".b)
         else
-          line.length
+          str.length
         end
       end