rubocop 1.88.2 → 1.90.0

data/lib/rubocop/comment_config/disable_next.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CommentConfig
+    # Handling of `disable-next` directives: computing the statement scope
+    # they apply to and tracking directives that attached to nothing.
+    # The scope is the whole statement starting on the next line bearing
+    # code. Comment-only lines between the directive and the code chain (so
+    # several directives can stack), while a blank line breaks the attachment.
+    # @api private
+    module DisableNext
+      # `disable-next` directives that suppress nothing: nothing follows
+      # them, or they sit at the end of a code line.
+      def detached_next_directives
+        cop_disabled_line_ranges # ensure the analysis that collects them ran
+        @detached_next_directives
+      end
+
+      # The line range of the statement a `disable-next` directive on the
+      # given line scopes to (or would scope to), or `nil` when no statement
+      # is attached. A directive is only honored on a comment-only line.
+      # Stacked directives share the target, so the computation is memoized.
+      # @api private
+      def statement_scope_after(line)
+        return nil unless comment_only_line?(line)
+
+        code_line = attached_code_line(line)
+        return nil unless code_line
+
+        (@statement_bounds ||= {})[code_line] ||= statement_bounds_at(code_line)
+      end
+
+      private
+
+      def apply_disable_next(analyses, directive)
+        bounds = statement_scope_after(directive.line_number)
+        return @detached_next_directives << directive unless bounds
+
+        range = DirectiveRange.new(bounds.begin, bounds.end, directive)
+        directive.cop_names.each do |cop_name|
+          add_next_range(analyses, qualified_cop_name(cop_name), range)
+        end
+      end
+
+      def add_next_range(analyses, cop_name, range)
+        analysis = analyses[cop_name]
+        analyses[cop_name] = CopAnalysis.new(analysis.line_ranges + [range],
+                                             analysis.start_line_number, analysis.start_directive)
+      end
+
+      def attached_code_line(directive_line)
+        ((directive_line + 1)..processed_source.lines.size).each do |line|
+          return line unless comment_only_line?(line)
+          return nil if processed_source[line - 1].blank?
+        end
+
+        nil
+      end
+
+      def statement_bounds_at(line)
+        statement = statement_starting_at(line)
+        # A code line where no statement starts (e.g. a lone `end`) scopes
+        # the directive to that line alone.
+        return (line..line) unless statement
+
+        (line..statement_end_line(statement))
+      end
+
+      def statement_start_line?(node, line)
+        # Synthetic nodes (e.g. parentheses-less argument lists) have no
+        # source range. `begin` nodes are sequences of statements, not
+        # statements themselves - taking one would scope the directive to
+        # everything up to the last statement of the sequence.
+        node.source_range && node.first_line == line && !node.begin_type?
+      end
+
+      def statement_starting_at(line)
+        ast = processed_source.ast
+        return nil unless ast
+
+        ast.each_node.select { |node| statement_start_line?(node, line) }.max_by(&:last_line)
+      end
+
+      def statement_end_line(statement)
+        statement.each_node.filter_map do |node|
+          next unless node.source_range
+
+          heredoc?(node) ? node.loc.heredoc_end.line : node.last_line
+        end.max
+      end
+
+      def heredoc?(node)
+        node.respond_to?(:heredoc?) && node.heredoc?
+      end
+    end
+  end
+end

data/lib/rubocop/comment_config.rb

@@ -5,6 +5,7 @@ module RuboCop
   # and provides a way to check if each cop is enabled at arbitrary line.
   class CommentConfig
     extend SimpleForwardable
+    include DisableNext
 
     CONFIG_DISABLED_LINE_RANGE_MIN = -Float::INFINITY
 
@@ -25,8 +26,6 @@ module RuboCop
       end
     end
 
-    CopAnalysis = Struct.new(:line_ranges, :start_line_number)
-
     attr_reader :processed_source
 
     def_delegators :@processed_source, :config, :registry
@@ -35,14 +34,25 @@ module RuboCop
       @processed_source = processed_source
       @no_directives = !processed_source.raw_source.include?('rubocop')
       @stack = []
+      @detached_next_directives = []
     end
 
     def cop_enabled_at_line?(cop, line_number)
+      cop_enabled_at_lines?(cop, line_number, line_number)
+    end
+
+    # Whether the cop is enabled for all of the given line span. The cop
+    # counts as disabled for the span when any of its disabled ranges
+    # overlaps it, so that a directive on any line of a multi-line offense
+    # suppresses the offense.
+    def cop_enabled_at_lines?(cop, first_line, last_line)
       cop = cop.cop_name if cop.respond_to?(:cop_name)
       disabled_line_ranges = cop_disabled_line_ranges[cop]
       return true unless disabled_line_ranges
 
-      disabled_line_ranges.none? { |range| range.include?(line_number) }
+      disabled_line_ranges.none? do |range|
+        range.end >= first_line && range.begin <= last_line
+      end
     end
 
     def cop_opted_in?(cop)
@@ -55,8 +65,8 @@ module RuboCop
 
     def extra_enabled_comments
       disable_count = Hash.new(0)
-      registry.disabled(config).each do |cop|
-        disable_count[cop.cop_name] += 1
+      registry.disabled_names(config).each do |cop_name|
+        disable_count[cop_name] += 1
       end
       extra_enabled_comments_with_names(extras: Hash.new { |h, k| h[k] = [] }, names: disable_count)
     end
@@ -65,12 +75,32 @@ module RuboCop
       non_comment_token_line_numbers.none?(line_number)
     end
 
+    # The names of the cops that are opted in by an `enable` comment directive,
+    # used to mobilize cops disabled in the config on demand.
+    #
+    # @api private
+    # @return [Set<String>]
+    def opt_in_cops
+      @opt_in_cops ||= begin
+        cops = Set.new
+        each_directive do |directive|
+          next unless directive.enabled?
+          next if directive.all_cops?
+
+          cops.merge(directive.raw_cop_names)
+        end
+        cops
+      end
+    end
+
     private
 
     def extra_enabled_comments_with_names(extras:, names:)
       each_directive do |directive|
         next unless comment_only_line?(directive.line_number)
-        next if directive.push? || directive.pop?
+        # Push/pop and next-statement directives close themselves, so they
+        # play no part in the disable/enable pairing.
+        next if directive.push? || directive.pop? || directive.disable_next?
 
         if directive.enabled_all?
           handle_enable_all(directive, names, extras)
@@ -82,20 +112,7 @@ module RuboCop
       extras
     end
 
-    def opt_in_cops
-      @opt_in_cops ||= begin
-        cops = Set.new
-        each_directive do |directive|
-          next unless directive.enabled?
-          next if directive.all_cops?
-
-          cops.merge(directive.raw_cop_names)
-        end
-        cops
-      end
-    end
-
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     def analyze
       return {} if @no_directives
 
@@ -106,9 +123,11 @@ module RuboCop
         if directive.push?
           restore_point = analyses.transform_values(&:dup)
           @stack.push(restore_point)
-          apply_push(analyses, resolve_push_cops(directive), directive.line_number)
+          apply_push(analyses, resolve_push_cops(directive), directive)
         elsif directive.pop?
           pop_state(analyses, directive.line_number) if @stack.any?
+        elsif directive.disable_next?
+          apply_disable_next(analyses, directive)
         else
           directive.cop_names.each do |cop_name|
             cop_name = qualified_cop_name(cop_name)
@@ -119,10 +138,11 @@ module RuboCop
 
       analyses.each_with_object({}) do |element, hash|
         cop_name, analysis = *element
+        next if prevent_directive_disabling?(cop_name)
+
         hash[cop_name] = cop_line_ranges(analysis)
       end
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
     def resolve_push_cops(directive)
       directive.push_args.transform_values do |names|
@@ -136,37 +156,41 @@ module RuboCop
       cops.map { |c| qualified_cop_name(c) }
     end
 
-    def apply_push(analyses, resolved_cops, line)
+    def apply_push(analyses, resolved_cops, directive)
       resolved_cops.each do |op, cops|
-        cops.each { |cop| apply_cop_op(analyses, op, cop, line) }
+        cops.each { |cop| apply_cop_op(analyses, op, cop, directive) }
       end
     end
 
-    def apply_cop_op(analyses, operation, cop, line)
+    def apply_cop_op(analyses, operation, cop, directive)
       analysis = analyses[cop]
+      line = directive.line_number
       if operation == '-' && !analysis.start_line_number
-        analyses[cop] = CopAnalysis.new(analysis.line_ranges, line)
+        analyses[cop] = CopAnalysis.new(analysis.line_ranges, line, directive)
       elsif operation == '+' && analysis.start_line_number
-        analyses[cop] =
-          CopAnalysis.new(analysis.line_ranges + [analysis.start_line_number..line], nil)
+        analyses[cop] = CopAnalysis.new(analysis.close(line), nil)
       end
     end
 
     def pop_state(analyses, line)
       restore_point = @stack.pop
       (restore_point.keys | analyses.keys).each do |cop|
-        current = analyses[cop]
-        new_range = current.start_line_number ? [current.start_line_number..(line - 1)] : []
-        new_start = restore_point[cop]&.start_line_number ? line : nil
-        analyses[cop] = CopAnalysis.new(current.line_ranges + new_range, new_start)
+        analyses[cop] = popped_analysis(analyses[cop], restore_point[cop], line)
       end
     end
 
+    def popped_analysis(current, restored, line)
+      ranges = current.close(line - 1)
+      return CopAnalysis.new(ranges, nil) unless restored&.start_line_number
+
+      CopAnalysis.new(ranges, line, restored.start_directive)
+    end
+
     def inject_disabled_cops_directives(analyses)
-      registry.disabled(config).each do |cop|
-        analyses[cop.cop_name] = analyze_cop(
-          analyses[cop.cop_name],
-          DirectiveComment.new(ConfigDisabledCopDirectiveComment.new(cop.cop_name))
+      registry.disabled_names(config).each do |cop_name|
+        analyses[cop_name] = analyze_cop(
+          analyses[cop_name],
+          DirectiveComment.new(ConfigDisabledCopDirectiveComment.new(cop_name))
         )
       end
     end
@@ -186,27 +210,21 @@ module RuboCop
       return analysis unless directive.disabled?
 
       line = directive.line_number
-      CopAnalysis.new(analysis.line_ranges + [(line..line)], analysis.start_line_number)
+      range = DirectiveRange.new(line, line, directive)
+      CopAnalysis.new(analysis.line_ranges + [range], analysis.start_line_number,
+                      analysis.start_directive)
     end
 
     def analyze_disabled(analysis, directive)
-      line = directive.line_number
-      start_line = analysis.start_line_number
-      new_ranges = start_line ? analysis.line_ranges + [start_line..line] : analysis.line_ranges
-      CopAnalysis.new(new_ranges, line)
+      CopAnalysis.new(analysis.close(directive.line_number), directive.line_number, directive)
     end
 
     def analyze_rest(analysis, directive)
-      line = directive.line_number
-      start_line = analysis.start_line_number
-      new_ranges = start_line ? analysis.line_ranges + [start_line..line] : analysis.line_ranges
-      CopAnalysis.new(new_ranges, nil)
+      CopAnalysis.new(analysis.close(directive.line_number), nil)
     end
 
     def cop_line_ranges(analysis)
-      return analysis.line_ranges unless analysis.start_line_number
-
-      analysis.line_ranges + [(analysis.start_line_number..Float::INFINITY)]
+      analysis.close(Float::INFINITY)
     end
 
     def each_directive
@@ -219,7 +237,21 @@ module RuboCop
     end
 
     def qualified_cop_name(cop_name)
-      Cop::Registry.qualified_cop_name(cop_name.strip, processed_source.file_path)
+      # A directive naming a cop under the wrong department is not honored -
+      # the mistake is surfaced by `Lint/RedundantCopDisableDirective` (with a
+      # did-you-mean hint) instead of a stderr warning that is easy to miss
+      # and disappears entirely on cached runs.
+      Cop::Registry.qualified_cop_name(cop_name.strip, processed_source.file_path,
+                                       correct_namespace: false)
+    end
+
+    # `Style/DisableCopsWithinSourceCodeDirective` cannot be disabled via
+    # directive comments when it is explicitly enabled with `Enabled: true`.
+    # This prevents users from bypassing the cop by writing a disable
+    # directive that targets this cop itself.
+    def prevent_directive_disabling?(cop_name)
+      cop_name == DirectiveComment::STYLE_DISABLE_COPS_DIRECTIVE_COP &&
+        config.dig(cop_name, 'Enabled') == true
     end
 
     def non_comment_token_line_numbers

data/lib/rubocop/config.rb

@@ -2,7 +2,7 @@
 
 # FIXME: Moving Rails department code to RuboCop Rails will remove
 # the following rubocop:disable comment.
-# rubocop:disable Metrics/ClassLength
+# rubocop:disable-next Metrics/ClassLength
 module RuboCop
   # This class represents the configuration of the RuboCop application
   # and all its cops. A Config is associated with a YAML configuration
@@ -27,7 +27,7 @@ module RuboCop
       config
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
     def initialize(hash = RuboCop::ConfigLoader.default_configuration, loaded_path = nil)
       @loaded_path = loaded_path
       @for_cop = Hash.new do |h, cop|
@@ -72,7 +72,6 @@ module RuboCop
       @badge_config_cache = {}.compare_by_identity
       @clusivity_config_exists_cache = {}
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     def loaded_plugins
       @loaded_plugins ||= ConfigLoader.loaded_plugins
@@ -168,7 +167,11 @@ module RuboCop
         department_config = self[badge.department_name]
         cop_config = for_cop(badge.to_s)
         if department_config
-          department_config.merge(cop_config)
+          merged_config = department_config.merge(cop_config)
+          if department_config['Exclude'] && cop_config['Exclude']
+            merged_config['Exclude'] = department_config['Exclude'] | cop_config['Exclude']
+          end
+          merged_config
         else
           cop_config
         end
@@ -209,6 +212,20 @@ module RuboCop
       for_all_cops['NewCops'] == 'enable'
     end
 
+    # Whether the given pending cop should be enabled, based on the `NewCops` setting of
+    # its department (if any) or of `AllCops`. A department may set `NewCops` to `enable`,
+    # `disable`, `pending`, or a version, in which case pending cops added in that version
+    # or earlier are enabled.
+    def enabled_new_cop?(qualified_cop_name)
+      setting = new_cops_setting_for(qualified_cop_name)
+
+      case setting.to_s
+      when 'enable' then true
+      when '', 'pending', 'disable' then false
+      else new_cops_version_covers?(setting, qualified_cop_name)
+      end
+    end
+
     def active_support_extensions_enabled?
       for_all_cops['ActiveSupportExtensionsEnabled']
     end
@@ -326,6 +343,7 @@ module RuboCop
 
         cop_metadata = self[qualified_cop_name]
         next unless cop_metadata['Enabled'] == 'pending'
+        next if new_cops_covered?(qualified_cop_name)
 
         pending_cops << CopConfig.new(qualified_cop_name, cop_metadata)
       end
@@ -337,6 +355,14 @@ module RuboCop
       @gem_versions_in_target ||= read_gem_versions_from_target_lockfile
     end
 
+    # Returns the names of the target's gems that are sourced from a local path
+    # (i.e. `path:` dependencies and the project's own gem when the `Gemfile`
+    # uses `gemspec`), whose code therefore lives in the project itself.
+    # @returns [Array<String>, nil] The gem names, or nil without a lockfile.
+    def path_sourced_gems_in_target
+      @path_sourced_gems_in_target ||= read_path_sourced_gems_from_target_lockfile
+    end
+
     def inspect # :nodoc:
       "#<#{self.class.name}:#{object_id} @loaded_path=#{loaded_path}>"
     end
@@ -381,6 +407,14 @@ module RuboCop
       Lockfile.new(lockfile_path).gem_versions
     end
 
+    # @returns [Array<String>, nil] The names of the gems sourced from a local path.
+    def read_path_sourced_gems_from_target_lockfile
+      lockfile_path = bundler_lock_file_path
+      return nil unless lockfile_path
+
+      Lockfile.new(lockfile_path).path_sourced_gem_names
+    end
+
     def enable_cop?(qualified_cop_name, cop_options)
       # If the cop is explicitly enabled or `Lint/Syntax`, the other checks can be skipped.
       return true if cop_options['Enabled'] == true || qualified_cop_name == 'Lint/Syntax'
@@ -399,6 +433,43 @@ module RuboCop
 
       self[cop_department.join('/')]
     end
+
+    # The effective `NewCops` setting for the given cop: the department-level
+    # setting if present, otherwise the `AllCops` setting.
+    def new_cops_setting_for(qualified_cop_name)
+      department = department_of(qualified_cop_name)
+      setting = department['NewCops'] if department
+
+      setting || for_all_cops['NewCops']
+    end
+
+    # Whether the cop's pending status is resolved by a `NewCops` setting,
+    # so that it should not appear in the pending cops warning.
+    # Unlike `enabled_new_cop?`, `disable` counts as covered.
+    def new_cops_covered?(qualified_cop_name)
+      setting = new_cops_setting_for(qualified_cop_name)
+
+      case setting.to_s
+      when 'enable', 'disable' then true
+      when '', 'pending' then false
+      else new_cops_version_covers?(setting, qualified_cop_name)
+      end
+    end
+
+    def new_cops_version_covers?(new_cops_version, qualified_cop_name)
+      cop_metadata = self[qualified_cop_name]
+      version_added = comparable_version(cop_metadata['VersionAdded']) if cop_metadata
+      pinned_version = comparable_version(new_cops_version)
+      return false if version_added.nil? || pinned_version.nil?
+
+      version_added <= pinned_version
+    end
+
+    # Returns a `Gem::Version` for values like `'1.19'` or `1.19`, and `nil`
+    # for non-version values like `'N/A'` or `'<<next>>'`.
+    def comparable_version(value)
+      value = value.to_s
+      Gem::Version.new(value) if value.match?(/\A\d/) && Gem::Version.correct?(value)
+    end
   end
 end
-# rubocop:enable Metrics/ClassLength

data/lib/rubocop/config_loader.rb

@@ -49,7 +49,7 @@ module RuboCop
         FileFinder.root_level = nil
       end
 
-      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable-next Metrics/AbcSize
       def load_file(file, check: true)
         path = file_path(file)
 
@@ -73,7 +73,6 @@ module RuboCop
 
         Config.create(hash, path, check: check)
       end
-      # rubocop:enable Metrics/AbcSize
 
       def load_yaml_configuration(absolute_path)
         file_contents = read_file(absolute_path)

data/lib/rubocop/config_loader_resolver.rb

@@ -115,7 +115,7 @@ module RuboCop
     # with the addition that any value that is a hash, and occurs in both
     # arguments, will also be merged. And so on.
     #
-    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable-next Metrics/AbcSize
     def merge(base_hash, derived_hash, **opts)
       result = base_hash.merge(derived_hash)
       keys_appearing_in_both = base_hash.keys & derived_hash.keys
@@ -132,7 +132,6 @@ module RuboCop
       end
       result
     end
-    # rubocop:enable Metrics/AbcSize
 
     # An `Enabled: true` setting in user configuration for a cop overrides an
     # `Enabled: false` setting for its department.

data/lib/rubocop/config_validator.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # Handles validation of configuration, for example cop names, parameter
   # names, and Ruby versions.
-  # rubocop:disable Metrics/ClassLength
+  # rubocop:disable-next Metrics/ClassLength
   class ConfigValidator
     extend SimpleForwardable
 
@@ -16,6 +16,8 @@ module RuboCop
                          Reference References Safe SafeAutoCorrect].freeze
     # @api private
     NEW_COPS_VALUES = %w[pending disable enable].freeze
+    # @api private
+    NEW_COPS_VERSION_PATTERN = /\A\d+(\.\d+)*\z/.freeze
 
     # @api private
     CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect References].to_set.freeze
@@ -164,16 +166,48 @@ module RuboCop
     end
 
     def validate_new_cops_parameter
+      validate_all_cops_new_cops_parameter
+      validate_department_new_cops_parameters
+    end
+
+    def validate_all_cops_new_cops_parameter
       new_cop_parameter = @config.for_all_cops['NewCops']
       return if new_cop_parameter.nil? || NEW_COPS_VALUES.include?(new_cop_parameter)
 
-      message = "invalid #{new_cop_parameter} for `NewCops` found in" \
+      message = "invalid #{new_cop_parameter} for `NewCops` found in " \
                 "#{smart_loaded_path}\n" \
                 "Valid choices are: #{NEW_COPS_VALUES.join(', ')}"
 
       raise ValidationError, message
     end
 
+    def validate_department_new_cops_parameters
+      @config.each do |name, section|
+        value = new_cops_value_for_department(name, section)
+        next if value.nil? || NEW_COPS_VALUES.include?(value) || new_cops_version_value?(value)
+
+        raise ValidationError,
+              "invalid #{value} for `NewCops` found in #{smart_loaded_path}\n" \
+              "Valid choices for a department are: #{NEW_COPS_VALUES.join(', ')}, " \
+              "or a version string like '1.50'"
+      end
+    end
+
+    def new_cops_value_for_department(name, section)
+      return nil if name == 'AllCops' || !section.is_a?(Hash)
+      return nil unless Cop::Registry.global.department?(name)
+
+      section['NewCops']
+    end
+
+    def new_cops_version_value?(value)
+      case value
+      when Float, Integer then true
+      when String then NEW_COPS_VERSION_PATTERN.match?(value)
+      else false
+      end
+    end
+
     def validate_parameter_shape(valid_cop_names)
       valid_cop_names.each do |name|
         if @config[name].nil?
@@ -207,6 +241,9 @@ module RuboCop
 
       @config[cop_name].each_key do |param|
         next if COMMON_PARAMS.include?(param) || default_config.key?(param)
+        # Departments shipped as top-level sections in an extension's default configuration accept
+        # `NewCops`, like any other department.
+        next if param == 'NewCops' && Cop::Registry.global.department?(cop_name)
 
         supported_params = default_config.keys - INTERNAL_PARAMS
 
@@ -287,5 +324,4 @@ 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

@@ -12,6 +12,14 @@ module RuboCop
         autocorrect_requested? && disable_uncorrectable? && autocorrect_enabled?
       end
 
+      # Whether a correction exists but is skipped because it is unsafe in a
+      # safe autocorrect run, while `--disable-uncorrectable` asks for a todo
+      # comment on everything this run cannot correct.
+      def skipped_unsafe_correction_with_disable_uncorrectable?
+        autocorrect_requested? && disable_uncorrectable? &&
+          @options.fetch(:safe_autocorrect, false) && !safe_autocorrect?
+      end
+
       def autocorrect_requested?
         @options.fetch(:autocorrect, false)
       end

data/lib/rubocop/cop/badge.rb

@@ -52,6 +52,14 @@ module RuboCop
         cop_name == other.cop_name && (!qualified? || department == other.department)
       end
 
+      # Returns true if the badge's qualified name or the badge's department
+      # matches any of the given names.
+      def match_name?(given_names)
+        return false unless given_names
+
+        given_names.include?(to_s) || given_names.include?(department_name)
+      end
+
       def to_s
         @to_s ||= qualified? ? "#{department}/#{cop_name}" : cop_name
       end