rubocop 1.92.0 → 1.92.2

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

@@ -69,15 +69,41 @@ 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)
         end
 
+        # The body gets parenthesized when it becomes endless, so it is no longer a command.
+        def command_body_in_argument?(body)
+          !require_parentheses?(body) && super
+        end
+
         def correct_to_multiline(corrector, node)
           if (body = node.body) && body.begin_type? && body.parenthesized_call?
             break_line_before(corrector, node, body)

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/cop/style/struct_inheritance.rb

@@ -41,6 +41,12 @@ module RuboCop
         MSG = "Don't extend an instance initialized by `Struct.new`. " \
               'Use a block to customize the struct.'
 
+        # When the closing parenthesis of `Struct.new` is on its own line, omitting the
+        # parentheses in the same pass leaves a line break before the appended `do`.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_class(node)
           return unless struct_constructor?(node.parent_class)
           return if defines_constants?(node.body)

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

@@ -166,7 +166,7 @@ module RuboCop
         PATTERN
 
         def self.autocorrect_incompatible_with
-          [Layout::SpaceBeforeBlockBraces]
+          [Layout::SpaceBeforeBlockBraces, Style::TrailingCommaInArguments]
         end
 
         # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

data/lib/rubocop/lsp/routes.rb

@@ -25,12 +25,6 @@ module RuboCop
       # via `executeCommandProvider` so it knows which commands it can invoke.
       EXECUTE_COMMANDS = %w[rubocop.formatAutocorrects rubocop.formatAutocorrectsAll].freeze
 
-      def self.handle(name, &block)
-        define_method(:"handle_#{name}", &block)
-      end
-
-      private_class_method :handle
-
       def initialize(server)
         @server = server
 
@@ -44,6 +38,29 @@ module RuboCop
         method(name)
       end
 
+      def handle_unsupported_method(request, method = request[:method])
+        @server.write(
+          id: request[:id],
+          error: LanguageServer::Protocol::Interface::ResponseError.new(
+            code: LanguageServer::Protocol::Constant::ErrorCodes::METHOD_NOT_FOUND,
+            message: "Unsupported Method: #{method}"
+          )
+        )
+        Logger.log("Unsupported Method: #{method}")
+      end
+
+      def handle_method_missing(request)
+        return unless request.key?(:id)
+
+        @server.write(id: request[:id], result: nil)
+      end
+
+      def self.handle(name, &block)
+        define_method(:"handle_#{name}", &block)
+      end
+
+      private_class_method :handle
+
       handle 'initialize' do |request|
         initialization_options = extract_initialization_options_from(request)
 
@@ -178,23 +195,6 @@ module RuboCop
         # No-op, we log everything
       end
 
-      def handle_unsupported_method(request, method = request[:method])
-        @server.write(
-          id: request[:id],
-          error: LanguageServer::Protocol::Interface::ResponseError.new(
-            code: LanguageServer::Protocol::Constant::ErrorCodes::METHOD_NOT_FOUND,
-            message: "Unsupported Method: #{method}"
-          )
-        )
-        Logger.log("Unsupported Method: #{method}")
-      end
-
-      def handle_method_missing(request)
-        return unless request.key?(:id)
-
-        @server.write(id: request[:id], result: nil)
-      end
-
       private
 
       def extract_initialization_options_from(request)

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/server/cache.rb

@@ -51,9 +51,9 @@ module RuboCop
             Pathname(project_dir).join(lockfile_name)
           end.find(&:exist?)
           version_data = lockfile_path&.read || RuboCop::Version::STRING
-          config_data = Pathname(
-            args_config_file_path || ConfigFinder.find_config_path(Dir.pwd)
-          ).read
+          config_path = Pathname(args_config_file_path || ConfigFinder.find_config_path(Dir.pwd))
+          # NOTE: A missing config file is reported by `RuboCop::CLI` with a friendly message.
+          config_data = config_path.exist? ? config_path.read : ''
           yaml = load_erb_templated_yaml(config_data)
 
           inherit_from_data = inherit_from_data(yaml)
@@ -181,7 +181,7 @@ module RuboCop
           yaml_code = ERB.new(content).result
 
           require 'yaml'
-          YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol], aliases: true)
+          YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol], aliases: true) || {}
         end
       end
     end

data/lib/rubocop/target_ruby.rb

@@ -100,15 +100,23 @@ module RuboCop
       def gemspec_filepath
         return @gemspec_filepath if defined?(@gemspec_filepath)
 
-        @gemspec_filepath =
-          @config.traverse_directories_upwards(@config.base_dir_for_path_parameters) do |dir|
-            # NOTE: Can't use `dir.glob` because of JRuby 9.4.8.0 incompatibility:
-            # https://github.com/jruby/jruby/issues/8358
-            candidates = Pathname.glob("#{dir}/*.gemspec")
-            # Bundler will use a gemspec whatever the filename is, as long as its the only one in
-            # the folder.
-            break candidates.first if candidates.one?
-          end
+        @gemspec_filepath = @config.traverse_directories_upwards(
+          @config.base_dir_for_path_parameters, ConfigFinder.project_root
+        ) do |dir|
+          candidates = gemspec_candidates(dir)
+
+          # Bundler will use a gemspec whatever the filename is, as long as its the only one in
+          # the folder.
+          break candidates.first if candidates.one?
+        end
+      end
+
+      def gemspec_candidates(dir)
+        # NOTE: Can't use `dir.glob` because of JRuby 9.4.8.0 incompatibility:
+        # https://github.com/jruby/jruby/issues/8358
+        Pathname.glob("#{dir}/*.gemspec")
+      rescue SystemCallError
+        []
       end
 
       def version_from_gemspec_file(file)
@@ -179,6 +187,8 @@ module RuboCop
         return unless file && File.file?(file)
 
         File.read(file).match(pattern) { |md| md[:version].to_f }
+      rescue SystemCallError
+        nil
       end
 
       def version_file
@@ -250,6 +260,8 @@ module RuboCop
           result = line.match(/^\s*ruby\s+(\d+\.\d+)[p.\d]*\s*$/)
           return result.captures.first.to_f if result
         end
+      rescue SystemCallError
+        nil
       end
 
       def bundler_lock_file_path

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.92.0'
+    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.0
+  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.0
+  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