rubocop 1.71.1 → 1.92.0

data/lib/rubocop/comment_config.rb

@@ -5,6 +5,8 @@ module RuboCop
   # and provides a way to check if each cop is enabled at arbitrary line.
   class CommentConfig
     extend SimpleForwardable
+    include DisableNext
+    include PushPop
 
     CONFIG_DISABLED_LINE_RANGE_MIN = -Float::INFINITY
 
@@ -25,8 +27,6 @@ module RuboCop
       end
     end
 
-    CopAnalysis = Struct.new(:line_ranges, :start_line_number)
-
     attr_reader :processed_source
 
     def_delegators :@processed_source, :config, :registry
@@ -34,14 +34,26 @@ module RuboCop
     def initialize(processed_source)
       @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)
@@ -54,8 +66,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
@@ -64,11 +76,29 @@ 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
+    # or a `+` argument of a `push`/`next` directive, used to mobilize cops
+    # disabled in the config on demand. Departments are expanded for the
+    # opt-in forms only: a plain `enable` naming a department usually just
+    # closes a `disable` of it, and expanding it would switch on every
+    # config-disabled cop of the department for the rest of the file.
+    #
+    # @api private
+    # @return [Set<String>]
+    def opt_in_cops
+      @opt_in_cops ||= begin
+        cops = Set.new
+        each_directive { |directive| cops.merge(opted_in_by(directive)) }
+        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 self_closing_directive?(directive)
 
         if directive.enabled_all?
           handle_enable_all(directive, names, extras)
@@ -80,43 +110,59 @@ 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
+    def opted_in_by(directive)
+      if directive.push? || directive.next?
+        directive.signed_args.fetch('+', []).flat_map { |name| expand_cop_name(name) }
+      elsif !directive.enabled? || directive.all_cops?
+        []
+      elsif directive.enable_next?
+        directive.cop_names
+      else
+        directive.raw_cop_names
       end
     end
 
-    def analyze # rubocop:todo Metrics/AbcSize
+    # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def analyze
       return {} if @no_directives
 
       analyses = Hash.new { |hash, key| hash[key] = CopAnalysis.new([], nil) }
       inject_disabled_cops_directives(analyses)
 
       each_directive do |directive|
-        directive.cop_names.each do |cop_name|
-          cop_name = qualified_cop_name(cop_name)
-          analyses[cop_name] = analyze_cop(analyses[cop_name], directive)
+        if directive.push?
+          restore_point = analyses.transform_values(&:dup)
+          @stack.push(restore_point)
+          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)
+        elsif directive.next?
+          apply_next_directive(analyses, resolve_push_cops(directive), directive)
+        elsif directive.enable_next?
+          apply_enable_next(analyses, directive)
+        else
+          directive.cop_names.each do |cop_name|
+            cop_name = qualified_cop_name(cop_name)
+            analyses[cop_name] = analyze_cop(analyses[cop_name], directive)
+          end
         end
       end
 
       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
 
     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
@@ -136,35 +182,21 @@ module RuboCop
       return analysis unless directive.disabled?
 
       line = directive.line_number
-      start_line = analysis.start_line_number
-
-      CopAnalysis.new(analysis.line_ranges + [(line..line)], start_line)
+      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
-
-      # Cop already disabled on this line, so we end the current disabled
-      # range before we start a new range.
-      return CopAnalysis.new(analysis.line_ranges + [start_line..line], line) if start_line
-
-      CopAnalysis.new(analysis.line_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
-
-      return CopAnalysis.new(analysis.line_ranges + [start_line..line], nil) if start_line
-
-      CopAnalysis.new(analysis.line_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
@@ -176,8 +208,29 @@ module RuboCop
       end
     end
 
+    # Push/pop and next-statement directives close themselves, so they
+    # play no part in the disable/enable pairing.
+    def self_closing_directive?(directive)
+      directive.push? || directive.pop? || directive.disable_next? ||
+        directive.next? || directive.enable_next?
+    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
@@ -205,7 +258,7 @@ module RuboCop
       directive.cop_names.each do |name|
         if directive.disabled?
           names[name] += 1
-        elsif (names[name]).positive?
+        elsif names[name].positive?
           names[name] -= 1
         else
           extras[directive.comment] << name

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,14 +27,43 @@ module RuboCop
       config
     end
 
-    # rubocop:disable Metrics/AbcSize
+    # 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|
         cop_name = cop.respond_to?(:cop_name) ? cop.cop_name : cop
-        qualified_cop_name = Cop::Registry.qualified_cop_name(cop_name, loaded_path)
-        cop_options = self[qualified_cop_name].dup || {}
-        cop_options['Enabled'] = enable_cop?(qualified_cop_name, cop_options)
+
+        if ConfigObsoletion.deprecated_cop_name?(cop)
+          # Since a deprecated cop will no longer have a qualified name (as the badge is no
+          # longer valid), and since we do not want to automatically enable the cop, we just
+          # set the configuration to an empty hash if it is unset.
+          # This is necessary to allow a renamed cop have its old configuration merged in
+          # before being used (which is necessary to allow it to be disabled via config).
+          cop_options = self[cop_name].dup || {}
+        else
+          qualified_cop_name = Cop::Registry.qualified_cop_name(cop_name, loaded_path, warn: false)
+          cop_options = self[qualified_cop_name].dup || {}
+          cop_options['Enabled'] = enable_cop?(qualified_cop_name, cop_options)
+
+          # If the cop has deprecated names (ie. it has been renamed), it is possible that
+          # users will still have old configuration for the cop's old name. In this case,
+          # if `ConfigObsoletion` is configured to warn rather than error (and therefore
+          # RuboCop runs), we want to respect the old configuration, so merge it in.
+          #
+          # NOTE: If there is configuration for both the cop and a deprecated names, the old
+          # configuration will be merged on top of the new configuration!
+          ConfigObsoletion.deprecated_names_for(cop).each do |deprecated_cop_name|
+            deprecated_config = @for_cop[deprecated_cop_name]
+            next if deprecated_config.empty?
+
+            warn Rainbow(<<~WARNING).yellow
+              Warning: Using `#{deprecated_cop_name}` configuration in #{loaded_path} for `#{cop}`.
+            WARNING
+
+            cop_options.merge!(@for_cop[deprecated_cop_name])
+          end
+        end
+
         h[cop] = h[cop_name] = cop_options
       end
       @hash = hash
@@ -43,7 +72,10 @@ module RuboCop
       @badge_config_cache = {}.compare_by_identity
       @clusivity_config_exists_cache = {}
     end
-    # rubocop:enable Metrics/AbcSize
+
+    def loaded_plugins
+      @loaded_plugins ||= ConfigLoader.loaded_plugins
+    end
 
     def loaded_features
       @loaded_features ||= ConfigLoader.loaded_features
@@ -135,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
@@ -176,6 +212,30 @@ 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
+
+    # Whether preview behavior is on, for cops that gate an unstable change
+    # behind it and for cops that are themselves `Enabled: preview`.
+    # `--preview` / `--no-preview` win over `AllCops: Preview`.
+    def preview?(options = {})
+      preview = options[:preview]
+      return preview unless preview.nil?
+
+      for_all_cops['Preview'] == true
+    end
+
     def active_support_extensions_enabled?
       for_all_cops['ActiveSupportExtensionsEnabled']
     end
@@ -184,6 +244,9 @@ module RuboCop
       for_all_cops['StringLiteralsFrozenByDefault']
     end
 
+    # Returns true if the file matches any include pattern. If a block is given, the block is called
+    # to determine if the pattern is relevant (true returned by the block) or should be skipped
+    # (false returned).
     def file_to_include?(file)
       relative_file_path = path_relative_to_config(file)
 
@@ -195,11 +258,9 @@ module RuboCop
       absolute_file_path = File.expand_path(file)
 
       patterns_to_include.any? do |pattern|
-        if block_given?
-          yield pattern, relative_file_path, absolute_file_path
-        else
-          match_path?(pattern, relative_file_path) || match_path?(pattern, absolute_file_path)
-        end
+        next if block_given? && !yield(pattern)
+
+        match_relative_or_absolute_path?(pattern, relative_file_path, absolute_file_path)
       end
     end
 
@@ -209,10 +270,7 @@ module RuboCop
       # `bundler-console` conveys `Bundler::Console`).
       return true if File.extname(file) == '.gemspec'
 
-      file_to_include?(file) do |pattern, relative_path, absolute_path|
-        /[A-Z]/.match?(pattern.to_s) &&
-          (match_path?(pattern, relative_path) || match_path?(pattern, absolute_path))
-      end
+      file_to_include?(file) { |pattern| /[A-Z]/.match?(pattern.to_s) }
     end
 
     # Returns true if there's a chance that an Include pattern matches hidden
@@ -253,12 +311,12 @@ module RuboCop
            loaded_path != File.join(Dir.home, ConfigLoader::DOTFILE)
           File.expand_path(File.dirname(loaded_path))
         else
-          Dir.pwd
+          PathUtil.pwd
         end
     end
 
     def parser_engine
-      @parser_engine ||= for_all_cops.fetch('ParserEngine', :parser_whitequark).to_sym
+      @parser_engine ||= for_all_cops.fetch('ParserEngine', :default).to_sym
     end
 
     def target_rails_version
@@ -295,6 +353,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
@@ -306,12 +365,26 @@ 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
 
     private
 
+    def match_relative_or_absolute_path?(pattern, relative_file_path, absolute_file_path)
+      should_use_absolute_path = absolute?(pattern.to_s) || pattern.to_s.start_with?('..') ||
+                                 relative_file_path.start_with?('..')
+      match_path?(pattern, should_use_absolute_path ? absolute_file_path : relative_file_path)
+    end
+
     # @return [Float, nil] The Rails version as a `major.minor` Float.
     def target_rails_version_from_bundler_lock_file
       @target_rails_version_from_bundler_lock_file ||= read_rails_version_from_bundler_lock_file
@@ -344,6 +417,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'
@@ -362,6 +443,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_finder.rb

@@ -30,7 +30,7 @@ module RuboCop
       private
 
       def find_project_root
-        pwd = Dir.pwd
+        pwd = PathUtil.pwd
         gems_file = find_last_file_upwards('Gemfile', pwd) || find_last_file_upwards('gems.rb', pwd)
         return unless gems_file