rubocop 1.92.1 → 1.92.2

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

@@ -74,7 +74,7 @@ module RuboCop
 
           arguments = [exception_node, message_node].compact.map(&:source).join(', ')
 
-          if node.parent && requires_parens?(node.parent)
+          if parenthesize?(node)
             "#{node.method_name}(#{arguments})"
           else
             "#{node.method_name} #{arguments}"
@@ -86,28 +86,60 @@ module RuboCop
           return if message_nodes.size > 1
 
           argument = message_nodes.first.source
-          exception_class = exception_node.receiver&.source || exception_node.source
+          exception_class = exception_class_node(exception_node).source
 
-          if node.parent && requires_parens?(node.parent)
+          if parenthesize?(node)
             "#{node.method_name}(#{exception_class}.new(#{argument}))"
           else
             "#{node.method_name} #{exception_class}.new(#{argument})"
           end
         end
 
+        def exception_class_node(exception_node)
+          use_new_method?(exception_node) ? exception_node.receiver : exception_node
+        end
+
         def check_compact(node)
           if node.arguments.size > 1
             exception = node.first_argument
             return if exception.send_type? && exception.first_argument&.hash_type?
+            return if use_new_method?(exception) && exception.arguments?
 
             add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
-              replace_raise(corrector, node, correction_exploded_to_compact(node))
+              correct_raise(node) { correct_to_compact(corrector, node) }
             end
           else
             correct_style_detected
           end
         end
 
+        def correct_to_compact(corrector, node)
+          if heredoc_message?(node)
+            correct_heredoc_exploded_to_compact(corrector, node)
+          else
+            corrector.replace(node, correction_exploded_to_compact(node))
+          end
+        end
+
+        def heredoc_message?(node)
+          node.parenthesized? && node.arguments.size == 2 && heredoc?(node.last_argument)
+        end
+
+        def heredoc?(node)
+          node.each_node(:any_str).any?(&:heredoc?)
+        end
+
+        def correct_heredoc_exploded_to_compact(corrector, node)
+          exception_node, message_node = *node.arguments
+          exception_class = exception_class_node(exception_node)
+          corrector.replace(range_between(exception_class, message_node), '.new(')
+          corrector.insert_after(message_node, ')')
+        end
+
+        def range_between(left_node, right_node)
+          left_node.source_range.end.join(right_node.source_range.begin)
+        end
+
         def check_exploded(node)
           return correct_style_detected unless node.arguments.one?
 
@@ -118,15 +150,36 @@ module RuboCop
           return if allowed_non_exploded_type?(first_arg)
 
           add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
-            replace_raise(corrector, node, correction_compact_to_exploded(node))
+            correct_raise(node) { correct_to_exploded(corrector, node) }
           end
         end
 
-        def replace_raise(corrector, node, replacement)
+        def correct_to_exploded(corrector, node)
+          if heredoc_new_argument?(node)
+            correct_heredoc_compact_to_exploded(corrector, node)
+          else
+            corrector.replace(node, correction_compact_to_exploded(node))
+          end
+        end
+
+        def heredoc_new_argument?(node)
+          new_call = node.first_argument
+          return false unless new_call.arguments.one? && heredoc?(new_call.first_argument)
+
+          node.parenthesized? || !parenthesize?(node)
+        end
+
+        def correct_heredoc_compact_to_exploded(corrector, node)
+          new_call = node.first_argument
+          corrector.replace(range_between(new_call.receiver, new_call.first_argument), ', ')
+          corrector.remove(new_call.loc.end) if new_call.loc.end
+        end
+
+        def correct_raise(node)
           opposite_style_detected
           return if inside_corrected_raise?(node)
 
-          corrector.replace(node, replacement)
+          yield
           ignore_node(node)
         end
 
@@ -157,6 +210,12 @@ module RuboCop
           Array(cop_config['AllowedCompactTypes']).include?(type)
         end
 
+        def parenthesize?(node)
+          return true if node.parenthesized?
+
+          node.parent && requires_parens?(node.parent)
+        end
+
         def requires_parens?(parent)
           return true if parent.operator_keyword?
           return true if parent.type?(:call, :super, :yield, :array, :pair)

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

@@ -100,6 +100,7 @@ module RuboCop
           return unless key
           return if accumulator_used_in_expressions?(block_node, key, value)
           return if nested_match?(key) || nested_match?(value)
+          return if heredoc_in_inject_numblock?(block_node, key, value)
 
           register_offense(node, block_node, key, value)
         end
@@ -124,6 +125,12 @@ module RuboCop
           end
         end
 
+        def heredoc_in_inject_numblock?(block_node, key, value)
+          return false if !block_node.numblock_type? || block_node.method?(:each_with_object)
+
+          [key, value].any? { |node| node.each_node(:any_str).any?(&:heredoc?) }
+        end
+
         def accumulator_name(block_node)
           index = block_node.method?(:each_with_object) ? 1 : 0
           block_node.argument_list[index].name
@@ -136,42 +143,20 @@ module RuboCop
         def register_offense(send_node, block_node, key_expr, value_expr)
           message = format(MSG, method: send_node.method_name)
 
+          # Each part is replaced separately so that heredoc bodies between them are kept.
           add_offense(send_node.loc.selector, message: message) do |corrector|
-            corrector.replace(
-              replacement_range(send_node, block_node),
-              replacement(block_node, key_expr, value_expr)
-            )
-          end
-        end
+            corrector.replace(method_call_range(send_node), 'to_h')
 
-        def replacement(block_node, key_expr, value_expr)
-          key_source = adjusted_source(key_expr, block_node)
-          value_source = adjusted_source(value_expr, block_node)
-          body = "[#{key_source}, #{value_source}]"
-
-          if block_node.numblock_type?
-            block_node.braces? ? "to_h { #{body} }" : do_end_replacement(block_node, body)
-          else
-            named_block_replacement(block_node, body)
-          end
-        end
+            unless block_node.numblock_type?
+              corrector.replace(block_node.arguments, "|#{element_arg_source(block_node)}|")
+            end
 
-        def named_block_replacement(block_node, body)
-          arg = element_arg_source(block_node)
-          if block_node.braces?
-            "to_h { |#{arg}| #{body} }"
-          else
-            do_end_replacement(block_node, body, arg)
+            correct_body(corrector, block_node, key_expr, value_expr)
           end
         end
 
-        def do_end_replacement(block_node, body, arg = nil)
-          args = arg ? " |#{arg}|" : ''
-          "to_h do#{args}\n#{indent(block_node)}  #{body}\n#{indent(block_node)}end"
-        end
-
-        def replacement_range(send_node, block_node)
-          range_between(send_node.loc.selector.begin_pos, block_node.source_range.end_pos)
+        def method_call_range(send_node)
+          range_between(send_node.loc.selector.begin_pos, send_node.source_range.end_pos)
         end
 
         def element_arg_source(block_node)
@@ -182,6 +167,16 @@ module RuboCop
           end
         end
 
+        def correct_body(corrector, block_node, key_expr, value_expr)
+          key_source = adjusted_source(key_expr, block_node)
+          value_source = adjusted_source(value_expr, block_node)
+          body = block_node.body
+          assignment = body.begin_type? ? body.children.first : body
+
+          corrector.replace(assignment, "[#{key_source}, #{value_source}]")
+          corrector.remove(accumulator_range(body.children.last)) if body.begin_type?
+        end
+
         def adjusted_source(expr_node, block_node)
           source = element_source(expr_node)
           return source unless block_node.numblock_type?
@@ -191,10 +186,6 @@ module RuboCop
           source.gsub('_2', '_1')
         end
 
-        def indent(node)
-          ' ' * node.source_range.column
-        end
-
         def element_source(expr_node)
           if command_call?(expr_node) || expr_node.assignment? || expr_node.rescue_type?
             return "(#{expr_node.source})"
@@ -210,6 +201,13 @@ module RuboCop
 
           node.arguments? && !node.parenthesized? && !node.operator_method? && !node.setter_method?
         end
+
+        def accumulator_range(accumulator)
+          range = range_with_surrounding_space(accumulator.source_range, side: :left)
+          return range unless range.source_buffer.source[range.begin_pos - 1] == ';'
+
+          range_with_surrounding_space(range.adjust(begin_pos: -1), side: :left, newlines: false)
+        end
       end
     end
   end

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

@@ -67,6 +67,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant `begin` block detected.'
+        SPACE_INSIDE_PARENS_STYLES = %w[space compact].freeze
 
         def self.autocorrect_incompatible_with
           [Style::BlockDelimiters]
@@ -132,7 +133,8 @@ module RuboCop
           empty_begin?(node) ||
             begin_block_has_multiline_statements?(node) ||
             contain_rescue_or_ensure?(node) ||
-            valid_context_using_only_begin?(node)
+            valid_context_using_only_begin?(node) ||
+            ternary_operand_requiring_begin?(node)
         end
 
         def register_offense(node)
@@ -229,6 +231,12 @@ module RuboCop
             parent&.send_type? || parent&.operator_keyword?
         end
 
+        def ternary_operand_requiring_begin?(node)
+          return false unless node.parent&.if_type? && node.parent.ternary?
+
+          !node.children.one? || low_precedence_statement?(node.children.first)
+        end
+
         def valid_begin_assignment?(node)
           node.parent&.assignment? && (!node.children.one? || too_long_when_joined?(node))
         end
@@ -239,14 +247,28 @@ module RuboCop
           return false unless max && statement.single_line?
 
           length = statement.source.length
-          length += 2 if low_precedence_statement?(statement)
+          length += parentheses_width if low_precedence_statement?(statement)
+
           node.loc.column + length > max
         end
 
+        def parentheses_width
+          space_inside_parens? ? 4 : 2
+        end
+
+        def space_inside_parens?
+          return false unless config.cop_enabled?('Layout/SpaceInsideParens')
+
+          style = config.for_cop('Layout/SpaceInsideParens')['EnforcedStyle']
+
+          SPACE_INSIDE_PARENS_STYLES.include?(style)
+        end
+
         def inspect_branches(node)
           node.branches.each do |branch|
             next unless branch&.kwbegin_type?
             next if branch.rescue_node || branch.ensure_node
+            next if ternary_operand_requiring_begin?(branch)
 
             register_offense(branch)
           end

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

@@ -37,23 +37,18 @@ module RuboCop
         private
 
         def fix_exploded(node)
-          exploded?(node) do |command, message|
+          exploded?(node) do |exception, message|
             # `raise RuntimeError, nil` uses the class name as the message, so
             # rewriting it to `raise nil.to_s` (an empty message) would change it.
             next if message.nil_type?
 
             add_offense(node, message: MSG_1) do |corrector|
-              corrector.replace(node, replaced_exploded(node, command, message))
+              corrector.remove(exception.source_range.join(message.source_range.begin))
+              corrector.replace(message, message_source(message))
             end
           end
         end
 
-        def replaced_exploded(node, command, message)
-          arg = message_source(message)
-          arg = node.parenthesized? ? "(#{arg})" : " #{arg}"
-          "#{command}#{arg}"
-        end
-
         def string_message?(message)
           message.any_str_type?
         end
@@ -63,11 +58,20 @@ module RuboCop
             next if message.nil_type?
 
             add_offense(node, message: MSG_2) do |corrector|
+              # Replacing the call would drop a heredoc body that sits inside its parentheses.
+              next if heredoc_body_inside?(new_call, message)
+
               corrector.replace(new_call, message_source(message))
             end
           end
         end
 
+        def heredoc_body_inside?(new_call, message)
+          message.each_node(:any_str).any? do |str|
+            str.heredoc? && str.loc.heredoc_end.end_pos < new_call.source_range.end_pos
+          end
+        end
+
         def message_source(message)
           if string_message?(message)
             message.source
@@ -90,7 +94,7 @@ module RuboCop
 
         # @!method exploded?(node)
         def_node_matcher :exploded?, <<~PATTERN
-          (send nil? ${:raise :fail} (const {nil? cbase} :RuntimeError) $_)
+          (send nil? {:raise :fail} $(const {nil? cbase} :RuntimeError) $_)
         PATTERN
 
         # @!method compact?(node)

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

@@ -115,7 +115,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.self_receiver? && regular_method_call?(node)
-          return if node.parent&.mlhs_type?
+          return if multiple_assignment_target?(node)
           return if allowed_send_node?(node)
           return if it_method_in_block?(node)
 
@@ -154,6 +154,14 @@ module RuboCop
           end
         end
 
+        def multiple_assignment_target?(node)
+          return false unless (parent = node.parent)
+
+          parent = parent.parent if parent.splat_type?
+
+          parent.mlhs_type?
+        end
+
         def allowed_send_node?(node)
           @allowed_send_nodes.include?(node) ||
             @local_variables_scopes[node].include?(node.method_name) ||

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

@@ -69,10 +69,31 @@ module RuboCop
           return false if disallow_endless_method_style?
           return false unless body_node
           return false if body_node.parent.assignment_method?
+          return false if captures_following_code?(body_node.parent)
 
           !unsupported_endless_method_body?(body_node) && endless_method_body?(body_node)
         end
 
+        # `def foo; bar; end && baz` would become `def foo() = bar && baz`. The same goes for a def
+        # that ends an operand, as in `a && def foo; bar; end || baz`.
+        def captures_following_code?(node)
+          return false unless (parent = node.parent)
+
+          node_end = node.source_range.end_pos
+          return captures_following_code?(parent) if parent.source_range.end_pos == node_end
+
+          parent.children.first.equal?(node) && extends_endless_body?(parent, node)
+        end
+
+        def extends_endless_body?(parent, node)
+          case parent.type
+          when :and, :or then parent.logical_operator?
+          when :if then parent.ternary?
+          when :rescue then same_line?(node, parent.resbody_branches.first) # the modifier form
+          else parent.type?(:call, :range)
+          end
+        end
+
         def unsupported_endless_method_body?(body_node)
           body_node.basic_conditional? ||
             NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)

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

@@ -143,7 +143,18 @@ module RuboCop
         def replacement(parts)
           interpolated_parts = parts.map { |part| adjust_str(part) }
 
-          "\"#{handle_quotes(interpolated_parts).join}\""
+          "\"#{join_parts(handle_quotes(interpolated_parts))}\""
+        end
+
+        def join_parts(parts)
+          parts.each_with_object(+'') do |part, result|
+            result.insert(-2, '\\') if interpolation_formed?(result, part)
+            result << part
+          end
+        end
+
+        def interpolation_formed?(preceding, part)
+          part.start_with?('{', '@', '$') && preceding.match?(/(?<!\\)(?:\\\\)*#\z/)
         end
 
         def adjust_str(part)

data/lib/rubocop/plugin/configuration_integrator.rb

@@ -105,18 +105,39 @@ module RuboCop
 
           case rules.type
           when :path
-            [ConfigLoader.load_file(rules.value, check: false), rules.value]
+            config = ConfigLoader.load_file(rules.value, check: false)
+            warn_about_obsolete_config(plugin, config)
+            [config, rules.value]
           when :object
             path = plugin.method(:rules).source_location[0]
             [Config.create(rules.value, path, check: true), path]
           when :error
-            plugin_name = plugin.about&.name || plugin.inspect
             error_message = rules.value.respond_to?(:message) ? rules.value.message : rules.value
 
-            raise "Plugin `#{plugin_name}' failed to load with error: #{error_message}"
+            raise "Plugin `#{plugin_name(plugin)}' failed to load with error: #{error_message}"
           end
         end
 
+        # Plugin configuration is loaded without validation, so an obsolete key in a plugin's
+        # defaults used to surface only later, against the user's own file, once the two had
+        # been merged. Report it here, while the path is still the plugin's, and name the
+        # plugin: the file lives inside an installed gem, so the fix is to report it upstream.
+        # It is a warning whatever the rule's severity: a stale plugin is not the user's
+        # mistake and must not stop the run.
+        def warn_about_obsolete_config(plugin, config)
+          messages = ConfigObsoletion.new(config).messages
+          return if messages.empty?
+
+          warn Rainbow(<<~WARNING).yellow
+            Warning: obsolete configuration found in the `#{plugin_name(plugin)}` plugin:
+            #{messages.join("\n")}
+          WARNING
+        end
+
+        def plugin_name(plugin)
+          plugin.about&.name || plugin.inspect
+        end
+
         # This is how we ensure "first-in wins": plugins can override AllCops settings that are
         # set by RuboCop's default configuration, but once a plugin sets an AllCop setting, they
         # have exclusive first-in-wins rights to that setting.

data/lib/rubocop/runner.rb

@@ -367,8 +367,8 @@ module RuboCop
       return if team.cops.empty?
 
       team.defer_corrections = @options[:diff]
+      team.cops.first.offenses_to_check = offenses.reject(&:corrected?)
 
-      team.cops.first.offenses_to_check = offenses
       yield team
     end
 

data/lib/rubocop/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.92.1
+  version: 1.92.2
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -1157,7 +1157,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://rubocop.org/
-  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.92.1
+  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.92.2
   source_code_uri: https://github.com/rubocop/rubocop/
   documentation_uri: https://docs.rubocop.org/rubocop/1.92/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues