rubocop 1.84.1 → 1.84.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 358bce5232f7b6e4e490a3d173d09cb4d3df8fc9e92355b550d0047e10e0f462
-  data.tar.gz: 8e65d98bd3478db7eee250dd05ffc6fd4f4d17d144207950fc12f5e83f7995f6
+  metadata.gz: f04de47751f13e6453b15f6114038e6c9ef89418cde47c8e8ce73abecc1664ee
+  data.tar.gz: d1d9cd363db45392d753d24324b1828fe20834bfea01f5efcd2ee246352cbef1
 SHA512:
-  metadata.gz: 4b6cf48e7582909807829dd43e7fd379a9e4ec46cd387659a16321f4fd3ee7a321ac16859ce86870d41fae2602abde14197e1bb91094abb8bf9dd809dc6e648e
-  data.tar.gz: c619779f7ac9d8563aadc5f6675333f22d7c8d2300d6ac1c996260d442210f6b2b809f24e7fa1479b6b908a0ca16bc8f61bc23200f3e2f302e03369bce6dafac
+  metadata.gz: f28b74f272f302feb77cdf3053f1116c7b24e3b0c57b139c71fd315d3c38fa8b4f3c122691fd071af1990699f7b7a52d9de5296ac8bb257435ef612ca317ef11
+  data.tar.gz: 82cba886044606ae3b12eb9ef3b2b706be63d1503e80a10a9b22df2b329ed318b8b286e1b110d64bce0c9f10d7f39f84ad48735ba8a6b2d2f259dd78f4592550

data/lib/rubocop/cache_config.rb

@@ -25,5 +25,34 @@ module RuboCop
 
       File.join(root, 'rubocop_cache')
     end
+
+    # Lightweight cache root computation that reads CacheRootDirectory from
+    # the toplevel config file and environment variables without going through
+    # the full ConfigStore/ConfigLoader. This method can be used, for example,
+    # before loading configuration files. Please note that this method doesn't
+    # take into account any `inherit_from` dependencies.
+    def self.root_dir_from_toplevel_config(cache_root_override = nil)
+      root_dir do
+        next cache_root_override if cache_root_override
+
+        config_path = ConfigFinder.find_config_path(Dir.pwd)
+        file_contents = File.read(config_path)
+
+        # Returns early if `CacheRootDirectory` is not used before requiring `erb` or `yaml`.
+        next unless file_contents.include?('CacheRootDirectory')
+
+        require 'erb'
+        require 'yaml'
+        yaml_code = ERB.new(file_contents).result
+        config_yaml = YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol], aliases: true)
+
+        # For compatibility with Ruby 3.0 or lower.
+        if Gem::Version.new(Psych::VERSION) < Gem::Version.new('4.0.0')
+          config_yaml == false ? nil : config_yaml
+        end
+
+        config_yaml&.dig('AllCops', 'CacheRootDirectory')
+      end
+    end
   end
 end

data/lib/rubocop/cli.rb

@@ -166,7 +166,9 @@ module RuboCop
 
       @config_store.apply_options!(@options)
       # Set cache root after apply_options! to ensure force_default_config is applied first.
+      early_cache_root = ConfigLoader.cache_root(@options[:cache_root])
       ConfigLoader.cache_root = ResultCache.cache_root(@config_store, @options[:cache_root])
+      warn_if_cache_root_changed(early_cache_root, ConfigLoader.cache_root)
 
       handle_exiting_options
 
@@ -225,5 +227,21 @@ module RuboCop
     def report_pending_cops
       PendingCopsReporter.warn_if_needed(@config_store.for_pwd)
     end
+
+    def warn_if_cache_root_changed(early, desired)
+      return if early == desired
+      # Normalize paths to avoid false positives from symlink resolution differences
+      if File.exist?(early) && File.exist?(desired) &&
+         File.realpath(early) == File.realpath(desired)
+        return
+      end
+
+      warn Rainbow(
+        "Warning: Remote configuration cache files were stored in `#{early}` " \
+        "because a desired cache root (`#{desired}`) was not set at the top level. " \
+        'Consider setting `AllCops: CacheRootDirectory` in your toplevel configuration file, ' \
+        'using the `RUBOCOP_CACHE_ROOT` environment variable, or using CLI options.'
+      ).yellow
+    end
   end
 end

data/lib/rubocop/config_loader.rb

@@ -2,6 +2,7 @@
 
 require 'erb'
 require 'yaml'
+require_relative 'cache_config'
 require_relative 'config_finder'
 
 module RuboCop
@@ -23,13 +24,17 @@ module RuboCop
       include FileFinder
 
       attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops,
-                    :ignore_unrecognized_cops, :cache_root
-      attr_writer :default_configuration
+                    :ignore_unrecognized_cops
+      attr_writer :default_configuration, :cache_root
       attr_reader :loaded_plugins, :loaded_features
 
       alias debug? debug
       alias ignore_parent_exclusion? ignore_parent_exclusion
 
+      def cache_root(cache_root_override = nil)
+        @cache_root ||= CacheConfig.root_dir_from_toplevel_config(cache_root_override)
+      end
+
       def clear_options
         @debug = nil
         @loaded_plugins = Set.new

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

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

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

@@ -187,6 +187,7 @@ module RuboCop
         def should_correct_entire_chain?(send_node, top_level_send)
           return false unless style == :special_for_inner_method_call_in_parentheses
           return false unless inner_call?(top_level_send)
+          return false unless display_column(send_node.source_range) < column_delta.abs
 
           top_level_send != send_node || begins_its_line?(top_level_send.loc.end)
         end

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

@@ -153,6 +153,7 @@ module RuboCop
 
         def check_hash_pair_indentation(node, lhs, rhs)
           @base = find_hash_pair_alignment_base(node) || lhs.source_range
+          return if aligned_with_first_line_dot?(node, rhs)
 
           calculate_column_delta_offense(rhs, @base.column)
         end
@@ -165,6 +166,16 @@ module RuboCop
           first_call.loc.dot.join(first_call.loc.selector)
         end
 
+        def aligned_with_first_line_dot?(node, rhs)
+          return false unless rhs.source.start_with?('.', '&.')
+
+          first_call = first_call_has_a_dot(node)
+          return false if first_call == node.receiver
+
+          dot = first_call.loc.dot
+          dot.line == node.first_line && dot.column == rhs.column
+        end
+
         def check_regular_indentation(node, lhs, rhs, given_style)
           @base = alignment_base(node, rhs, given_style)
           correct_column = if @base
@@ -269,7 +280,7 @@ module RuboCop
           return unless rhs.source.start_with?('.', '&.')
 
           node = semantic_alignment_node(node)
-          return unless node&.loc&.selector && node.loc.dot
+          return unless node&.loc?(:selector) && node.loc.dot
 
           node.loc.dot.join(node.loc.selector)
         end
@@ -322,9 +333,9 @@ module RuboCop
         end
 
         def method_on_receiver_last_line?(node, base_receiver, type)
-          base_receiver &&
-            node.loc.dot.line == base_receiver.last_line &&
-            base_receiver.type?(type)
+          return false unless base_receiver
+
+          same_line?(node.loc.dot, base_receiver.source_range.end) && base_receiver.type?(type)
         end
 
         def get_dot_right_above(node)
@@ -337,24 +348,33 @@ module RuboCop
         end
 
         def find_multiline_block_chain_node(node)
-          return find_continuation_receiver(node) if node.block_node
+          return find_continuation_node(node) if node.block_node
 
           handle_descendant_block(node)
         end
 
-        def find_continuation_receiver(node)
+        def find_continuation_node(node)
           receiver = node.receiver
-          return unless receiver.call_type? && receiver.loc.dot && receiver.receiver
+          return receiver.send_node if single_line_block_receiver?(receiver)
+          return unless receiver.call_type? && receiver.loc.dot
+          return receiver if receiver.receiver.begin_type? && node.block_node.single_line?
           return unless receiver.loc.dot.line > receiver.receiver.last_line
 
           receiver
         end
 
+        def single_line_block_receiver?(receiver)
+          receiver.single_line? && receiver.any_block_type?
+        end
+
         def handle_descendant_block(node)
+          receiver = node.receiver
+          return receiver.send_node if single_line_block_receiver?(receiver)
+
           block_node = node.each_descendant(:any_block).first
           return unless block_node&.multiline?
 
-          node.receiver.call_type? ? node.receiver : block_node.parent
+          receiver.call_type? ? receiver : block_node.parent
         end
 
         def first_call_has_a_dot(node)

data/lib/rubocop/cop/offense.rb

@@ -66,6 +66,13 @@ module RuboCop
         alias_method :last_line, :line
         alias_method :last_column, :column
 
+        attr_reader :source_buffer
+
+        def initialize(line, column, source_line, begin_pos, end_pos)
+          super
+          @source_buffer = Parser::Source::Buffer.new('(pseudo)', source: source_line)
+        end
+
         def column_range
           column...last_column
         end

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

@@ -198,12 +198,13 @@ module RuboCop
         alias on_csend on_send
 
         def on_block(node)
-          return if ignored_node?(node)
+          return if part_of_ignored_node?(node)
           return if proper_block_style?(node)
 
           message = message(node)
           add_offense(node.loc.begin, message: message) do |corrector|
             autocorrect(corrector, node)
+            ignore_node(node)
           end
         end
 

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

@@ -37,7 +37,6 @@ module RuboCop
       #
       class EmptyClassDefinition < Base
         include ConfigurableEnforcedStyle
-        include Alignment
         include RangeHelp
         extend AutoCorrector
 
@@ -45,27 +44,24 @@ module RuboCop
           'Prefer a two-line class definition over `Class.new` for classes with no body.'
         MSG_CLASS_NEW = 'Prefer `Class.new` over class definition for classes with no body.'
 
-        # @!method class_new_assignment?(node)
-        def_node_matcher :class_new_assignment?, <<~PATTERN
-          (casgn _ _ (send (const _ :Class) :new ...))
+        # @!method class_new_assignment(node)
+        def_node_matcher :class_new_assignment, <<~PATTERN
+          (casgn _ _ $(send (const _ :Class) :new ...))
         PATTERN
 
         def on_casgn(node)
           return unless style == :class_definition
-          return unless node.expression
-
-          class_new_node = find_class_new_node(node.expression)
-          return if chained_with_any_method?(node.expression, class_new_node)
-          return if variable_parent_class?(class_new_node)
+          return unless (class_new_node = class_new_assignment(node))
+          return if (arg = class_new_node.first_argument) && !arg.const_type?
 
           add_offense(node, message: MSG_CLASS_DEFINITION) do |corrector|
-            autocorrect_class_new(corrector, node)
+            autocorrect_class_new(corrector, node, class_new_node)
           end
         end
 
         def on_class(node)
           return unless style == :class_new
-          return unless empty_class?(node)
+          return if (body = node.body) && !body.children.empty?
 
           add_offense(node, message: MSG_CLASS_NEW) do |corrector|
             autocorrect_class_definition(corrector, node)
@@ -74,69 +70,25 @@ module RuboCop
 
         private
 
-        def autocorrect_class_new(corrector, node)
+        def autocorrect_class_new(corrector, node, class_new_node)
           indent = ' ' * node.loc.column
           class_name = node.name
-          class_new_node = find_class_new_node(node.expression)
-          parent_class = extract_parent_class(class_new_node)
-
-          replacement = if parent_class
-                          "class #{class_name} < #{parent_class}\n#{indent}end"
-                        else
-                          "class #{class_name}\n#{indent}end"
-                        end
+          if (parent_class = class_new_node.first_argument)
+            parent_class_name = " < #{parent_class.source}"
+          end
 
-          corrector.replace(node, replacement)
+          corrector.replace(node, "class #{class_name}#{parent_class_name}\n#{indent}end")
         end
 
         def autocorrect_class_definition(corrector, node)
-          source_line = processed_source.buffer.source_line(node.loc.line)
-          indent = source_line[/\A */]
+          indent = ' ' * node.loc.column
           class_name = node.identifier.source
-          parent_class = node.parent_class&.source
+          if (parent_class = node.parent_class)
+            parent_class_name = "(#{parent_class.source})"
+          end
           range = range_by_whole_lines(node.source_range, include_final_newline: true)
 
-          replacement = if parent_class
-                          "#{indent}#{class_name} = Class.new(#{parent_class})\n"
-                        else
-                          "#{indent}#{class_name} = Class.new\n"
-                        end
-
-          corrector.replace(range, replacement)
-        end
-
-        def extract_parent_class(class_new_node)
-          first_arg = class_new_node.first_argument
-          first_arg&.source
-        end
-
-        def variable_parent_class?(class_new_node)
-          first_arg = class_new_node.first_argument
-          return false unless first_arg
-
-          !first_arg.const_type?
-        end
-
-        def find_class_new_node(node)
-          return nil unless node.send_type?
-          return nil unless node.receiver&.const_type?
-
-          return node if node.receiver.const_name.to_sym == :Class && node.method?(:new)
-
-          nil
-        end
-
-        def chained_with_any_method?(expression_node, class_new_node)
-          return true unless expression_node == class_new_node
-
-          false
-        end
-
-        def empty_class?(node)
-          body = node.body
-          return true unless body
-
-          body.begin_type? && body.children.empty?
+          corrector.replace(range, "#{indent}#{class_name} = Class.new#{parent_class_name}\n")
         end
       end
     end

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

@@ -118,7 +118,7 @@ module RuboCop
           return if allowed_unannotated?(detections)
 
           detections.each do |detected_sequence, token_range|
-            check_sequence(detected_sequence, token_range)
+            check_sequence(node, detected_sequence, token_range)
           end
         end
 
@@ -143,17 +143,34 @@ module RuboCop
             matches_allowed_pattern?(send_parent.method_name))
         end
 
-        def check_sequence(detected_sequence, token_range)
+        def check_sequence(node, detected_sequence, token_range)
           if detected_sequence.style == style
             correct_style_detected
           elsif correctable_sequence?(detected_sequence.type)
             style_detected(detected_sequence.style)
-            add_offense(token_range, message: message(detected_sequence.style)) do |corrector|
+            register_offense(node, detected_sequence, token_range)
+          end
+        end
+
+        def register_offense(node, detected_sequence, token_range)
+          msg = message(detected_sequence.style)
+
+          if format_string_context?(node)
+            add_offense(token_range, message: msg) do |corrector|
               autocorrect_sequence(corrector, detected_sequence, token_range)
             end
+          else
+            add_offense(token_range, message: msg)
           end
         end
 
+        def format_string_context?(node)
+          format_string_in_typical_context?(node) ||
+            node.each_ancestor(:dstr).any? do |dstr_node|
+              format_string_in_typical_context?(dstr_node)
+            end
+        end
+
         def correctable_sequence?(detected_type)
           detected_type == 's' || style == :annotated || style == :unannotated
         end

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

@@ -36,7 +36,7 @@ module RuboCop
         def on_hash(node)
           return if node.children.first&.kwsplat_type?
           return unless (array = containing_array(node))
-          return unless last_array_item?(array, node) && explicit_array?(array)
+          return unless expected_braced_last_array_item?(array, node) && explicit_array?(array)
 
           if braces_style?
             check_braces(node)
@@ -52,10 +52,12 @@ module RuboCop
           parent if parent&.array_type?
         end
 
-        def last_array_item?(array, node)
-          return false if array.child_nodes.all?(&:hash_type?)
+        def expected_braced_last_array_item?(array, node)
+          return false if array.each_value.all? do |node|
+            node.hash_type? && (braces_style? ? node.braces? : !node.braces?)
+          end
 
-          array.children.last.equal?(node)
+          !array.values[-2]&.hash_type? && array.values.last.equal?(node)
         end
 
         def explicit_array?(array)

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

@@ -253,7 +253,7 @@ module RuboCop
 
         def sibling_if_shares_line?(child, node)
           inner = unwrap_begin(child)
-          inner&.if_type? && shares_line_with?(inner, node)
+          inner&.if_type? && !inner.ternary? && shares_line_with?(inner, node)
         end
 
         def unwrap_begin(node)
@@ -264,7 +264,7 @@ module RuboCop
         end
 
         def shares_line_with?(inner, node)
-          inner.loc.line == node.loc.end.line || inner.loc.end.line == node.loc.line
+          same_line?(inner, node.loc.end) || same_line?(inner.loc.end, node)
         end
 
         def find_containing_collection(node)

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

@@ -103,8 +103,6 @@ module RuboCop
         MSG_MISSING = 'Use def with parentheses when there are parameters.'
 
         def on_def(node)
-          return if forced_parentheses?(node)
-
           args = node.arguments
 
           if require_parentheses?(args)
@@ -113,10 +111,10 @@ module RuboCop
             else
               correct_style_detected
             end
+          elsif forced_parentheses?(node)
+            correct_style_detected
           elsif parentheses?(args)
             unwanted_parentheses(args)
-          else
-            correct_style_detected
           end
         end
         alias on_defs on_def

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

@@ -21,8 +21,6 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        NON_MODIFIER_THEN = /then\s*(#.*)?$/.freeze
-
         MSG = 'Do not use `then` for multi-line `%<keyword>s`.'
 
         def on_normal_if_unless(node)
@@ -36,7 +34,7 @@ module RuboCop
         private
 
         def non_modifier_then?(node)
-          NON_MODIFIER_THEN.match?(node.loc.begin&.source_line)
+          node.then? && node.loc.begin.line != node.if_branch&.loc&.line
         end
       end
     end

data/lib/rubocop/lsp/routes.rb

@@ -203,13 +203,13 @@ module RuboCop
 
         return [] if new_text == text
 
-        [
+        [{
           newText: new_text,
           range: {
             start: { line: 0, character: 0 },
             end: { line: text.count("\n") + 1, character: 0 }
           }
-        ]
+        }]
       end
 
       def diagnostic(file_uri, text)

data/lib/rubocop/rspec/shared_contexts.rb

@@ -31,7 +31,7 @@ RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLe
         ENV['HOME'] = original_home
         ENV['XDG_CONFIG_HOME'] = original_xdg_config_home
 
-        RuboCop::FileFinder.root_level = nil
+        RuboCop::ConfigLoader.clear_options # This also resets RuboCop::FileFinder.root_level
       end
     end
   end

data/lib/rubocop/server/cache.rb

@@ -73,33 +73,12 @@ module RuboCop
           cache_root_dir = if cache_root_path
                              File.join(cache_root_path, 'rubocop_cache')
                            else
-                             cache_root_dir_from_config
+                             CacheConfig.root_dir_from_toplevel_config
                            end
 
           File.expand_path(File.join(cache_root_dir, 'server'))
         end
 
-        def cache_root_dir_from_config
-          CacheConfig.root_dir do
-            # `RuboCop::ConfigStore` has heavy dependencies, this is a lightweight implementation
-            # so that only the necessary `CacheRootDirectory` can be obtained.
-            config_path = ConfigFinder.find_config_path(Dir.pwd)
-            file_contents = File.read(config_path)
-
-            # Returns early if `CacheRootDirectory` is not used before requiring `erb` or `yaml`.
-            next unless file_contents.include?('CacheRootDirectory')
-
-            config_yaml = load_erb_templated_yaml(file_contents)
-
-            # For compatibility with Ruby 3.0 or lower.
-            if Gem::Version.new(Psych::VERSION) < Gem::Version.new('4.0.0')
-              config_yaml == false ? nil : config_yaml
-            end
-
-            config_yaml&.dig('AllCops', 'CacheRootDirectory')
-          end
-        end
-
         def port_path
           dir.join('port')
         end

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.84.1'
+    STRING = '1.84.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.84.1
+  version: 1.84.2
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -1097,7 +1097,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://rubocop.org/
-  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.84.1
+  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.84.2
   source_code_uri: https://github.com/rubocop/rubocop/
   documentation_uri: https://docs.rubocop.org/rubocop/1.84/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues