mux_ruby 5.1.0 → 5.2.0

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.92.2/lib/rubocop/target_finder.rb

@@ -0,0 +1,231 @@
+# 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)
+                   # Expand the directory so that the traversal can prune directories the
+                   # config excludes - the exclude patterns are absolute paths, and glued
+                   # onto a relative base (`rubocop .`) they never match anything.
+                   target_files_in_dir(File.expand_path(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 = PathUtil.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)
+      base_dir_config = @config_store.for(base_dir)
+
+      target_files = if hidden_dir?(base_dir)
+                       all_files.select { |file| ruby_file?(file) }
+                     else
+                       all_files.select { |file| to_inspect?(file, base_dir, 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, base_dir, base_dir_config)
+      return false if base_dir_config.file_to_exclude?(file)
+      return true if !hidden_file_in_dir?(file, base_dir) && ruby_file?(file)
+
+      base_dir_config.file_to_include?(file)
+    end
+
+    def hidden_dir?(dir)
+      basename = File.basename(dir)
+      basename.start_with?('.') && basename != '.' && basename != '..'
+    end
+
+    def hidden_file_in_dir?(file, base_dir)
+      base_dir = "#{base_dir}#{File::SEPARATOR}" unless base_dir.end_with?(File::SEPARATOR)
+      relative = file.delete_prefix(base_dir)
+      relative.start_with?('.') || relative.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|
+        "\\#{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/vendor/bundle/ruby/3.2.0/gems/rubocop-1.92.2/lib/rubocop/target_ruby.rb

@@ -0,0 +1,326 @@
+# 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, 4.0, 4.1
+    ].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, ConfigFinder.project_root
+        ) do |dir|
+          candidates = gemspec_candidates(dir)
+
+          # 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 gemspec_candidates(dir)
+        # NOTE: Can't use `dir.glob` because of JRuby 9.4.8.0 incompatibility:
+        # https://github.com/jruby/jruby/issues/8358
+        Pathname.glob("#{dir}/*.gemspec")
+      rescue SystemCallError
+        []
+      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
+      def name
+        "`#{filename}`"
+      end
+
+      private
+
+      def filename
+        '.ruby-version'
+      end
+
+      def pattern
+        /\A(?:ruby-)?(?<version>\d+\.\d+)/.freeze
+      end
+
+      def find_version
+        file = version_file
+        return unless file && File.file?(file)
+
+        File.read(file).match(pattern) { |md| md[:version].to_f }
+      rescue SystemCallError
+        nil
+      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
+      private
+
+      def filename
+        '.tool-versions'
+      end
+
+      def pattern
+        /^(?:ruby )(?<version>\d+\.\d+)/.freeze
+      end
+    end
+
+    # The target ruby version may be found in a mise.toml file, in a line
+    # starting with `ruby = "`.
+    # @api private
+    class MiseTomlFile < RubyVersionFile
+      private
+
+      def filename
+        'mise.toml'
+      end
+
+      def pattern
+        /^ruby = ["'](?<version>\d+\.\d+)/.freeze
+      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
+      rescue SystemCallError
+        nil
+      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,
+      MiseTomlFile,
+      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/vendor/bundle/ruby/3.2.0/gems/rubocop-1.92.2/lib/rubocop/todo_audit.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Audits `.rubocop_todo.yml` for `Exclude` entries that are no longer
+  # needed: files a cop would not flag anymore, or files that no longer
+  # exist. Used by the `--report-unused-todo-entries` option.
+  # @api private
+  class TodoAudit
+    Entry = Struct.new(:cop_name, :path)
+
+    def initialize(config_store, options)
+      @config_store = config_store
+      @options = options
+    end
+
+    # @return [Array<Entry>, nil] the unused entries, or `nil` when there is
+    #   no todo file to audit
+    def unused_entries
+      return nil unless todo_path
+
+      entries = todo_exclude_entries
+      return [] if entries.empty?
+
+      offending_cops = offending_cops_without_todo(entries)
+      entries.reject { |entry| offending_cops[absolute(entry.path)]&.include?(entry.cop_name) }
+    end
+
+    def todo_file
+      CLI::Command::AutoGenerateConfig::AUTO_GENERATED_FILE
+    end
+
+    private
+
+    def todo_path
+      return @todo_path if defined?(@todo_path)
+
+      path = File.expand_path(todo_file)
+      @todo_path = File.exist?(path) ? path : nil
+    end
+
+    def todo_exclude_entries
+      yaml = YAML.safe_load_file(todo_path, permitted_classes: [Regexp, Symbol], aliases: true)
+      return [] unless yaml.is_a?(Hash)
+
+      yaml.flat_map do |cop_name, cop_config|
+        next [] unless auditable_cop?(cop_name, cop_config)
+
+        cop_config['Exclude'].grep(String).map { |path| Entry.new(cop_name, path) }
+      end
+    end
+
+    # Only registered cops with an `Exclude` list can be audited - for an
+    # unknown cop (e.g. from an extension that is not loaded in this run)
+    # the absence of offenses proves nothing.
+    def auditable_cop?(cop_name, cop_config)
+      cop_name.include?('/') &&
+        cop_config.is_a?(Hash) &&
+        cop_config['Exclude'].is_a?(Array) &&
+        Cop::Registry.global.contains_cop_matching?([cop_name])
+    end
+
+    # Inspects every file the todo entries mention, with the todo exclusions
+    # subtracted from the configuration, and returns the names of the cops
+    # that still report offenses, keyed by absolute file path.
+    def offending_cops_without_todo(entries)
+      files = entries.map { |entry| absolute(entry.path) }.uniq.select { |file| File.file?(file) }
+
+      files.to_h do |file|
+        offenses = inspect_file(file, entries)
+        [file, offenses.to_set(&:cop_name)]
+      end
+    end
+
+    def inspect_file(file, entries)
+      config = audit_config(@config_store.for_file(file), entries)
+      team = Cop::Team.mobilize(Cop::Registry.global, config, @options.merge(autocorrect: false))
+
+      processed_source = ProcessedSource.from_file(
+        file, config.target_ruby_version, parser_engine: config.parser_engine
+      )
+      processed_source.config = config
+      processed_source.registry = Cop::Registry.global
+
+      team.investigate(processed_source).offenses.reject(&:disabled?)
+    end
+
+    # A copy of the configuration with the todo exclusions removed for the
+    # audited cops, so their offenses in the listed files become visible.
+    def audit_config(config, entries)
+      hash = config.to_hash.dup
+
+      entries.group_by(&:cop_name).each do |cop_name, cop_entries|
+        cop_config = hash[cop_name]
+        next unless cop_config.is_a?(Hash) && cop_config['Exclude'].is_a?(Array)
+
+        hash[cop_name] = subtract_excludes(cop_config, cop_entries)
+      end
+
+      Config.create(hash, config.loaded_path, check: false)
+    end
+
+    def subtract_excludes(cop_config, cop_entries)
+      removals = cop_entries.map { |entry| absolute(entry.path) }
+      cop_config.merge('Exclude' => cop_config['Exclude'] - removals)
+    end
+
+    def absolute(path)
+      File.expand_path(path, File.dirname(todo_path))
+    end
+  end
+end