rubocop 1.81.1 → 1.81.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e194323f7062efb4f5777f4039ff475256dfa86b6e95dd63f42f682b3e59a55
-  data.tar.gz: 533b2e1fe940252958b245c2d492e0e4b39e37babd9e918fbc3ee505faf030ac
+  metadata.gz: 8acfafa4ed4b94c367e6ef95c84d2d02f01222a1e8a813790948977476f34456
+  data.tar.gz: 0d2ad56c4a81da58046a098351606bfb8314f09f9e5f946ad1dd825aa70fe0f7
 SHA512:
-  metadata.gz: c4bbe12c2a1c627b8f4938a3cc52cd3e4c51ee334b8f1d3b2c373dd109c20741721c090b9152ef2e3f8a908f95c90cc7d8021ba48a1354884361219880153581
-  data.tar.gz: 0ee2973781e011caf6069a9072f8f6a59196d0430fe3d90af740bc2795423d4ead9fc62ddbe11bfe2be8230b769446e734eebcf461c494bb2921a3fb16135c7c
+  metadata.gz: ae4edea22ca7511df39ec99591df3d537bfd3fa8974d5bb461d2b1c674b48f15296f22c81b1cd9329719a68b0d3f8d36442eaa5742cbf8e0974c6e3e2e56e29c
+  data.tar.gz: ffce467cec50d2ed0ef7b312a15dd17e9b7fd1622b70528d12f0cfe16056ae3b5111f2d360b4e855ea5811befd092a306ff56ad091b89a6050f3354f3db205a4

data/config/default.yml

@@ -275,7 +275,7 @@ Gemspec/AddRuntimeDependency:
   Description: 'Prefer `add_dependency` over `add_runtime_dependency`.'
   StyleGuide: '#add_dependency_vs_add_runtime_dependency'
   References:
-    - https://github.com/rubygems/rubygems/issues/7799#issuecomment-2192720316
+    - https://github.com/ruby/rubygems/issues/7799#issuecomment-2192720316
   Enabled: pending
   VersionAdded: '1.65'
   Include:
@@ -3207,6 +3207,7 @@ Security/JSONLoad:
                  security issues. See reference for more information.
   References:
     - 'https://ruby-doc.org/stdlib-2.7.0/libdoc/json/rdoc/JSON.html#method-i-load'
+    - 'https://bugs.ruby-lang.org/issues/19528'
   Enabled: true
   VersionAdded: '0.43'
   VersionChanged: '1.22'
@@ -4552,8 +4553,9 @@ Style/LambdaCall:
   Description: 'Use lambda.call(...) instead of lambda.(...).'
   StyleGuide: '#proc-call'
   Enabled: true
+  AutoCorrect: contextual
   VersionAdded: '0.13'
-  VersionChanged: '0.14'
+  VersionChanged: '1.81'
   EnforcedStyle: call
   SupportedStyles:
     - call

data/lib/rubocop/config_loader_resolver.rb

@@ -295,10 +295,11 @@ module RuboCop
         begin
           gem = Bundler.load.specs[gem_name].first
           gem_path = gem.full_gem_path if gem
-        rescue Bundler::GemfileNotFound
-          # No Gemfile found. Bundler may be loaded manually
-        rescue Bundler::GitError
-          # The Gemfile exists but contains an uninstalled git source
+        rescue StandardError
+          # The Gemfile has a problem, which could be one of:
+          # - No Gemfile found. Bundler may be loaded manually
+          # - The Gemfile exists but contains an uninstalled git source
+          # - The Gemfile exists but cannot be loaded for some other reason
         end
       end
 

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

@@ -193,7 +193,6 @@ module RuboCop
         SEPARATOR_ALIGNMENT_STYLES = %w[EnforcedColonStyle EnforcedHashRocketStyle].freeze
 
         def on_send(node)
-          return if double_splat?(node)
           return unless node.arguments?
 
           last_argument = node.last_argument
@@ -233,6 +232,8 @@ module RuboCop
         end
 
         def argument_before_hash(hash_node)
+          return hash_node.children.first.children.first if hash_node.children.first.kwsplat_type?
+
           hash_node.left_sibling.respond_to?(:loc) ? hash_node.left_sibling : nil
         end
 
@@ -241,10 +242,6 @@ module RuboCop
           self.column_deltas = Hash.new { |hash, key| hash[key] = {} }
         end
 
-        def double_splat?(node)
-          node.children.last.is_a?(Symbol)
-        end
-
         def check_pairs(node)
           first_pair = node.pairs.first
           reset!

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

@@ -31,7 +31,7 @@ module RuboCop
 
         # @!method overwritten_constant(node)
         def_node_matcher :overwritten_constant, <<~PATTERN
-          (resbody nil? (casgn nil? $_) nil?)
+          (resbody nil? $(casgn _ _) nil?)
         PATTERN
 
         def self.autocorrect_incompatible_with
@@ -41,7 +41,8 @@ module RuboCop
         def on_resbody(node)
           return unless (constant = overwritten_constant(node))
 
-          add_offense(node.loc.assoc, message: format(MSG, constant: constant)) do |corrector|
+          message = format(MSG, constant: constant.source)
+          add_offense(node.loc.assoc, message: message) do |corrector|
             corrector.remove(range_between(node.loc.keyword.end_pos, node.loc.assoc.end_pos))
           end
         end

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

@@ -13,28 +13,34 @@ module RuboCop
       # @example
       #   # bad
       #   # rubocop:disable Layout/LineLength Style/Encoding
-      #   #                                  ^ missing comma
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength, Style/Encoding
       #
       #   # bad
       #   # rubocop:disable
       #
+      #   # good
+      #   # rubocop:disable all
+      #
       #   # bad
       #   # rubocop:disable Layout/LineLength # rubocop:disable Style/Encoding
       #
+      #   # good
+      #   # rubocop:disable Layout/LineLength
+      #   # rubocop:disable Style/Encoding
+      #
       #   # bad
       #   # rubocop:wrongmode Layout/LineLength
       #
       #   # good
       #   # rubocop:disable Layout/LineLength
       #
-      #   # good
-      #   # rubocop:disable Layout/LineLength, Style/Encoding
-      #
-      #   # good
-      #   # rubocop:disable all
+      #   # bad
+      #   # rubocop:disable Layout/LineLength comment
       #
       #   # good
-      #   # rubocop:disable Layout/LineLength -- This is a good comment.
+      #   # rubocop:disable Layout/LineLength -- comment
       #
       class CopDirectiveSyntax < Base
         COMMON_MSG = 'Malformed directive comment detected.'

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

@@ -102,8 +102,6 @@ module RuboCop
         end
 
         def debugger_method?(send_node)
-          return false if send_node.parent&.send_type? && send_node.parent.receiver == send_node
-
           debugger_methods.include?(chained_method_name(send_node))
         end
 

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

@@ -19,12 +19,23 @@ module RuboCop
         MSG = 'Empty interpolation detected.'
 
         def on_interpolation(begin_node)
+          return if in_percent_literal_array?(begin_node)
+
           node_children = begin_node.children.dup
           node_children.delete_if { |e| e.nil_type? || (e.basic_literal? && e.str_content&.empty?) }
           return unless node_children.empty?
 
           add_offense(begin_node) { |corrector| corrector.remove(begin_node) }
         end
+
+        private
+
+        def in_percent_literal_array?(begin_node)
+          array_node = begin_node.each_ancestor(:array).first
+          return false unless array_node
+
+          array_node.percent_literal?
+        end
       end
     end
   end

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

@@ -9,9 +9,21 @@ module RuboCop
       # cop disables on wide ranges of code, that latter contributors to
       # a file wouldn't be aware of.
       #
-      # @example
-      #   # Lint/MissingCopEnableDirective:
-      #   #   MaximumRangeSize: .inf
+      # You can set `MaximumRangeSize` to define the maximum number of
+      # consecutive lines a cop can be disabled for.
+      #
+      # - `.inf` any size (default)
+      # - `0` allows only single-line disables
+      # - `1` means the maximum allowed is as follows:
+      #
+      # [source,ruby]
+      # ----
+      # # rubocop:disable SomeCop
+      # a = 1
+      # # rubocop:enable SomeCop
+      # ----
+      #
+      # @example MaximumRangeSize: .inf (default)
       #
       #   # good
       #   # rubocop:disable Layout/SpaceAroundOperators
@@ -25,9 +37,7 @@ module RuboCop
       #   x= 0
       #   # EOF
       #
-      # @example
-      #   # Lint/MissingCopEnableDirective:
-      #   #   MaximumRangeSize: 2
+      # @example MaximumRangeSize: 2
       #
       #   # good
       #   # rubocop:disable Layout/SpaceAroundOperators

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

@@ -24,10 +24,7 @@ module RuboCop
         MSG = 'Avoid rescuing the `Exception` class. Perhaps you meant to rescue `StandardError`?'
 
         def on_resbody(node)
-          return unless node.children.first
-
-          rescue_args = node.children.first.children
-          return unless rescue_args.any? { |a| targets_exception?(a) }
+          return unless node.exceptions.any? { |exception| targets_exception?(exception) }
 
           add_offense(node)
         end

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

@@ -108,7 +108,7 @@ module RuboCop
           value_node = node.last_argument
           node_arguments = node.arguments[0...-1]
 
-          if value_node.send_type? && value_node.method?(:[]) &&
+          if value_node.respond_to?(:method?) && value_node.method?(:[]) &&
              node.receiver == value_node.receiver &&
              node_arguments.none?(&:call_type?) &&
              node_arguments == value_node.arguments

data/lib/rubocop/cop/naming/method_name.rb

@@ -147,7 +147,9 @@ module RuboCop
         alias on_defs on_def
 
         def on_alias(node)
-          handle_method_name(node.new_identifier, node.new_identifier.value)
+          return unless (new_identifier = node.new_identifier).sym_type?
+
+          handle_method_name(new_identifier, new_identifier.value)
         end
 
         private

data/lib/rubocop/cop/naming/predicate_method.rb

@@ -193,8 +193,7 @@ module RuboCop
             return_values << extract_return_value(return_node)
           end
 
-          last_value = last_value(node)
-          return_values << last_value if last_value
+          return_values << last_value(node)
 
           process_return_values(return_values)
         end
@@ -247,8 +246,9 @@ module RuboCop
         end
 
         def last_value(node)
-          value = node.begin_type? ? node.children.last : node
-          value&.return_type? ? extract_return_value(value) : value
+          value = node.begin_type? ? node.children.last || s(:nil) : node
+
+          value.return_type? ? extract_return_value(value) : value
         end
 
         def process_return_values(return_values)

data/lib/rubocop/cop/security/json_load.rb

@@ -6,22 +6,40 @@ module RuboCop
       # Checks for the use of JSON class methods which have potential
       # security issues.
       #
+      # `JSON.load` and similar methods allow deserialization of arbitrary ruby objects:
+      #
+      # [source,ruby]
+      # ----
+      # require 'json/add/string'
+      # result = JSON.load('{ "json_class": "String", "raw": [72, 101, 108, 108, 111] }')
+      # pp result # => "Hello"
+      # ----
+      #
+      # Never use `JSON.load` for untrusted user input. Prefer `JSON.parse` unless you have
+      # a concrete use-case for `JSON.load`.
+      #
+      # NOTE: Starting with `json` gem version 2.8.0, triggering this behavior without explicitly
+      # passing the `create_additions` keyword argument emits a deprecation warning, with the
+      # goal of being secure by default in the next major version 3.0.0.
+      #
       # @safety
       #   This cop's autocorrection is unsafe because it's potentially dangerous.
-      #   If using a stream, like `JSON.load(open('file'))`, it will need to call
+      #   If using a stream, like `JSON.load(open('file'))`, you will need to call
       #   `#read` manually, like `JSON.parse(open('file').read)`.
-      #   If reading single values (rather than proper JSON objects), like
-      #   `JSON.load('false')`, it will need to pass the `quirks_mode: true`
-      #   option, like `JSON.parse('false', quirks_mode: true)`.
       #   Other similar issues may apply.
       #
       # @example
       #   # bad
-      #   JSON.load("{}")
-      #   JSON.restore("{}")
+      #   JSON.load('{}')
+      #   JSON.restore('{}')
       #
       #   # good
-      #   JSON.parse("{}")
+      #   JSON.parse('{}')
+      #   JSON.unsafe_load('{}')
+      #
+      #   # good - explicit use of `create_additions` option
+      #   JSON.load('{}', create_additions: true)
+      #   JSON.load('{}', create_additions: false)
       #
       class JSONLoad < Base
         extend AutoCorrector
@@ -29,13 +47,17 @@ module RuboCop
         MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'
         RESTRICT_ON_SEND = %i[load restore].freeze
 
-        # @!method json_load(node)
-        def_node_matcher :json_load, <<~PATTERN
-          (send (const {nil? cbase} :JSON) ${:load :restore} ...)
+        # @!method insecure_json_load(node)
+        def_node_matcher :insecure_json_load, <<~PATTERN
+          (
+            send (const {nil? cbase} :JSON) ${:load :restore}
+            ...
+            !(hash `(sym $:create_additions))
+          )
         PATTERN
 
         def on_send(node)
-          json_load(node) do |method|
+          insecure_json_load(node) do |method|
             add_offense(node.loc.selector, message: format(MSG, method: method)) do |corrector|
               corrector.replace(node.loc.selector, 'parse')
             end

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

@@ -95,7 +95,7 @@ module RuboCop
           $(call
             {
               (begin (send $_ :& $_))
-              (call $_ :intersection $_)
+              (call $!nil? :intersection $_)
             }
             $%1
           )
@@ -107,7 +107,7 @@ module RuboCop
             $(call
               {
                 (begin (send $_ :& $_))
-                (call $_ :intersection $_)
+                (call $!nil? :intersection $_)
               }
               %ARRAY_SIZE_METHODS
             )

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

@@ -444,7 +444,7 @@ module RuboCop
             next if child.parent.dstr_type?
 
             white_space = white_space_range(child, column)
-            corrector.remove(white_space) if white_space.source.strip.empty?
+            corrector.remove(white_space) if white_space
           end
 
           if condition.loc.else && !same_line?(condition.else_branch, condition)
@@ -465,9 +465,13 @@ module RuboCop
 
         def white_space_range(node, column)
           expression = node.source_range
-          begin_pos = expression.begin_pos - (expression.column - column - 2)
+          end_pos = expression.begin_pos
+          begin_pos = end_pos - (expression.column - column - 2)
 
-          Parser::Source::Range.new(expression.source_buffer, begin_pos, expression.begin_pos)
+          return nil if begin_pos > end_pos
+
+          white_space = Parser::Source::Range.new(expression.source_buffer, begin_pos, end_pos)
+          white_space if white_space.source.strip.empty?
         end
 
         def assignment(node)

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

@@ -48,6 +48,11 @@ module RuboCop
         MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
               'either `#public_constant` or `#private_constant`.'
 
+        # @!method visibility_declaration_for(node)
+        def_node_matcher :visibility_declaration_for, <<~PATTERN
+          (send nil? {:public_constant :private_constant} $...)
+        PATTERN
+
         def on_casgn(node)
           return unless class_or_module_scope?(node)
           return if visibility_declaration?(node)
@@ -77,20 +82,20 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         def visibility_declaration?(node)
           node.parent.each_child_node(:send).any? do |child|
-            visibility_declaration_for?(child, node.name)
-          end
-        end
+            next false unless (arguments = visibility_declaration_for(child))
 
-        # @!method visibility_declaration_for?(node, const_name)
-        def_node_matcher :visibility_declaration_for?, <<~PATTERN
-          (send nil? {:public_constant :private_constant} ({sym str} #match_name?(%1)))
-        PATTERN
+            arguments = arguments.first.children.first.to_a if arguments.first&.splat_type?
+            constant_values = arguments.map do |argument|
+              argument.value.to_sym if argument.respond_to?(:value)
+            end
 
-        def match_name?(name, constant_name)
-          name.to_sym == constant_name.to_sym
+            constant_values.include?(node.name)
+          end
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -144,7 +144,7 @@ module RuboCop
         MSG_REQUIRE_ALWAYS = 'Use endless method definitions.'
 
         def on_def(node)
-          return if node.assignment_method?
+          return if node.assignment_method? || use_heredoc?(node)
 
           case style
           when :allow_single_line, :allow_always
@@ -198,6 +198,13 @@ module RuboCop
           add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
         end
 
+        def use_heredoc?(node)
+          return false unless (body = node.body)
+          return true if body.str_type? && body.heredoc?
+
+          body.each_descendant(:str).any?(&:heredoc?)
+        end
+
         def correct_to_multiline(corrector, node)
           replacement = <<~RUBY.strip
             def #{node.method_name}#{arguments(node)}
@@ -225,7 +232,13 @@ module RuboCop
         def too_long_when_made_endless?(node)
           return false unless config.cop_enabled?('Layout/LineLength')
 
-          endless_replacement(node).length > config.for_cop('Layout/LineLength')['Max']
+          offset = modifier_offset(node)
+
+          endless_replacement(node).length + offset > config.for_cop('Layout/LineLength')['Max']
+        end
+
+        def modifier_offset(node)
+          same_line?(node.parent, node) ? node.loc.column - node.parent.loc.column : 0
         end
       end
     end

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

@@ -7,9 +7,12 @@ module RuboCop
       # It is recommended to either always use `fdiv` or coerce one side only.
       # This cop also provides other options for code consistency.
       #
+      # For `Regexp.last_match` and nth reference (e.g., `$1`), it assumes that the value
+      # is a string matched by a regular expression, and allows conversion with `#to_f`.
+      #
       # @safety
       #   This cop is unsafe, because if the operand variable is a string object
-      #   then `.to_f` will be removed and an error will occur.
+      #   then `#to_f` will be removed and an error will occur.
       #
       #   [source,ruby]
       #   ----
@@ -84,6 +87,14 @@ module RuboCop
           (send !nil? :to_f)
         PATTERN
 
+        # @!method regexp_last_match?(node)
+        def_node_matcher :regexp_last_match?, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Regexp) :last_match int)
+            (:nth_ref _)
+          }
+        PATTERN
+
         def on_send(node)
           return unless offense_condition?(node)
 
@@ -104,6 +115,9 @@ module RuboCop
         private
 
         def offense_condition?(node)
+          return false if regexp_last_match?(node.receiver.receiver) ||
+                          regexp_last_match?(node.first_argument.receiver)
+
           case style
           when :left_coerce
             right_coerce?(node)

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

@@ -55,19 +55,21 @@ module RuboCop
         include OnNormalIfUnless
         extend AutoCorrector
 
-        MSG = 'Favor the ternary operator (`?:`) or multi-line constructs ' \
-              'over single-line `%<keyword>s/then/else/end` constructs.'
+        MSG_SUFFIX = 'over single-line `%<keyword>s/then/else/end` constructs.'
+        MSG_TERNARY = "Favor the ternary operator (`?:`) #{MSG_SUFFIX}"
+        MSG_MULTILINE = "Favor multi-line `%<keyword>s` #{MSG_SUFFIX}"
 
         def on_normal_if_unless(node)
           return unless node.single_line?
           return unless node.else_branch
           return if node.elsif? || node.if_branch&.begin_type?
 
-          message = message(node)
-          add_offense(node, message: message) do |corrector|
+          multiline = multiline?(node)
+
+          add_offense(node, message: message(node, multiline)) do |corrector|
             next if part_of_ignored_node?(node)
 
-            autocorrect(corrector, node)
+            autocorrect(corrector, node, multiline)
 
             ignore_node(node)
           end
@@ -75,12 +77,18 @@ module RuboCop
 
         private
 
-        def message(node)
-          format(MSG, keyword: node.keyword)
+        def multiline?(node)
+          always_multiline? || cannot_replace_to_ternary?(node)
+        end
+
+        def message(node, multiline)
+          template = multiline ? MSG_MULTILINE : MSG_TERNARY
+
+          format(template, keyword: node.keyword)
         end
 
-        def autocorrect(corrector, node)
-          if always_multiline? || cannot_replace_to_ternary?(node)
+        def autocorrect(corrector, node, multiline)
+          if multiline
             IfThenCorrector.new(node, indentation: configured_indentation_width).call(corrector)
           else
             corrector.replace(node, ternary_correction(node))

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

@@ -89,7 +89,7 @@ module RuboCop
 
         def on_send(node)
           format_without_additional_args?(node) do |value|
-            replacement = value.source
+            replacement = escape_control_chars(value.source)
 
             add_offense(node, message: message(node, replacement)) do |corrector|
               corrector.replace(node, replacement)
@@ -134,7 +134,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def all_fields_literal?(string, arguments)
           count = 0
           sequences = RuboCop::Cop::Utils::FormatString.new(string).format_sequences
@@ -147,13 +147,14 @@ module RuboCop
             hash = arguments.detect(&:hash_type?)
             next unless (argument = find_argument(sequence, arguments, hash))
             next unless matching_argument?(sequence, argument)
+            next if (sequence.width || sequence.precision) && argument.dstr_type?
 
             count += 1
           end
 
           sequences.size == count
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         # If the sequence has a variable (`*`) width, it cannot be autocorrected
         # if the width is not given as a numeric literal argument
@@ -229,7 +230,12 @@ module RuboCop
             end
           end
 
-          "#{start_delimiter}#{string}#{end_delimiter}"
+          "#{start_delimiter}#{escape_control_chars(string)}#{end_delimiter}"
+        end
+
+        # Escape any control characters in the string (eg. `\t` or `\n` become `\\t` or `\\n`)
+        def escape_control_chars(string)
+          string.gsub(/\p{Cc}/) { |s| s.dump[1..-2] }
         end
 
         def argument_values(arguments)

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

@@ -49,9 +49,10 @@ module RuboCop
         def on_dstr(node)
           return unless single_interpolation?(node)
 
-          add_offense(node) do |corrector|
-            embedded_node = node.children.first
+          embedded_node = node.children.first
+          return if use_match_pattern?(embedded_node)
 
+          add_offense(node) do |corrector|
             if variable_interpolation?(embedded_node)
               autocorrect_variable_interpolation(corrector, embedded_node, node)
             elsif single_variable_interpolation?(embedded_node)
@@ -71,6 +72,14 @@ module RuboCop
             !embedded_in_percent_array?(node)
         end
 
+        def use_match_pattern?(node)
+          return false if target_ruby_version <= 2.7
+
+          node.children.any? do |child|
+            child.respond_to?(:match_pattern_type?) && child.match_pattern_type?
+          end
+        end
+
         def single_variable_interpolation?(node)
           return false unless node.children.one?
 

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/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/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.81.1'
+    STRING = '1.81.7'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \

metadata

@@ -1,16 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.81.1
+  version: 1.81.7
 platform: ruby
 authors:
 - Bozhidar Batsov
 - Jonas Arvidsson
 - Yuji Nakayama
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-26 00:00:00.000000000 Z
+date: 2025-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -1092,12 +1091,11 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://rubocop.org/
-  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.81.1
+  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.81.7
   source_code_uri: https://github.com/rubocop/rubocop/
   documentation_uri: https://docs.rubocop.org/rubocop/1.81/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -1112,8 +1110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Automatic Ruby code style checking tool.
 test_files: []