rubocop 1.57.1 → 1.81.6

data/lib/rubocop/target_finder.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 module RuboCop
-  # This class finds target files to inspect by scanning the directory tree
-  # and picking ruby files.
+  # This class finds target files to inspect by scanning the directory tree and picking ruby files.
   # @api private
   class TargetFinder
     HIDDEN_PATH_SUBSTRING = "#{File::SEPARATOR}."
@@ -12,21 +11,8 @@ module RuboCop
       @options = options
     end
 
-    def force_exclusion?
-      @options[:force_exclusion]
-    end
-
-    def debug?
-      @options[:debug]
-    end
-
-    def fail_fast?
-      @options[:fail_fast]
-    end
-
-    # Generate a list of target files by expanding globbing patterns
-    # (if any). If args is empty, recursively find all Ruby source
-    # files under the current directory
+    # Generate a list of target files by expanding globbing patterns (if any). If args is empty,
+    # recursively find all Ruby source files under the current directory
     # @return [Array] array of file paths
     def find(args, mode)
       return target_files_in_dir if args.empty?
@@ -44,12 +30,11 @@ module RuboCop
       files.map { |f| File.expand_path(f) }.uniq
     end
 
-    # Finds all Ruby source files under the current or other supplied
-    # directory. A Ruby source file is defined as a file with the `.rb`
-    # extension or a file with no extension that has a ruby shebang line
-    # as its first line.
-    # It is possible to specify includes and excludes using the config file,
-    # so you can include other Ruby files like Rakefiles and gemspecs.
+    # Finds all Ruby source files under the current or other supplied directory. A Ruby source file
+    # is defined as a file with the `.rb` extension or a file with no extension that has a ruby
+    # shebang line as its first line.
+    # It is possible to specify includes and excludes using the config file, so you can include
+    # other Ruby files like Rakefiles and gemspecs.
     # @param base_dir Root directory under which to search for
     #   ruby source files
     # @return [Array] Array of filenames
@@ -57,29 +42,21 @@ module RuboCop
       # Support Windows: Backslashes from command-line -> forward slashes
       base_dir = base_dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
       all_files = find_files(base_dir, File::FNM_DOTMATCH)
-      # use file.include? for performance optimization
-      hidden_files = all_files.select { |file| file.include?(HIDDEN_PATH_SUBSTRING) }.sort
       base_dir_config = @config_store.for(base_dir)
 
-      target_files = all_files.select { |file| to_inspect?(file, hidden_files, base_dir_config) }
+      target_files = if hidden_path?(base_dir)
+                       all_files.select { |file| ruby_file?(file) }
+                     else
+                       all_files.select { |file| to_inspect?(file, base_dir_config) }
+                     end
 
       target_files.sort_by!(&order)
     end
 
-    def to_inspect?(file, hidden_files, base_dir_config)
-      return false if base_dir_config.file_to_exclude?(file)
-      return true if !hidden_files.bsearch do |hidden_file|
-        file <=> hidden_file
-      end && ruby_file?(file)
-
-      base_dir_config.file_to_include?(file)
-    end
-
-    # Search for files recursively starting at the given base directory using
-    # the given flags that determine how the match is made. Excluded files will
-    # be removed later by the caller, but as an optimization find_files removes
-    # the top level directories that are excluded in configuration in the
-    # normal way (dir/**/*).
+    # Search for files recursively starting at the given base directory using the given flags that
+    # determine how the match is made. Excluded files will be removed later by the caller, but as an
+    # optimization find_files removes the top level directories that are excluded in configuration
+    # in the normal way (dir/**/*).
     def find_files(base_dir, flags)
       # get all wanted directories first to improve speed of finding all files
       exclude_pattern = combined_exclude_glob_patterns(base_dir)
@@ -93,9 +70,22 @@ module RuboCop
       Dir.glob(patterns, flags).select { |path| FileTest.file?(path) }
     end
 
+    private
+
+    def to_inspect?(file, base_dir_config)
+      return false if base_dir_config.file_to_exclude?(file)
+      return true if !hidden_path?(file) && ruby_file?(file)
+
+      base_dir_config.file_to_include?(file)
+    end
+
+    def hidden_path?(path)
+      path.include?(HIDDEN_PATH_SUBSTRING)
+    end
+
     def wanted_dir_patterns(base_dir, exclude_pattern, flags)
       # Escape glob characters in base_dir to avoid unwanted behavior.
-      base_dir = base_dir.gsub(/[\\\{\}\[\]\*\?]/) do |reserved_glob_character|
+      base_dir = base_dir.gsub(/[\\{}\[\]*?]/) do |reserved_glob_character|
         "\\#{reserved_glob_character}"
       end
 
@@ -124,21 +114,6 @@ module RuboCop
       "#{base_dir}/{#{patterns.join(',')}}"
     end
 
-    def ruby_extension?(file)
-      ruby_extensions.include?(File.extname(file))
-    end
-
-    def ruby_extensions
-      @ruby_extensions ||= begin
-        ext_patterns = all_cops_include.select { |pattern| pattern.start_with?('**/*.') }
-        ext_patterns.map { |pattern| pattern.sub('**/*', '') }
-      end
-    end
-
-    def ruby_filename?(file)
-      ruby_filenames.include?(File.basename(file))
-    end
-
     def ruby_filenames
       @ruby_filenames ||= begin
         file_patterns = all_cops_include.reject { |pattern| pattern.start_with?('**/*.') }
@@ -150,53 +125,73 @@ module RuboCop
       @all_cops_include ||= @config_store.for_pwd.for_all_cops['Include'].map(&:to_s)
     end
 
-    def ruby_executable?(file)
-      return false unless File.extname(file).empty? && File.exist?(file)
+    def process_explicit_path(path, mode)
+      files = path.include?('*') ? Dir[path] : [path]
 
-      first_line = File.open(file, &:readline)
-      /#!.*(#{ruby_interpreters(file).join('|')})/.match?(first_line)
-    rescue EOFError, ArgumentError => e
-      warn("Unprocessable file #{file}: #{e.class}, #{e.message}") if debug?
+      if mode == :only_recognized_file_types || force_exclusion?
+        files.select! { |file| included_file?(file) }
+      end
+      files.reject! { |file| FileTest.directory?(file) }
 
-      false
+      force_exclusion? ? without_excluded(files) : files
     end
 
-    def ruby_interpreters(file)
-      @config_store.for(file).for_all_cops['RubyInterpreters']
+    def without_excluded(files)
+      files.reject do |file|
+        # When --ignore-parent-exclusion is given, we must look at the configuration associated with
+        # the file, but in the default case when --ignore-parent-exclusion is not given, can safely
+        # look only at the configuration for the current directory, since it's only the Exclude
+        # parameters we're going to check.
+        config = @config_store.for(ignore_parent_exclusion? ? file : '.')
+        config.file_to_exclude?(file)
+      end
     end
 
-    def stdin?
-      @options.key?(:stdin)
+    def included_file?(file)
+      ruby_file?(file) || configured_include?(file)
     end
 
     def ruby_file?(file)
       stdin? || ruby_extension?(file) || ruby_filename?(file) || ruby_executable?(file)
     end
 
-    def configured_include?(file)
-      @config_store.for_pwd.file_to_include?(file)
+    def stdin?
+      @options.key?(:stdin)
     end
 
-    def included_file?(file)
-      ruby_file?(file) || configured_include?(file)
+    def ruby_extension?(file)
+      ruby_extensions.include?(File.extname(file))
     end
 
-    def process_explicit_path(path, mode)
-      files = path.include?('*') ? Dir[path] : [path]
-
-      if mode == :only_recognized_file_types || force_exclusion?
-        files.select! { |file| included_file?(file) }
+    def ruby_extensions
+      @ruby_extensions ||= begin
+        ext_patterns = all_cops_include.select { |pattern| pattern.start_with?('**/*.') }
+        ext_patterns.map { |pattern| pattern.sub('**/*', '') }
       end
+    end
 
-      return files unless force_exclusion?
+    def ruby_filename?(file)
+      ruby_filenames.include?(File.basename(file))
+    end
 
-      files.reject do |file|
-        config = @config_store.for(file)
-        config.file_to_exclude?(file)
-      end
+    def configured_include?(file)
+      @config_store.for_pwd.file_to_include?(file)
     end
 
-    private
+    def ruby_executable?(file)
+      return false if !File.extname(file).empty? || !File.exist?(file) || File.empty?(file)
+
+      first_line = File.open(file, &:readline)
+      /#!.*(#{ruby_interpreters(file).join('|')})/.match?(first_line)
+    rescue EOFError, ArgumentError => e
+      warn("Unprocessable file #{file}: #{e.class}, #{e.message}") if debug?
+
+      false
+    end
+
+    def ruby_interpreters(file)
+      @config_store.for(file).for_all_cops['RubyInterpreters']
+    end
 
     def order
       if fail_fast?
@@ -206,5 +201,21 @@ module RuboCop
         :itself
       end
     end
+
+    def force_exclusion?
+      @options[:force_exclusion]
+    end
+
+    def ignore_parent_exclusion?
+      @options[:ignore_parent_exclusion]
+    end
+
+    def debug?
+      @options[:debug]
+    end
+
+    def fail_fast?
+      @options[:fail_fast]
+    end
   end
 end

data/lib/rubocop/target_ruby.rb

@@ -4,7 +4,7 @@ module RuboCop
   # The kind of Ruby that code inspected by RuboCop is written in.
   # @api private
   class TargetRuby
-    KNOWN_RUBIES = [2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3].freeze
+    KNOWN_RUBIES = [2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3, 3.4, 3.5].freeze
     DEFAULT_VERSION = 2.7
 
     OBSOLETE_RUBIES = {
@@ -34,6 +34,20 @@ module RuboCop
       end
     end
 
+    # The target ruby version may be configured by setting the
+    # `RUBOCOP_TARGET_RUBY_VERSION` environment variable.
+    class RuboCopEnvVar < Source
+      def name
+        '`RUBOCOP_TARGET_RUBY_VERSION` environment variable'
+      end
+
+      private
+
+      def find_version
+        ENV.fetch('RUBOCOP_TARGET_RUBY_VERSION', nil)&.to_f
+      end
+    end
+
     # The target ruby version may be configured in RuboCop's config.
     # @api private
     class RuboCopConfig < Source
@@ -48,6 +62,99 @@ module RuboCop
       end
     end
 
+    # The target ruby version may be found in a .gemspec file.
+    # @api private
+    class GemspecFile < Source
+      extend NodePattern::Macros
+
+      # @!method required_ruby_version(node)
+      def_node_search :required_ruby_version, <<~PATTERN
+        (send _ :required_ruby_version= $_)
+      PATTERN
+
+      # @!method gem_requirement_versions(node)
+      def_node_matcher :gem_requirement_versions, <<~PATTERN
+        (send (const(const _ :Gem):Requirement) :new
+          {$str+ | (send $str :freeze)+ | (array $str+) | (array (send $str :freeze)+)}
+        )
+      PATTERN
+
+      def name
+        "`required_ruby_version` parameter (in #{gemspec_filepath})"
+      end
+
+      private
+
+      def find_version
+        file = gemspec_filepath
+        return unless file && File.file?(file)
+
+        right_hand_side = version_from_gemspec_file(file)
+        return if right_hand_side.nil?
+
+        find_minimal_known_ruby(right_hand_side)
+      end
+
+      def gemspec_filepath
+        return @gemspec_filepath if defined?(@gemspec_filepath)
+
+        @gemspec_filepath =
+          @config.traverse_directories_upwards(@config.base_dir_for_path_parameters) do |dir|
+            # NOTE: Can't use `dir.glob` because of JRuby 9.4.8.0 incompatibility:
+            # https://github.com/jruby/jruby/issues/8358
+            candidates = Pathname.glob("#{dir}/*.gemspec")
+            # Bundler will use a gemspec whatever the filename is, as long as its the only one in
+            # the folder.
+            break candidates.first if candidates.one?
+          end
+      end
+
+      def version_from_gemspec_file(file)
+        # When using parser_prism, we need to use a Ruby version that Prism supports (3.3+)
+        # for parsing the gemspec file. This doesn't affect the detected Ruby version,
+        # it's just for the parsing step.
+        ruby_version_for_parsing = if @config.parser_engine == :parser_prism
+                                     3.3
+                                   else
+                                     DEFAULT_VERSION
+                                   end
+
+        processed_source = ProcessedSource.from_file(
+          file, ruby_version_for_parsing, parser_engine: @config.parser_engine
+        )
+        return unless processed_source.valid_syntax?
+
+        required_ruby_version(processed_source.ast).first
+      end
+
+      def version_from_right_hand_side(right_hand_side)
+        gem_requirement_versions = gem_requirement_versions(right_hand_side)
+
+        if right_hand_side.array_type? && right_hand_side.children.all?(&:str_type?)
+          version_from_array(right_hand_side)
+        elsif gem_requirement_versions
+          gem_requirement_versions.map(&:value)
+        elsif right_hand_side.str_type?
+          right_hand_side.value
+        end
+      end
+
+      def version_from_array(array)
+        array.children.map(&:value)
+      end
+
+      def find_minimal_known_ruby(right_hand_side)
+        version = version_from_right_hand_side(right_hand_side)
+        return unless version
+
+        requirement = Gem::Requirement.new(version)
+
+        KNOWN_RUBIES.detect do |v|
+          requirement.satisfied_by?(Gem::Version.new("#{v}.99"))
+        end
+      end
+    end
+
     # The target ruby version may be found in a .ruby-version file.
     # @api private
     class RubyVersionFile < Source
@@ -143,84 +250,6 @@ module RuboCop
       end
     end
 
-    # The target ruby version may be found in a .gemspec file.
-    # @api private
-    class GemspecFile < Source
-      extend NodePattern::Macros
-
-      GEMSPEC_EXTENSION = '.gemspec'
-
-      # @!method required_ruby_version(node)
-      def_node_search :required_ruby_version, <<~PATTERN
-        (send _ :required_ruby_version= $_)
-      PATTERN
-
-      # @!method gem_requirement_versions(node)
-      def_node_matcher :gem_requirement_versions, <<~PATTERN
-        (send (const(const _ :Gem):Requirement) :new
-          {$str+ | (send $str :freeze)+ | (array $str+) | (array (send $str :freeze)+)}
-        )
-      PATTERN
-
-      def name
-        "`required_ruby_version` parameter (in #{gemspec_filename})"
-      end
-
-      private
-
-      def find_version
-        file = gemspec_filepath
-        return unless file && File.file?(file)
-
-        right_hand_side = version_from_gemspec_file(file)
-        return if right_hand_side.nil?
-
-        find_default_minimal_known_ruby(right_hand_side)
-      end
-
-      def gemspec_filename
-        @gemspec_filename ||= begin
-          basename = Pathname.new(@config.base_dir_for_path_parameters).basename.to_s
-          "#{basename}#{GEMSPEC_EXTENSION}"
-        end
-      end
-
-      def gemspec_filepath
-        @gemspec_filepath ||=
-          @config.find_file_upwards(gemspec_filename, @config.base_dir_for_path_parameters)
-      end
-
-      def version_from_gemspec_file(file)
-        processed_source = ProcessedSource.from_file(file, DEFAULT_VERSION)
-        required_ruby_version(processed_source.ast).first
-      end
-
-      def version_from_right_hand_side(right_hand_side)
-        gem_requirement_versions = gem_requirement_versions(right_hand_side)
-
-        if right_hand_side.array_type?
-          version_from_array(right_hand_side)
-        elsif gem_requirement_versions
-          gem_requirement_versions.map(&:value)
-        else
-          right_hand_side.value
-        end
-      end
-
-      def version_from_array(array)
-        array.children.map(&:value)
-      end
-
-      def find_default_minimal_known_ruby(right_hand_side)
-        version = version_from_right_hand_side(right_hand_side)
-        requirement = Gem::Requirement.new(version)
-
-        KNOWN_RUBIES.detect do |v|
-          v >= DEFAULT_VERSION && requirement.satisfied_by?(Gem::Version.new("#{v}.99"))
-        end
-      end
-    end
-
     # If all else fails, a default version will be picked.
     # @api private
     class Default < Source
@@ -240,11 +269,12 @@ module RuboCop
     end
 
     SOURCES = [
+      RuboCopEnvVar,
       RuboCopConfig,
+      GemspecFile,
       RubyVersionFile,
       ToolVersionsFile,
       BundlerLockFile,
-      GemspecFile,
       Default
     ].freeze
 
@@ -267,7 +297,7 @@ module RuboCop
 
     def rubocop_version_with_support
       if supported?
-        RuboCop::Version.version
+        RuboCop::Version::STRING
       else
         OBSOLETE_RUBIES[version]
       end

data/lib/rubocop/version.rb

@@ -3,25 +3,33 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.57.1'
+    STRING = '1.81.6'
 
-    MSG = '%<version>s (using Parser %<parser_version>s, ' \
+    MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \
+          'analyzing as Ruby %<target_ruby_version>s, ' \
           'running on %<ruby_engine>s %<ruby_version>s)%<server_mode>s [%<ruby_platform>s]'
 
+    MINIMUM_PARSABLE_PRISM_VERSION = 3.3
+
     CANONICAL_FEATURE_NAMES = {
       'Rspec' => 'RSpec', 'Graphql' => 'GraphQL', 'Md' => 'Markdown', 'Factory_bot' => 'FactoryBot',
-      'Thread_safety' => 'ThreadSafety'
+      'Thread_safety' => 'ThreadSafety', 'Rspec_rails' => 'RSpecRails'
     }.freeze
     EXTENSION_PATH_NAMES = {
       'rubocop-md' => 'markdown', 'rubocop-factory_bot' => 'factory_bot'
     }.freeze
 
+    # NOTE: Marked as private but used by gems like standard.
     # @api private
+    # rubocop:disable Metrics/MethodLength
     def self.version(debug: false, env: nil)
       if debug
-        verbose_version = format(MSG, version: STRING, parser_version: Parser::VERSION,
+        target_ruby_version = target_ruby_version(env)
+        verbose_version = format(MSG, version: STRING,
+                                      parser_version: parser_version(target_ruby_version),
                                       rubocop_ast_version: RuboCop::AST::Version::STRING,
+                                      target_ruby_version: target_ruby_version,
                                       ruby_engine: RUBY_ENGINE, ruby_version: RUBY_VERSION,
                                       server_mode: server_mode,
                                       ruby_platform: RUBY_PLATFORM)
@@ -38,16 +46,45 @@ module RuboCop
         STRING
       end
     end
+    # rubocop:enable Metrics/MethodLength
+
+    # @api private
+    def self.verbose(env: nil)
+      version(debug: true, env: env)
+    end
 
     # @api private
+    def self.parser_version(target_ruby_version)
+      config_path = ConfigFinder.find_config_path(Dir.pwd)
+      yaml = Util.silence_warnings do
+        ConfigLoader.load_yaml_configuration(config_path)
+      end
+      parser_engine = yaml.dig('AllCops', 'ParserEngine')
+      parser_engine_text = ", #{parser_engine}" if parser_engine
+
+      if target_ruby_version >= MINIMUM_PARSABLE_PRISM_VERSION
+        "Parser #{Parser::VERSION}, Prism #{Prism::VERSION}#{parser_engine_text}"
+      else
+        "Parser #{Parser::VERSION}"
+      end
+    end
+
+    # @api private
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     def self.extension_versions(env)
-      features = Util.silence_warnings do
-        # Suppress any config issues when loading the config (ie. deprecations,
-        # pending cops, etc.).
-        env.config_store.unvalidated.for_pwd.loaded_features.sort
+      plugins = config_for_pwd(env).loaded_plugins
+      plugin_versions = plugins.filter_map do |plugin|
+        next if Plugin::BUILTIN_INTERNAL_PLUGINS.key?(plugin.about.name)
+        next unless (plugin_name = plugin.about.name)
+
+        "  - #{plugin_name} #{plugin.about.version}"
       end
 
-      features.filter_map do |loaded_feature|
+      # TODO: It needs to be maintained for a while to ensure compatibility with extensions that
+      # don't support plugins. It should be removed in future once the old style becomes obsolete.
+      features = config_for_pwd(env).loaded_features.sort
+      features -= plugins.map { |plugin| plugin.about.name }
+      feature_versions = features.filter_map do |loaded_feature|
         next unless (match = loaded_feature.match(/rubocop-(?<feature>.*)/))
 
         # Get the expected name of the folder containing the extension code.
@@ -66,6 +103,27 @@ module RuboCop
 
         "  - #{loaded_feature} #{feature_version}"
       end
+
+      plugin_versions + feature_versions
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+    # @api private
+    def self.target_ruby_version(env)
+      if env
+        config_for_pwd(env).target_ruby_version
+      else
+        TargetRuby.new(Config.new).version
+      end
+    end
+
+    # @api private
+    def self.config_for_pwd(env)
+      Util.silence_warnings do
+        # Suppress any config issues when loading the config (ie. deprecations,
+        # pending cops, etc.).
+        env.config_store.unvalidated.for_pwd
+      end
     end
 
     # Returns feature version in one of two ways:

data/lib/rubocop/yaml_duplication_checker.rb

@@ -5,36 +5,30 @@ module RuboCop
   # @api private
   module YAMLDuplicationChecker
     def self.check(yaml_string, filename, &on_duplicated)
-      # Ruby 2.6+
-      tree = if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0')
-               # Specify filename to display helpful message when it raises
-               # an error.
-               YAML.parse(yaml_string, filename: filename)
-             else
-               YAML.parse(yaml_string, filename)
-             end
-      return unless tree
-
-      traverse(tree, &on_duplicated)
+      handler = DuplicationCheckHandler.new(&on_duplicated)
+      parser = Psych::Parser.new(handler)
+      parser.parse(yaml_string, filename)
+      parser.handler.root.children[0]
     end
 
-    def self.traverse(tree, &on_duplicated)
-      case tree
-      when Psych::Nodes::Mapping
-        tree.children.each_slice(2).with_object([]) do |(key, value), keys|
-          exist = keys.find { |key2| key2.value == key.value }
-          yield(exist, key) if exist
-          keys << key
-          traverse(value, &on_duplicated)
-        end
-      else
-        children = tree.children
-        return unless children
+    class DuplicationCheckHandler < Psych::TreeBuilder # :nodoc:
+      def initialize(&block)
+        super()
+        @block = block
+      end
 
-        children.each { |c| traverse(c, &on_duplicated) }
+      def end_mapping
+        mapping_node = super
+        # OPTIMIZE: Use a hash for faster lookup since there can
+        # be quite a few keys at the top-level.
+        keys = {}
+        mapping_node.children.each_slice(2) do |key, _value|
+          duplicate = keys[key.value]
+          @block.call(duplicate, key) if duplicate
+          keys[key.value] = key
+        end
+        mapping_node
       end
     end
-
-    private_class_method :traverse
   end
 end