rubocop 1.69.0 → 1.79.2

data/lib/rubocop/config_obsoletion.rb

@@ -23,9 +23,40 @@ module RuboCop
     class << self
       attr_accessor :files
 
+      def global
+        @global ||= new(Config.new)
+      end
+
+      def reset!
+        @global = nil
+        @deprecated_names = {}
+        LOAD_RULES_CACHE[rules_cache_key] = nil
+      end
+
+      def rules_cache_key
+        files.hash
+      end
+
       def legacy_cop_names
         # Used by DepartmentName#qualified_legacy_cop_name
-        new(Config.new).rules.select(&:cop_rule?).map(&:old_name)
+        global.legacy_cop_names
+      end
+
+      def deprecated_cop_name?(name)
+        global.deprecated_cop_name?(name)
+      end
+
+      def deprecated_names_for(cop)
+        @deprecated_names ||= {}
+        return @deprecated_names[cop] if @deprecated_names.key?(cop)
+
+        @deprecated_names[cop] = global.rules.filter_map do |rule|
+          next unless rule.cop_rule?
+          next unless rule.respond_to?(:new_name)
+          next unless rule.new_name == cop
+
+          rule.old_name
+        end
       end
     end
 
@@ -45,12 +76,21 @@ module RuboCop
       raise ValidationError, messages.join("\n")
     end
 
+    def legacy_cop_names
+      # Used by DepartmentName#qualified_legacy_cop_name
+      cop_rules.map(&:old_name)
+    end
+
+    def deprecated_cop_name?(name)
+      legacy_cop_names.include?(name)
+    end
+
     private
 
     # Default rules for obsoletions are in config/obsoletion.yml
     # Additional rules files can be added with `RuboCop::ConfigObsoletion.files << filename`
     def load_rules # rubocop:disable Metrics/AbcSize
-      rules = LOAD_RULES_CACHE[self.class.files] ||=
+      rules = LOAD_RULES_CACHE[self.class.rules_cache_key] ||=
         self.class.files.each_with_object({}) do |filename, hash|
           hash.merge!(YAML.safe_load(File.read(filename)) || {}) do |_key, first, second|
             case first
@@ -107,5 +147,9 @@ module RuboCop
         rule.message
       end
     end
+
+    def cop_rules
+      rules.select(&:cop_rule?)
+    end
   end
 end

data/lib/rubocop/config_validator.rb

@@ -3,21 +3,22 @@
 module RuboCop
   # Handles validation of configuration, for example cop names, parameter
   # names, and Ruby versions.
+  # rubocop:disable Metrics/ClassLength
   class ConfigValidator
     extend SimpleForwardable
 
     # @api private
     COMMON_PARAMS = %w[Exclude Include Severity inherit_mode AutoCorrect StyleGuide Details
-                       Enabled].freeze
+                       Enabled Reference References].freeze
     # @api private
     INTERNAL_PARAMS = %w[Description StyleGuide
                          VersionAdded VersionChanged VersionRemoved
-                         Reference Safe SafeAutoCorrect].freeze
+                         Reference References Safe SafeAutoCorrect].freeze
     # @api private
     NEW_COPS_VALUES = %w[pending disable enable].freeze
 
     # @api private
-    CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect].to_set.freeze
+    CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect References].to_set.freeze
     CONFIG_CHECK_DEPARTMENTS = %w[pending override_department].freeze
     CONFIG_CHECK_AUTOCORRECTS = %w[always contextual disabled].freeze
     private_constant :CONFIG_CHECK_KEYS, :CONFIG_CHECK_DEPARTMENTS
@@ -41,8 +42,9 @@ module RuboCop
         ConfigLoader.default_configuration.key?(key)
       end
 
-      check_obsoletions
+      validate_parameter_shape(valid_cop_names)
 
+      check_obsoletions
       alert_about_unrecognized_cops(invalid_cop_names)
       validate_new_cops_parameter
       validate_parameter_names(valid_cop_names)
@@ -64,12 +66,6 @@ module RuboCop
       target_ruby.version
     end
 
-    def validate_section_presence(name)
-      return unless @config.key?(name) && @config[name].nil?
-
-      raise ValidationError, "empty section #{name} found in #{smart_loaded_path}"
-    end
-
     private
 
     attr_reader :target_ruby
@@ -122,6 +118,7 @@ module RuboCop
       invalid_cop_names.each do |name|
         # There could be a custom cop with this name. If so, don't warn
         next if Cop::Registry.global.contains_cop_matching?([name])
+        next if ConfigObsoletion.deprecated_cop_name?(name)
 
         # Special case for inherit_mode, which is a directive that we keep in
         # the configuration (even though it's not a cop), because it's easier
@@ -177,9 +174,22 @@ module RuboCop
       raise ValidationError, message
     end
 
+    def validate_parameter_shape(valid_cop_names)
+      valid_cop_names.each do |name|
+        if @config[name].nil?
+          raise ValidationError, "empty section #{name.inspect} found in #{smart_loaded_path}"
+        elsif !@config[name].is_a?(Hash)
+          raise ValidationError, <<~MESSAGE
+            The configuration for #{name.inspect} in #{smart_loaded_path} is not a Hash.
+
+            Found: #{@config[name].inspect}
+          MESSAGE
+        end
+      end
+    end
+
     def validate_parameter_names(valid_cop_names)
       valid_cop_names.each do |name|
-        validate_section_presence(name)
         each_invalid_parameter(name) do |param, supported_params|
           warn Rainbow(<<~MESSAGE).yellow
             Warning: #{name} does not support #{param} parameter.
@@ -250,8 +260,7 @@ module RuboCop
       end
     end
 
-    # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-    def check_cop_config_value(hash, parent = nil)
+    def check_cop_config_value(hash, parent = nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       hash.each do |key, value|
         check_cop_config_value(value, key) if value.is_a?(Hash)
 
@@ -261,6 +270,8 @@ module RuboCop
           supposed_values = 'a boolean'
         elsif key == 'AutoCorrect' && !CONFIG_CHECK_AUTOCORRECTS.include?(value)
           supposed_values = '`always`, `contextual`, `disabled`, or a boolean'
+        elsif key == 'References'
+          supposed_values = 'an array of strings'
         else
           next
         end
@@ -268,7 +279,6 @@ module RuboCop
         raise ValidationError, param_error_message(parent, key, value, supposed_values)
       end
     end
-    # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
     # FIXME: Handling colors in exception messages like this is ugly.
     def param_error_message(parent, key, value, supposed_values)
@@ -277,4 +287,5 @@ module RuboCop
         "is supposed to be #{supposed_values} and #{Rainbow(value).yellow} is not."
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -49,67 +49,68 @@ module RuboCop
       private
 
       def disable_offense(offense_range)
-        range = surrounding_heredoc(offense_range) ||
-                surrounding_percent_array(offense_range) ||
-                string_continuation(offense_range)
+        unbreakable_range = multiline_ranges(offense_range)&.find do |range|
+          eol_comment_would_be_inside_literal?(offense_range, range)
+        end
 
-        if range
-          disable_offense_before_and_after(range_by_lines(range))
+        if unbreakable_range
+          disable_offense_before_and_after(range_by_lines(unbreakable_range))
         else
           disable_offense_with_eol_or_surround_comment(offense_range)
         end
       end
 
-      def disable_offense_with_eol_or_surround_comment(range)
-        eol_comment = " # rubocop:todo #{cop_name}"
-        needed_line_length = (range.source_line + eol_comment).length
+      def multiline_ranges(offense_range)
+        return if offense_range.empty?
 
-        if needed_line_length <= max_line_length
-          disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
-        else
-          disable_offense_before_and_after(range_by_lines(range))
+        processed_source.ast.each_node.filter_map do |node|
+          if surrounding_heredoc?(node)
+            heredoc_range(node)
+          elsif string_continuation?(node)
+            range_by_lines(node.source_range)
+          elsif surrounding_percent_array?(node) || multiline_string?(node)
+            node.source_range
+          end
         end
       end
 
-      def surrounding_heredoc(offense_range)
-        # The empty offense range is an edge case that can be reached from the Lint/Syntax cop.
-        return nil if offense_range.empty?
-
-        heredoc_nodes = processed_source.ast.each_descendant.select do |node|
-          node.respond_to?(:heredoc?) && node.heredoc?
+      def disable_offense_with_eol_or_surround_comment(range)
+        if line_with_eol_comment_too_long?(range)
+          disable_offense_before_and_after(range_by_lines(range))
+        else
+          disable_offense_at_end_of_line(range_of_first_line(range))
         end
-        heredoc_nodes.map { |node| node.source_range.join(node.loc.heredoc_end) }
-                     .find { |range| range.contains?(offense_range) }
       end
 
-      def surrounding_percent_array(offense_range)
-        return nil if offense_range.empty?
+      def eol_comment_would_be_inside_literal?(offense_range, literal_range)
+        return true if line_with_eol_comment_too_long?(offense_range)
 
-        percent_array = processed_source.ast.each_descendant.select do |node|
-          node.array_type? && node.percent_literal?
-        end
-
-        percent_array.map(&:source_range).find do |range|
-          range_overlaps_offense?(offense_range, range)
-        end
+        offense_line = offense_range.line
+        offense_line >= literal_range.first_line && offense_line < literal_range.last_line
       end
 
-      def string_continuation(offense_range)
-        return nil if offense_range.empty?
+      def line_with_eol_comment_too_long?(range)
+        (range.source_line + eol_comment).length > max_line_length
+      end
 
-        string_continuation_nodes = processed_source.ast.each_descendant.filter_map do |node|
-          range_by_lines(node.source_range) if string_continuation?(node)
-        end
+      def surrounding_heredoc?(node)
+        node.type?(:str, :dstr, :xstr) && node.heredoc?
+      end
 
-        string_continuation_nodes.find { |range| range_overlaps_offense?(offense_range, range) }
+      def heredoc_range(node)
+        node.source_range.join(node.loc.heredoc_end)
       end
 
-      def range_overlaps_offense?(offense_range, range)
-        offense_range.begin_pos > range.begin_pos && range.overlaps?(offense_range)
+      def surrounding_percent_array?(node)
+        node.array_type? && node.percent_literal?
       end
 
       def string_continuation?(node)
-        (node.str_type? || node.dstr_type? || node.xstr_type?) && node.source.match?(/\\\s*$/)
+        node.type?(:str, :dstr, :xstr) && node.source.match?(/\\\s*$/)
+      end
+
+      def multiline_string?(node)
+        node.dstr_type? && node.multiline?
       end
 
       def range_of_first_line(range)
@@ -135,10 +136,14 @@ module RuboCop
         config.for_cop('Layout/LineLength')['Max'] || 120
       end
 
-      def disable_offense_at_end_of_line(range, eol_comment)
+      def disable_offense_at_end_of_line(range)
         Corrector.new(range).insert_after(range, eol_comment)
       end
 
+      def eol_comment
+        " # rubocop:todo #{cop_name}"
+      end
+
       def disable_offense_before_and_after(range_by_lines)
         range_with_newline = range_by_lines.resize(range_by_lines.size + 1)
         leading_whitespace = range_by_lines.source_line[/^\s*/]

data/lib/rubocop/cop/base.rb

@@ -261,6 +261,12 @@ module RuboCop
         @config.target_ruby_version
       end
 
+      # Returns a gems locked versions (i.e. from Gemfile.lock or gems.locked)
+      # @returns [Gem::Version | nil] The locked gem version, or nil if the gem is not present.
+      def target_gem_version(gem_name)
+        @config.gem_versions_in_target && @config.gem_versions_in_target[gem_name]
+      end
+
       def parser_engine
         @config.parser_engine
       end

data/lib/rubocop/cop/bundler/duplicated_gem.rb

@@ -66,14 +66,14 @@ module RuboCop
 
         def conditional_declaration?(nodes)
           parent = nodes[0].each_ancestor.find { |ancestor| !ancestor.begin_type? }
-          return false unless parent&.if_type? || parent&.when_type?
+          return false unless parent&.type?(:if, :when)
 
           root_conditional_node = parent.if_type? ? parent : parent.parent
           nodes.all? { |node| within_conditional?(node, root_conditional_node) }
         end
 
         def within_conditional?(node, conditional_node)
-          conditional_node.branches.any? do |branch|
+          conditional_node.branches.compact.any? do |branch|
             branch == node || branch.child_nodes.include?(node)
           end
         end

data/lib/rubocop/cop/bundler/gem_comment.rb

@@ -161,7 +161,7 @@ module RuboCop
         end
 
         def gem_options(node)
-          return [] unless node.last_argument&.type == :hash
+          return [] unless node.last_argument&.hash_type?
 
           node.last_argument.keys.map(&:value)
         end

data/lib/rubocop/cop/bundler/ordered_gems.rb

@@ -45,7 +45,7 @@ module RuboCop
 
           gem_declarations(processed_source.ast)
             .each_cons(2) do |previous, current|
-            next unless consecutive_lines(previous, current)
+            next unless consecutive_lines?(previous, current)
             next unless case_insensitive_out_of_order?(gem_name(current), gem_name(previous))
 
             register_offense(previous, current)

data/lib/rubocop/cop/correctors/parentheses_corrector.rb

@@ -10,8 +10,11 @@ module RuboCop
         COMMA_REGEXP = /(?<=\))\s*,/.freeze
 
         def correct(corrector, node)
-          corrector.remove(node.loc.begin)
-          corrector.remove(node.loc.end)
+          buffer = node.source_range.source_buffer
+          corrector.remove(range_with_surrounding_space(range: node.loc.begin, buffer: buffer,
+                                                        side: :right, whitespace: true))
+          corrector.remove(range_with_surrounding_space(range: node.loc.end, buffer: buffer,
+                                                        side: :left))
           handle_orphaned_comma(corrector, node)
 
           return unless ternary_condition?(node) && next_char_is_question_mark?(node)

data/lib/rubocop/cop/gemspec/attribute_assignment.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Use consistent style for Gemspec attributes assignment.
+      #
+      # @example
+      #
+      #   # bad
+      #   # This example uses two styles for assignment of metadata attribute.
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = { 'key' => 'value' }
+      #     spec.metadata['another-key'] = 'another-value'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata['key'] = 'value'
+      #     spec.metadata['another-key'] = 'another-value'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = { 'key' => 'value', 'another-key' => 'another-value' }
+      #   end
+      #
+      #   # bad
+      #   # This example uses two styles for assignment of authors attribute.
+      #   Gem::Specification.new do |spec|
+      #     spec.authors = %w[author-0 author-1]
+      #     spec.authors[2] = 'author-2'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.authors = %w[author-0 author-1 author-2]
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.authors[0] = 'author-0'
+      #     spec.authors[1] = 'author-1'
+      #     spec.authors[2] = 'author-2'
+      #   end
+      #
+      #   # good
+      #   # This example uses consistent assignment per attribute,
+      #   # even though two different styles are used overall.
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = { 'key' => 'value' }
+      #     spec.authors[0] = 'author-0'
+      #     spec.authors[1] = 'author-1'
+      #     spec.authors[2] = 'author-2'
+      #   end
+      #
+      class AttributeAssignment < Base
+        include GemspecHelp
+
+        MSG = 'Use consistent style for Gemspec attributes assignment.'
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          assignments = source_assignments(processed_source.ast)
+          indexed_assignments = source_indexed_assignments(processed_source.ast)
+
+          assignments.keys.intersection(indexed_assignments.keys).each do |attribute|
+            indexed_assignments[attribute].each do |node|
+              add_offense(node)
+            end
+          end
+        end
+
+        private
+
+        def source_assignments(ast)
+          assignment_method_declarations(ast)
+            .select(&:assignment_method?)
+            .group_by(&:method_name)
+            .transform_keys { |method_name| method_name.to_s.delete_suffix('=').to_sym }
+        end
+
+        def source_indexed_assignments(ast)
+          indexed_assignment_method_declarations(ast)
+            .group_by { |node| node.children.first.method_name }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gemspec/duplicated_assignment.rb

@@ -6,10 +6,11 @@ module RuboCop
       # An attribute assignment method calls should be listed only once
       # in a gemspec.
       #
-      # Assigning to an attribute with the same name using `spec.foo =` will be
-      # an unintended usage. On the other hand, duplication of methods such
-      # as `spec.requirements`, `spec.add_runtime_dependency`, and others are
-      # permitted because it is the intended use of appending values.
+      # Assigning to an attribute with the same name using `spec.foo =` or
+      # `spec.attribute#[]=` will be an unintended usage. On the other hand,
+      # duplication of methods such # as `spec.requirements`,
+      # `spec.add_runtime_dependency`, and others are permitted because it is
+      # the intended use of appending values.
       #
       # @example
       #   # bad
@@ -34,6 +35,18 @@ module RuboCop
       #     spec.add_dependency('parallel', '~> 1.10')
       #     spec.add_dependency('parser', '>= 2.3.3.1', '< 3.0')
       #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata["key"] = "value"
+      #     spec.metadata["key"] = "value"
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata["key"] = "value"
+      #   end
+      #
       class DuplicatedAssignment < Base
         include RangeHelp
         include GemspecHelp
@@ -41,15 +54,16 @@ module RuboCop
         MSG = '`%<assignment>s` method calls already given on line ' \
               '%<line_of_first_occurrence>d of the gemspec.'
 
-        # @!method assignment_method_declarations(node)
-        def_node_search :assignment_method_declarations, <<~PATTERN
-          (send
-            (lvar #match_block_variable_name?) _ ...)
-        PATTERN
-
         def on_new_investigation
           return if processed_source.blank?
 
+          process_assignment_method_nodes
+          process_indexed_assignment_method_nodes
+        end
+
+        private
+
+        def process_assignment_method_nodes
           duplicated_assignment_method_nodes.each do |nodes|
             nodes[1..].each do |node|
               register_offense(node, node.method_name, nodes.first.first_line)
@@ -57,11 +71,12 @@ module RuboCop
           end
         end
 
-        private
-
-        def match_block_variable_name?(receiver_name)
-          gem_specification(processed_source.ast) do |block_variable_name|
-            return block_variable_name == receiver_name
+        def process_indexed_assignment_method_nodes
+          duplicated_indexed_assignment_method_nodes.each do |nodes|
+            nodes[1..].each do |node|
+              assignment = "#{node.children.first.method_name}[#{node.first_argument.source}]="
+              register_offense(node, assignment, nodes.first.first_line)
+            end
           end
         end
 
@@ -73,6 +88,13 @@ module RuboCop
             .select { |nodes| nodes.size > 1 }
         end
 
+        def duplicated_indexed_assignment_method_nodes
+          indexed_assignment_method_declarations(processed_source.ast)
+            .group_by { |node| [node.children.first.method_name, node.first_argument] }
+            .values
+            .select { |nodes| nodes.size > 1 }
+        end
+
         def register_offense(node, assignment, line_of_first_occurrence)
           line_range = node.loc.column...node.loc.last_column
           offense_location = source_range(processed_source.buffer, node.first_line, line_range)

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -71,7 +71,7 @@ module RuboCop
 
           dependency_declarations(processed_source.ast)
             .each_cons(2) do |previous, current|
-            next unless consecutive_lines(previous, current)
+            next unless consecutive_lines?(previous, current)
             next unless case_insensitive_out_of_order?(gem_name(current), gem_name(previous))
             next unless get_dependency_name(previous) == get_dependency_name(current)
 

data/lib/rubocop/cop/gemspec/require_mfa.rb

@@ -74,6 +74,14 @@ module RuboCop
           }
         PATTERN
 
+        # @!method metadata_assignment(node)
+        def_node_search :metadata_assignment, <<~PATTERN
+          `{
+            (send _ :metadata= _)
+            (send (send _ :metadata) :[]= (str _) _)
+          }
+        PATTERN
+
         # @!method rubygems_mfa_required(node)
         def_node_search :rubygems_mfa_required, <<~PATTERN
           (pair (str "rubygems_mfa_required") $_)
@@ -131,9 +139,15 @@ module RuboCop
         end
 
         def insert_mfa_required(corrector, node, block_var)
-          corrector.insert_before(node.loc.end, <<~RUBY)
+          require_mfa_directive = <<~RUBY.strip
             #{block_var}.metadata['rubygems_mfa_required'] = 'true'
           RUBY
+
+          if (last_assignment = metadata_assignment(processed_source.ast).to_a.last)
+            corrector.insert_after(last_assignment, "\n#{require_mfa_directive}")
+          else
+            corrector.insert_before(node.loc.end, "#{require_mfa_directive}\n")
+          end
         end
 
         def change_value(corrector, value)

data/lib/rubocop/cop/generator.rb

@@ -71,11 +71,17 @@ module RuboCop
                   (send nil? :bad_method ...)
                 PATTERN
 
+                # Called on every `send` node (method call) while walking the AST.
+                # TODO: remove this method if inspecting `send` nodes is unneeded for your cop.
+                # By default, this is aliased to `on_csend` as well to handle method calls
+                # with safe navigation, remove the alias if this is unnecessary.
+                # If kept, ensure your tests cover safe navigation as well!
                 def on_send(node)
                   return unless bad_method?(node)
 
                   add_offense(node)
                 end
+                alias on_csend on_send
               end
             end
           end