rubocop-grantbirki 1.75.2

data/lib/rubocop/target_finder.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # 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}."
+
+    def initialize(config_store, options = {})
+      @config_store = config_store
+      @options = options
+    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
+    # @return [Array] array of file paths
+    def find(args, mode)
+      return target_files_in_dir if args.empty?
+
+      files = []
+
+      args.uniq.each do |arg|
+        files += if File.directory?(arg)
+                   target_files_in_dir(arg.chomp(File::SEPARATOR))
+                 else
+                   process_explicit_path(arg, mode)
+                 end
+      end
+
+      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.
+    # @param base_dir Root directory under which to search for
+    #   ruby source files
+    # @return [Array] Array of filenames
+    def target_files_in_dir(base_dir = Dir.pwd)
+      # 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 = if base_dir.include?(HIDDEN_PATH_SUBSTRING)
+                       all_files.select { |file| ruby_file?(file) }
+                     else
+                       all_files.select { |file| to_inspect?(file, hidden_files, base_dir_config) }
+                     end
+
+      target_files.sort_by!(&order)
+    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/**/*).
+    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)
+      dir_flags = flags | File::FNM_PATHNAME | File::FNM_EXTGLOB
+      patterns = wanted_dir_patterns(base_dir, exclude_pattern, dir_flags)
+      patterns.map! { |dir| File.join(dir, '*') }
+      # We need this special case to avoid creating the pattern
+      # /**/* which searches the entire file system.
+      patterns = [File.join(base_dir, '**/*')] if patterns.empty?
+
+      Dir.glob(patterns, flags).select { |path| FileTest.file?(path) }
+    end
+
+    private
+
+    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
+
+    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|
+        "\\#{reserved_glob_character}"
+      end
+
+      dirs = Dir.glob(File.join(base_dir, '*/'), flags)
+                .reject do |dir|
+                  next true if dir.end_with?('/./', '/../')
+                  next true if File.fnmatch?(exclude_pattern, dir, flags)
+
+                  symlink_excluded_or_infinite_loop?(base_dir, dir, exclude_pattern, flags)
+                end
+      dirs.flat_map { |dir| wanted_dir_patterns(dir, exclude_pattern, flags) }.unshift(base_dir)
+    end
+
+    def symlink_excluded_or_infinite_loop?(base_dir, current_dir, exclude_pattern, flags)
+      dir_realpath = File.realpath(current_dir)
+      File.symlink?(current_dir.chomp('/')) && (
+        File.fnmatch?(exclude_pattern, "#{dir_realpath}/", flags) ||
+        File.realpath(base_dir).start_with?(dir_realpath)
+      )
+    end
+
+    def combined_exclude_glob_patterns(base_dir)
+      exclude = @config_store.for(base_dir).for_all_cops['Exclude'] || []
+      patterns = exclude.select { |pattern| pattern.is_a?(String) && pattern.end_with?('/**/*') }
+                        .map { |pattern| pattern.sub("#{base_dir}/", '') }
+      "#{base_dir}/{#{patterns.join(',')}}"
+    end
+
+    def ruby_filenames
+      @ruby_filenames ||= begin
+        file_patterns = all_cops_include.reject { |pattern| pattern.start_with?('**/*.') }
+        file_patterns.map { |pattern| pattern.sub('**/', '') }
+      end
+    end
+
+    def all_cops_include
+      @all_cops_include ||= @config_store.for_pwd.for_all_cops['Include'].map(&:to_s)
+    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) }
+      end
+      files.reject! { |file| FileTest.directory?(file) }
+
+      force_exclusion? ? without_excluded(files) : files
+    end
+
+    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 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 stdin?
+      @options.key?(:stdin)
+    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 configured_include?(file)
+      @config_store.for_pwd.file_to_include?(file)
+    end
+
+    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?
+        # Most recently modified file first.
+        ->(path) { -Integer(File.mtime(path)) }
+      else
+        :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

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+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, 3.4, 3.5].freeze
+    DEFAULT_VERSION = 2.7
+
+    OBSOLETE_RUBIES = {
+      1.9 => '0.41',
+      2.0 => '0.50',
+      2.1 => '0.57',
+      2.2 => '0.68',
+      2.3 => '0.81',
+      2.4 => '1.12',
+      2.5 => '1.28',
+      2.6 => '1.50'
+    }.freeze
+    private_constant :KNOWN_RUBIES, :OBSOLETE_RUBIES
+
+    # A place where information about a target ruby version is found.
+    # @api private
+    class Source
+      attr_reader :version, :name
+
+      def initialize(config)
+        @config = config
+        @version = find_version
+      end
+
+      def to_s
+        name
+      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
+      def name
+        "`TargetRubyVersion` parameter (in #{@config.smart_loaded_path})"
+      end
+
+      private
+
+      def find_version
+        @config.for_all_cops['TargetRubyVersion']&.to_f
+      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)
+        processed_source = ProcessedSource.from_file(
+          file, DEFAULT_VERSION, 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
+      RUBY_VERSION_FILENAME = '.ruby-version'
+      RUBY_VERSION_PATTERN = /\A(?:ruby-)?(?<version>\d+\.\d+)/.freeze
+
+      def name
+        "`#{RUBY_VERSION_FILENAME}`"
+      end
+
+      private
+
+      def filename
+        RUBY_VERSION_FILENAME
+      end
+
+      def pattern
+        RUBY_VERSION_PATTERN
+      end
+
+      def find_version
+        file = version_file
+        return unless file && File.file?(file)
+
+        File.read(file).match(pattern) { |md| md[:version].to_f }
+      end
+
+      def version_file
+        @version_file ||= @config.find_file_upwards(filename, @config.base_dir_for_path_parameters)
+      end
+    end
+
+    # The target ruby version may be found in a .tool-versions file, in a line
+    # starting with `ruby`.
+    # @api private
+    class ToolVersionsFile < RubyVersionFile
+      TOOL_VERSIONS_FILENAME = '.tool-versions'
+      TOOL_VERSIONS_PATTERN = /^(?:ruby )(?<version>\d+\.\d+)/.freeze
+
+      def name
+        "`#{TOOL_VERSIONS_FILENAME}`"
+      end
+
+      private
+
+      def filename
+        TOOL_VERSIONS_FILENAME
+      end
+
+      def pattern
+        TOOL_VERSIONS_PATTERN
+      end
+    end
+
+    # The lock file of Bundler may identify the target ruby version.
+    # @api private
+    class BundlerLockFile < Source
+      def name
+        "`#{bundler_lock_file_path}`"
+      end
+
+      private
+
+      def find_version
+        lock_file_path = bundler_lock_file_path
+        return nil unless lock_file_path
+
+        in_ruby_section = false
+        File.foreach(lock_file_path) do |line|
+          # If ruby is in Gemfile.lock or gems.lock, there should be two lines
+          # towards the bottom of the file that look like:
+          #     RUBY VERSION
+          #       ruby W.X.YpZ
+          # We ultimately want to match the "ruby W.X.Y.pZ" line, but there's
+          # extra logic to make sure we only start looking once we've seen the
+          # "RUBY VERSION" line.
+          in_ruby_section ||= line.match(/^\s*RUBY\s*VERSION\s*$/)
+          next unless in_ruby_section
+
+          # We currently only allow this feature to work with MRI ruby. If
+          # jruby (or something else) is used by the project, it's lock file
+          # will have a line that looks like:
+          #     RUBY VERSION
+          #       ruby W.X.YpZ (jruby x.x.x.x)
+          # The regex won't match in this situation.
+          result = line.match(/^\s*ruby\s+(\d+\.\d+)[p.\d]*\s*$/)
+          return result.captures.first.to_f if result
+        end
+      end
+
+      def bundler_lock_file_path
+        @config.bundler_lock_file_path
+      end
+    end
+
+    # If all else fails, a default version will be picked.
+    # @api private
+    class Default < Source
+      def name
+        'default'
+      end
+
+      private
+
+      def find_version
+        DEFAULT_VERSION
+      end
+    end
+
+    def self.supported_versions
+      KNOWN_RUBIES
+    end
+
+    SOURCES = [
+      RuboCopEnvVar,
+      RuboCopConfig,
+      GemspecFile,
+      RubyVersionFile,
+      ToolVersionsFile,
+      BundlerLockFile,
+      Default
+    ].freeze
+
+    private_constant :SOURCES
+    def initialize(config)
+      @config = config
+    end
+
+    def source
+      @source ||= SOURCES.each.lazy.map { |c| c.new(@config) }.detect(&:version)
+    end
+
+    def version
+      source.version
+    end
+
+    def supported?
+      KNOWN_RUBIES.include?(version)
+    end
+
+    def rubocop_version_with_support
+      if supported?
+        RuboCop::Version::STRING
+      else
+        OBSOLETE_RUBIES[version]
+      end
+    end
+  end
+end

data/lib/rubocop/util.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This module contains a collection of useful utility methods.
+  module Util
+    def self.silence_warnings
+      # Replaces Kernel::silence_warnings since it hides any warnings,
+      # including the RuboCop ones
+      old_verbose = $VERBOSE
+      $VERBOSE = nil
+      yield
+    ensure
+      $VERBOSE = old_verbose
+    end
+  end
+end

data/lib/rubocop/version.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This module holds the RuboCop version information.
+  module Version
+    STRING = '1.75.2'
+
+    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', '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
+        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)
+        return verbose_version unless env
+
+        extension_versions = extension_versions(env)
+        return verbose_version if extension_versions.empty?
+
+        <<~VERSIONS
+          #{verbose_version}
+          #{extension_versions.join("\n")}
+        VERSIONS
+      else
+        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)
+      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
+
+      # 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.
+        # Usually it would be the same as the extension name. but sometimes authors
+        # can choose slightly different name for their gems, e.g. rubocop-md instead of
+        # rubocop-markdown.
+        feature = EXTENSION_PATH_NAMES.fetch(loaded_feature, match[:feature])
+
+        begin
+          require "rubocop/#{feature}/version"
+        rescue LoadError
+          # Not worth mentioning libs that are not installed
+        end
+
+        next unless (feature_version = feature_version(feature))
+
+        "  - #{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:
+    #
+    # * Find by RuboCop core version style (e.g. rubocop-performance, rubocop-rspec)
+    # * Find by `bundle gem` version style (e.g. rubocop-rake)
+    #
+    # @api private
+    def self.feature_version(feature)
+      capitalized_feature = feature.capitalize
+      extension_name = CANONICAL_FEATURE_NAMES.fetch(capitalized_feature, capitalized_feature)
+
+      # Find by RuboCop core version style (e.g. rubocop-performance, rubocop-rspec)
+      RuboCop.const_get(extension_name)::Version::STRING
+    rescue NameError
+      begin
+        # Find by `bundle gem` version style (e.g. rubocop-rake, rubocop-packaging)
+        RuboCop.const_get(extension_name)::VERSION
+      rescue NameError
+        # noop
+      end
+    end
+
+    # @api private
+    def self.document_version
+      STRING.match('\d+\.\d+').to_s
+    end
+
+    # @api private
+    def self.server_mode
+      RuboCop.const_defined?(:Server) && Server.running? ? ' +server' : ''
+    end
+  end
+end

data/lib/rubocop/warning.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # A Warning exception is different from an Offense with severity 'warning'
+  # When a Warning is raised, this means that RuboCop was unable to perform a
+  # requested operation (such as inspecting or correcting a source file) due to
+  # user error
+  # For example, a configuration value in .rubocop.yml might be malformed
+  class Warning < StandardError
+  end
+end