rubocop 1.71.1 → 1.91.0

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
 

data/lib/rubocop/config_loader.rb

@@ -2,6 +2,7 @@
 
 require 'erb'
 require 'yaml'
+require_relative 'cache_config'
 require_relative 'config_finder'
 
 module RuboCop
@@ -22,41 +23,48 @@ module RuboCop
     class << self
       include FileFinder
 
-      PENDING_BANNER = <<~BANNER
-        The following cops were added to RuboCop, but are not configured. Please set Enabled to either `true` or `false` in your `.rubocop.yml` file.
-
-        Please also note that you can opt-in to new cops by default by adding this to your config:
-          AllCops:
-            NewCops: enable
-      BANNER
-
       attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops,
-                    :ignore_unrecognized_cops
-      attr_writer :default_configuration
-      attr_reader :loaded_features
+                    :enabled_by_default, :disabled_by_default, :ignore_unrecognized_cops,
+                    :preview
+      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
         @loaded_features = Set.new
         @disable_pending_cops = nil
         @enable_pending_cops = nil
+        @preview = nil
+        @enabled_by_default = nil
+        @disabled_by_default = nil
         @ignore_parent_exclusion = nil
         @ignore_unrecognized_cops = nil
+        @cache_root = nil
         FileFinder.root_level = nil
       end
 
+      # rubocop:disable-next Metrics/AbcSize
       def load_file(file, check: true)
         path = file_path(file)
 
         hash = load_yaml_configuration(path)
 
+        rubocop_config = Config.create(hash, path, check: false)
+        plugins = hash.delete('plugins')
+        loaded_plugins = resolver.resolve_plugins(rubocop_config, plugins)
+        add_loaded_plugins(loaded_plugins)
+
         loaded_features = resolver.resolve_requires(path, hash)
         add_loaded_features(loaded_features)
 
-        resolver.override_department_setting_for_cops({}, hash)
         resolver.resolve_inheritance_from_gems(hash)
         resolver.resolve_inheritance(path, hash, file, debug?)
         hash.delete('inherit_from')
@@ -76,7 +84,9 @@ module RuboCop
 
         puts "configuration from #{absolute_path}" if debug?
 
-        raise(TypeError, "Malformed configuration in #{absolute_path}") unless hash.is_a?(Hash)
+        unless hash.is_a?(Hash)
+          raise(ValidationError, "Malformed configuration in #{absolute_path}")
+        end
 
         hash
       end
@@ -84,8 +94,12 @@ module RuboCop
       def add_missing_namespaces(path, hash)
         # Using `hash.each_key` will cause the
         # `can't add a new key into hash during iteration` error
+        obsoletion = ConfigObsoletion.new(hash)
+
         hash_keys = hash.keys
         hash_keys.each do |key|
+          next if obsoletion.deprecated_cop_name?(key)
+
           q = Cop::Registry.qualified_cop_name(key, path)
           next if q == key
 
@@ -110,7 +124,7 @@ module RuboCop
       end
 
       def configuration_from_file(config_file, check: true)
-        return default_configuration if config_file == DEFAULT_FILE
+        return apply_default_overrides(default_configuration) if config_file == DEFAULT_FILE
 
         config = load_file(config_file, check: check)
         config.validate_after_resolution if check
@@ -121,21 +135,7 @@ module RuboCop
           add_excludes_from_files(config, config_file)
         end
 
-        merge_with_default(config, config_file).tap do |merged_config|
-          unless possible_new_cops?(merged_config)
-            pending_cops = pending_cops_only_qualified(merged_config.pending_cops)
-            warn_on_pending_cops(pending_cops) unless pending_cops.empty?
-          end
-        end
-      end
-
-      def pending_cops_only_qualified(pending_cops)
-        pending_cops.select { |cop| Cop::Registry.qualified_cop?(cop.name) }
-      end
-
-      def possible_new_cops?(config)
-        disable_pending_cops || enable_pending_cops ||
-          config.disabled_new_cops? || config.enabled_new_cops?
+        merge_with_default(config, config_file)
       end
 
       def add_excludes_from_files(config, config_file)
@@ -155,13 +155,25 @@ module RuboCop
         end
       end
 
-      # @api private
-      def inject_defaults!(project_root)
-        path = File.join(project_root, 'config', 'default.yml')
-        config = load_file(path)
-        new_config = ConfigLoader.merge_with_default(config, path)
-        puts "configuration from #{path}" if debug?
-        @default_configuration = new_config
+      # This API is primarily intended for testing and documenting plugins.
+      # When testing a plugin using `rubocop/rspec/support`, the plugin is loaded automatically,
+      # so this API is usually not needed. It is intended to be used only when implementing tests
+      # that do not use `rubocop/rspec/support`.
+      def inject_defaults!(config_yml_path)
+        if Pathname(config_yml_path).directory?
+          warn Rainbow(<<~MESSAGE).yellow, uplevel: 1
+            Use config YAML file path instead of project root directory.
+            e.g., `path/to/config/default.yml`
+          MESSAGE
+          raise ArgumentError,
+                'Passing a project root directory to `inject_defaults!` is no longer supported.'
+        end
+
+        path = config_yml_path.to_s
+        hash = ConfigLoader.load_yaml_configuration(path)
+        config = Config.new(hash, path).tap(&:make_excludes_absolute)
+
+        @default_configuration = ConfigLoader.merge_with_default(config, path)
       end
 
       # Returns the path RuboCop inferred as the root of the project. No file
@@ -176,24 +188,35 @@ module RuboCop
         ConfigFinder.project_root
       end
 
-      def warn_on_pending_cops(pending_cops)
-        warn Rainbow(PENDING_BANNER).yellow
-
-        pending_cops.each { |cop| warn_pending_cop cop }
-
-        warn Rainbow('For more information: https://docs.rubocop.org/rubocop/versioning.html').yellow
+      # Merges the given configuration with the default one.
+      def merge_with_default(config, config_file, unset_nil: true)
+        resolver.merge_with_default(config, config_file, unset_nil: unset_nil)
       end
 
-      def warn_pending_cop(cop)
-        version = cop.metadata['VersionAdded'] || 'N/A'
+      # Applies CLI overrides for `AllCops/EnabledByDefault` and
+      # `AllCops/DisabledByDefault` to the given configuration. Used when the
+      # configuration would otherwise be returned without going through
+      # `merge_with_default` (e.g. there is no user-supplied `.rubocop.yml`).
+      # Used when there is no configuration file, so the defaults are the whole
+      # configuration and still need the same treatment `merge_with_default`
+      # would have given them.
+      def apply_default_overrides(config)
+        hash = resolver.apply_preview_defaults(config, preview == true)
+
+        unless @enabled_by_default.nil? && @disabled_by_default.nil?
+          hash = hash.transform_values do |params|
+            params.is_a?(Hash) ? params.merge('Enabled' => !@disabled_by_default) : params
+          end
+        end
 
-        warn Rainbow("#{cop.name}: # new in #{version}").yellow
-        warn Rainbow('  Enabled: true').yellow
+        Config.new(hash, config.loaded_path)
       end
 
-      # Merges the given configuration with the default one.
-      def merge_with_default(config, config_file, unset_nil: true)
-        resolver.merge_with_default(config, config_file, unset_nil: unset_nil)
+      # @api private
+      # Used to add plugins that were required inside a config or from
+      # the CLI using `--plugin`.
+      def add_loaded_plugins(loaded_plugins)
+        @loaded_plugins.merge(Array(loaded_plugins))
       end
 
       # @api private