ultra-pro-pkg 0.0.1

data/simplecov-1.0.0/lib/simplecov/parallel_coordination.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# simplecov:disable
+# Methods below only fire under a parallel test runner; not reachable
+# from a single-process rspec run. Cucumber's test_projects exercise
+# the parallel_tests integration end-to-end in subprocesses, but
+# those subprocesses don't merge their Coverage data back into the
+# parent this dogfood report measures.
+module SimpleCov
+  class << self
+    # @api private
+    def final_result_process?
+      adapter = SimpleCov::ParallelAdapters.current
+      # No recognized parallel-test adapter. A subprocess forked while
+      # coverage was running is never the final reporter — the process that
+      # spawned it merges every slice and produces the report. Without this,
+      # fork-based runners that don't set TEST_ENV_NUMBER (e.g. Minitest's
+      # `parallelize`) have every worker produce the final report and its
+      # warnings. See issue #1171.
+      return !forked_subprocess? unless adapter
+
+      adapter.first_worker?
+    end
+
+    # @api private
+    def wait_for_other_processes
+      adapter = SimpleCov::ParallelAdapters.current
+      return unless adapter && final_result_process?
+
+      # Native synchronization first (adapters that wrap a runner with a
+      # real "wait" primitive — parallel_tests'
+      # `wait_for_other_processes_to_finish` — implement this; adapters
+      # without a native API no-op and rely on the polling fallback below).
+      adapter.wait_for_siblings
+
+      # The native wait can return before sibling at_exit handlers finish
+      # writing resultsets, and adapters without a native wait have
+      # nothing else. Either way, poll the resultset cache until all
+      # expected workers have reported or a timeout is reached. Capture
+      # the outcome so `ready_to_process_results?` can suppress min/max
+      # threshold checks against a partial total.
+      @parallel_results_complete =
+        wait_for_parallel_results(adapter.expected_worker_count, native_wait: adapter.native_wait?)
+    end
+
+    # @api private — true when every sibling reported its resultset
+    # before the wait deadline. Defaults to true outside a parallel
+    # run (when `wait_for_other_processes` is a no-op).
+    def parallel_results_complete?
+      defined?(@parallel_results_complete) ? @parallel_results_complete : true
+    end
+
+    # @api private — seconds the resultset count must hold steady, after a
+    # native wait, before we accept fewer than `expected` workers as final.
+    PARALLEL_RESULTS_SETTLE = 0.5
+    private_constant :PARALLEL_RESULTS_SETTLE
+
+    # @api private — returns true when the reporting worker has every
+    # resultset it's going to get, false on timeout. Single-process runs
+    # (expected <= 1) short-circuit to true with no waiting.
+    #
+    # Normally we poll until `expected` (= PARALLEL_TEST_GROUPS) workers have
+    # reported or `SimpleCov.parallel_wait_timeout` elapses; raise that setting
+    # when a slow worker routinely finishes well after the others.
+    #
+    # When a native wait already confirmed every sibling PROCESS exited
+    # (`native_wait`), no further resultset will appear, so a count below
+    # `expected` just means some workers produced none — e.g. parallel_test
+    # groups that got no spec file on a machine with more cores than files.
+    # Once the count then holds steady for `PARALLEL_RESULTS_SETTLE` we accept
+    # it as final rather than blocking for the whole timeout. Without a native
+    # wait (GenericAdapter) we can't tell an idle worker from a slow one, so we
+    # keep waiting the full timeout.
+    def wait_for_parallel_results(expected, native_wait: false)
+      return true unless expected > 1 # simplecov:disable branch — only false in real parallel runs
+
+      deadline = monotonic_time + parallel_wait_timeout
+      tracker = {count: 0, since: monotonic_time}
+      loop do
+        seen = SimpleCov::ResultMerger.read_resultset.size
+        return true if seen >= expected
+        return true if native_wait && resultset_count_settled?(tracker, seen)
+        return false if parallel_wait_timed_out?(deadline, expected, seen)
+
+        sleep 0.1
+      end
+    end
+
+    # Track whether the resultset count has held steady (and positive) for
+    # `PARALLEL_RESULTS_SETTLE` seconds. `tracker` carries the last count and
+    # the time it last changed across poll iterations.
+    def resultset_count_settled?(tracker, count)
+      if count > tracker[:count]
+        tracker[:count] = count
+        tracker[:since] = monotonic_time
+        return false
+      end
+
+      count.positive? && (monotonic_time - tracker[:since]) >= PARALLEL_RESULTS_SETTLE
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    # @api private — true once the wait deadline has passed; warns on
+    # the first timeout so the user knows the merged total is partial.
+    def parallel_wait_timed_out?(deadline, expected, seen)
+      return false unless monotonic_time > deadline
+
+      warn_about_incomplete_parallel_results(expected, seen)
+      true
+    end
+
+    # @api private
+    def warn_about_incomplete_parallel_results(expected, seen)
+      return unless print_errors
+
+      warn SimpleCov::Color.colorize(
+        "Only #{seen} of #{expected} parallel-test workers reported within " \
+        "#{parallel_wait_timeout}s, so coverage totals are partial and minimum / " \
+        "maximum coverage checks are skipped for this run. Increase " \
+        "SimpleCov.parallel_wait_timeout if a worker routinely needs longer.",
+        :yellow
+      )
+    end
+  end
+end
+# simplecov:enable

data/simplecov-1.0.0/lib/simplecov/process.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Hooks `Process._fork` (Ruby 3.1+) so child processes inherit SimpleCov's
+# coverage tracking when `SimpleCov.enable_for_subprocesses?` is set.
+#
+# `Process._fork` is the official extension point: `Kernel#fork`,
+# `Process.fork`, `IO.popen("-")`, and similar all funnel through it.
+# Hooking `_fork` (instead of redefining `Process.fork`) composes
+# correctly with other libraries doing the same — they each prepend
+# their own module and chain via `super`.
+
+module SimpleCov
+  # Prepended onto Process's singleton class so every fork — direct or
+  # via Kernel#fork / IO.popen — re-runs SimpleCov's at_fork callback in
+  # the child.
+  module ProcessForkHook
+    def _fork
+      active = defined?(SimpleCov) && Coverage.running?
+      # Assign the next serial in the PARENT, before the fork, so the child
+      # inherits its own stable ordinal via copy-on-write. The default
+      # at_fork uses it (instead of the child pid) to name the subprocess's
+      # result, keeping that name identical across runs. See issue #1171.
+      SimpleCov.next_subprocess_serial! if active
+      pid = super
+      if pid.zero? && active
+        # Mark the child here, independent of whatever custom at_fork block
+        # the user installed, so `final_result_process?` can keep forked
+        # workers from each producing the final report. See issue #1171.
+        SimpleCov.mark_forked_subprocess!
+        SimpleCov.at_fork.call(::Process.pid)
+      end
+      pid
+    end
+  end
+end
+
+Process.singleton_class.prepend(SimpleCov::ProcessForkHook)

data/simplecov-1.0.0/lib/simplecov/profiles/bundler_filter.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "bundler_filter" do
+  skip "/vendor/bundle/"
+end

data/simplecov-1.0.0/lib/simplecov/profiles/hidden_filter.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "hidden_filter" do
+  skip(/\A\..*/)
+end

data/simplecov-1.0.0/lib/simplecov/profiles/rails.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "rails" do
+  load_profile "test_frameworks"
+
+  skip %r{\Aconfig/}
+  skip %r{\Adb/}
+
+  group "Controllers", "app/controllers"
+  group "Channels", "app/channels"
+  group "Models", "app/models"
+  group "Mailers", "app/mailers"
+  group "Helpers", "app/helpers"
+  group "Jobs", %w[app/jobs app/workers]
+  group "Libraries", "lib/"
+
+  # Preserve the legacy `track_files` semantics (additive disk-discovery
+  # without restricting the report's universe): write the ivar directly
+  # so loading the profile doesn't emit the public-API deprecation. Users
+  # migrating their own configs should prefer `cover "{app,lib}/**/*.rb"`,
+  # which both injects unloaded files and scopes the report to the match
+  # set — usually the intended behavior for a Rails project.
+  @tracked_files = "{app,lib}/**/*.rb"
+
+  # `parallelize(workers: ...)` forks worker processes that each run a
+  # slice of the suite. Without subprocess support, the workers' coverage
+  # is dropped on the floor and the parent records 0% for everything they
+  # touched. Hooking `Process._fork` makes each worker re-call
+  # `SimpleCov.start` with a unique command_name so the resultsets merge
+  # correctly.
+  merge_subprocesses true
+end

data/simplecov-1.0.0/lib/simplecov/profiles/root_filter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "root_filter" do
+  # Exclude all files outside of simplecov root. Shares the regex with
+  # SimpleCov::UselessResultsRemover so the root-prefix logic lives in one
+  # place; this profile is the user-facing entry point that tools like
+  # `SimpleCov.filtered` apply.
+  skip do |src|
+    src.filename !~ SimpleCov::UselessResultsRemover.root_regex
+  end
+end

data/simplecov-1.0.0/lib/simplecov/profiles/strict.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# A "no shortfalls allowed" profile: every coverage criterion is
+# enabled and held to 100%. Per
+# https://github.com/simplecov-ruby/simplecov/issues/1061, this lives as
+# an opt-in profile rather than the default — most projects can't
+# realistically start at 100% on day one — so a team that has paid down
+# the debt can flip the strict switch without re-typing the threshold
+# trio every time.
+#
+# JRuby gracefully degrades: `enable_coverage :branch` / `:method` are
+# accepted (they just add to the configured criteria set), but the
+# runtime can't actually measure them, so the corresponding stats never
+# materialize. `CoverageViolations` skips threshold lookups for
+# criteria not in the stats, so the `:branch` / `:method` clauses below
+# silently no-op on JRuby and only `:line` is enforced.
+#
+# `:eval` widens the universe of code held to 100% to include strings
+# passed through `Kernel#eval` (typically ERB templates, when the user
+# sets `ERB#filename=`). Guarded on `coverage_for_eval_supported?` so
+# the profile stays quiet on Ruby < 3.2, where `enable_coverage :eval`
+# would otherwise warn about the missing runtime support every time
+# the profile loads.
+SimpleCov.profiles.define "strict" do
+  enable_coverage :branch
+  enable_coverage :method
+  # simplecov:disable branch — dogfood runs on Ruby >= 3.2 only, so
+  # the else arm (eval coverage not supported) is unreachable from CI.
+  enable_coverage :eval if coverage_for_eval_supported?
+  # simplecov:enable
+  minimum_coverage line: 100, branch: 100, method: 100
+end

data/simplecov-1.0.0/lib/simplecov/profiles/test_frameworks.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "test_frameworks" do
+  skip %r{\A(test|features|spec|autotest)/}
+end

data/simplecov-1.0.0/lib/simplecov/profiles.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  #
+  # Profiles are SimpleCov configuration procs that can be easily
+  # loaded using SimpleCov.start :rails and defined using
+  #   SimpleCov.profiles.define :foo do
+  #     # SimpleCov configuration here, same as in  SimpleCov.configure
+  #   end
+  #
+  class Profiles < Hash
+    #
+    # Define a SimpleCov profile:
+    #   SimpleCov.profiles.define 'rails' do
+    #     # Same as SimpleCov.configure do .. here
+    #   end
+    #
+    def define(name, &blk)
+      name = name.to_sym
+      raise SimpleCov::ConfigurationError, "SimpleCov Profile '#{name}' is already defined" unless self[name].nil?
+
+      self[name] = blk
+    end
+
+    #
+    # Applies the profile of given name on SimpleCov.configure
+    #
+    def load(name)
+      SimpleCov.configure(&fetch_proc(name))
+    end
+
+    #
+    # Returns the proc registered for the given profile name, autoloading
+    # bundled or plugin-gem profiles on first lookup. Raises if the profile
+    # cannot be located.
+    #
+    # Lookup order:
+    #   1. already registered via #define
+    #   2. require "simplecov/profiles/<name>"   (bundled profiles)
+    #   3. require "simplecov-profile-<name>"    (third-party plugin gems)
+    #
+    def fetch_proc(name)
+      name = name.to_sym
+      autoload_profile(name) unless key?(name)
+      return self[name] if key?(name)
+
+      raise SimpleCov::ConfigurationError, "Could not find SimpleCov Profile called '#{name}'"
+    end
+
+  private
+
+    def autoload_profile(name)
+      require "simplecov/profiles/#{name}"
+    rescue LoadError
+      begin
+        # simplecov:disable — third-party gem fallback (no such gem in test env)
+        require "simplecov-profile-#{name}"
+        # simplecov:enable
+      rescue LoadError
+        # fall through; #fetch_proc raises the user-facing error
+      end
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/result/missing_source_files_reporter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class Result
+    # When a resultset references source files that don't exist on the local
+    # filesystem they're silently dropped — which produces an empty `0 / 0
+    # (100.00%)` report that looks like success but isn't. Emit a single
+    # warning summarizing the drop and, when every entry was lost, point at
+    # the typical cause (`SimpleCov.collate` invoked from a machine or path
+    # different from where the resultsets were generated). See #980.
+    class MissingSourceFilesReporter
+      def initialize(missing_paths, input_size:, every_entry_dropped:)
+        @missing_paths = missing_paths
+        @input_size = input_size
+        @every_entry_dropped = every_entry_dropped
+      end
+
+      def warn!
+        warn SimpleCov::Color.colorize(message, :yellow)
+      end
+
+      def message
+        @every_entry_dropped ? all_missing_warning : partial_missing_warning
+      end
+
+    private
+
+      def all_missing_warning
+        "SimpleCov dropped all #{@missing_paths.size} source file(s) from the result — " \
+          "none of the paths in the resultset exist on this filesystem: " \
+          "#{summary}. If you're running `SimpleCov.collate`, the source " \
+          "files must be available at the same absolute paths as when the individual resultsets " \
+          "were generated."
+      end
+
+      def partial_missing_warning
+        "SimpleCov dropped #{@missing_paths.size} source file(s) from the result because " \
+          "they don't exist on this filesystem: #{summary}. They were " \
+          "tracked in the resultset but have since moved or been removed."
+      end
+
+      def summary
+        sample = @missing_paths.first(5).join(", ")
+        remaining = @missing_paths.size - 5
+        remaining.positive? ? "#{sample} (+#{remaining} more)" : sample
+      end
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/result/source_file_builder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class Result
+    # Constructs `SimpleCov::SourceFile` instances from a raw coverage
+    # hash, sorts them by filename, and surfaces filenames whose source
+    # is no longer present on disk so the caller can warn about the
+    # silent drop (see #980).
+    class SourceFileBuilder
+      attr_reader :missing_source_files
+
+      def initialize(original_result, not_loaded_files:)
+        @original_result = original_result
+        @not_loaded_files = not_loaded_files
+        @missing_source_files = []
+      end
+
+      def call
+        SimpleCov::FileList.new(
+          @original_result
+            .filter_map { |filename, coverage| build_source_file(filename, coverage) }
+            .sort_by(&:filename)
+        )
+      end
+
+    private
+
+      def build_source_file(filename, coverage)
+        unless File.file?(filename)
+          @missing_source_files << filename
+          return
+        end
+
+        SimpleCov::SourceFile.new(
+          filename,
+          stringify_outer_keys(coverage),
+          loaded: !@not_loaded_files.include?(filename)
+        )
+      end
+
+      # `Coverage.result` returns symbol keys (`:lines`, `:branches`,
+      # `:methods`); resultsets loaded from disk are already string-keyed.
+      # SourceFile reads with strings, and handles both Array and
+      # stringified-Array branch/method keys via `restore_ruby_data_structure`,
+      # so only the outer hash needs normalizing.
+      def stringify_outer_keys(coverage)
+        coverage.transform_keys(&:to_s)
+      end
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/result.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+require "forwardable"
+require_relative "result/missing_source_files_reporter"
+require_relative "result/source_file_builder"
+
+module SimpleCov
+  #
+  # A simplecov code coverage result, initialized from the Hash Ruby's built-in coverage
+  # library generates (Coverage.result).
+  #
+  class Result
+    extend Forwardable
+
+    # Returns the original Coverage.result used for this instance of SimpleCov::Result
+    attr_reader :original_result
+    # Returns all files that are applicable to this result (sans filters!) as instances of
+    # SimpleCov::SourceFile. Aliased as :source_files
+    attr_reader :files
+    alias source_files files
+    # Explicitly set the Time this result has been created
+    attr_writer :created_at
+    # Explicitly set the command name that was used for this coverage result. Defaults to SimpleCov.command_name
+    attr_writer :command_name
+
+    def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength,
+                   :covered_lines, :missed_lines,
+                   :total_branches, :covered_branches, :missed_branches,
+                   :total_methods, :covered_methods, :missed_methods,
+                   :coverage_statistics, :coverage_statistics_by_file
+    def_delegator :files, :lines_of_code, :total_lines
+
+    # Bundles the filter and grouping configuration a Result applies to its
+    # source files after building them. Each field defaults to the SimpleCov
+    # singleton's configuration, so ordinary callers never construct one;
+    # tests pass a custom instance to opt out of (or extend) the project's
+    # filters or groups (e.g. `filters: []` to keep every file). Grouping the
+    # three together keeps Result#initialize's parameter list small.
+    class FilterConfig
+      attr_reader :filters, :cover_filters, :groups
+
+      def initialize(filters: SimpleCov.filters, cover_filters: SimpleCov.cover_filters, groups: SimpleCov.groups)
+        @filters = filters
+        @cover_filters = cover_filters
+        @groups = groups
+      end
+    end
+
+    # Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of
+    # coverage data).
+    #
+    # `filter_config` defaults to the SimpleCov singleton's filter / group
+    # configuration so existing call sites are unchanged. Pass a custom
+    # FilterConfig to opt out — useful for tests that build synthetic Results
+    # and don't want the project's filters or groups applied.
+    def initialize(original_result, command_name: nil, created_at: nil, not_loaded_files: Set.new,
+                   report: false, filter_config: FilterConfig.new)
+      @original_result = original_result.freeze
+      @command_name = command_name
+      @created_at = created_at
+      @groups_config = filter_config.groups
+      builder = SourceFileBuilder.new(original_result, not_loaded_files: not_loaded_files)
+      @files = builder.call
+      warn_about_missing_source_files(builder.missing_source_files, original_result.size) if report
+      apply_cover_filters!(filter_config.cover_filters)
+      apply_filters!(filter_config.filters)
+    end
+
+    # Returns all filenames for source files contained in this result
+    def filenames
+      files.map(&:filename)
+    end
+
+    # Returns the SimpleCov::SourceFile for the given path, or nil if no
+    # matching file is in this result. The path is resolved against
+    # SimpleCov.root, so callers can pass either an absolute path or a
+    # project-relative one.
+    def source_file_for(path)
+      target = File.expand_path(path, SimpleCov.root)
+      files.find { |file| file.filename == target }
+    end
+
+    # Returns the {line:/branch:/method:} coverage_statistics hash for the
+    # given file path, or nil if no matching source file is in this
+    # result. See SimpleCov::Result#source_file_for for path resolution.
+    def coverage_for(path)
+      source_file_for(path)&.coverage_statistics
+    end
+
+    # Returns a Hash of groups for this result. Define groups using SimpleCov.group 'Models', 'app/models'
+    def groups
+      @groups ||= SimpleCov.grouped(files, groups: @groups_config)
+    end
+
+    # Applies the configured SimpleCov.formatter on this result. Returns
+    # nil if formatting has been opted out of (`SimpleCov.formatter false`
+    # / `SimpleCov.formatters []`) — the cheap path for non-final
+    # processes in a parallel CI run, which only need their
+    # `.resultset.json` on disk. See #964.
+    def format!
+      formatter = SimpleCov.formatter
+      return nil if formatter.nil?
+
+      formatter.new.format(self)
+    end
+
+    # Defines when this result has been created. Defaults to Time.now
+    def created_at
+      @created_at ||= Time.now
+    end
+
+    # The command name that launched this result.
+    # Delegated to SimpleCov.command_name if not set manually
+    def command_name
+      @command_name ||= SimpleCov.command_name
+    end
+
+    # Returns a hash representation of this Result that can be used for marshalling it into JSON
+    def to_hash
+      {
+        command_name => {
+          "coverage" => coverage,
+          "timestamp" => created_at.to_i
+        }
+      }
+    end
+
+    # Loads a SimpleCov::Result#to_hash dump
+    def self.from_hash(hash)
+      hash.map do |command_name, data|
+        new(data.fetch("coverage"), command_name: command_name, created_at: Time.at(data["timestamp"]))
+      end
+    end
+
+  private
+
+    def warn_about_missing_source_files(missing, input_size)
+      return if missing.empty?
+
+      # Emit only from the process that writes the final report. The merged
+      # result is rebuilt in every parallel worker (each one stores its own
+      # slice), so without this gate the warning prints once per worker — this
+      # is the same signal SimpleCov uses to pick the process that runs the
+      # report and threshold checks. It's intentionally not gated on
+      # print_errors: the default at_fork sets print_errors false on workers,
+      # and in many parallel runners the final-report process is itself a
+      # worker, so a print_errors gate would suppress the one warning we want.
+      # See issues #980 and #1171.
+      return unless SimpleCov.final_result_process?
+
+      MissingSourceFilesReporter.new(
+        missing,
+        input_size: input_size,
+        every_entry_dropped: @files.empty? && missing.size == input_size
+      ).warn!
+    end
+
+    def coverage
+      original_result.slice(*filenames)
+    end
+
+    # Applies the given filter chain to `@files`, dropping each source
+    # file that any filter matches.
+    def apply_filters!(filters)
+      filters.each do |filter|
+        @files = SimpleCov::FileList.new(@files.reject { |source_file| filter.matches?(source_file) })
+      end
+    end
+
+    # When any `cover` matcher is configured, restrict `@files` to source
+    # files matching at least one of them. With no cover matchers configured
+    # this is a no-op, preserving the historical "everything required, then
+    # filtered" universe.
+    def apply_cover_filters!(cover_filters)
+      return if cover_filters.empty?
+
+      @files = SimpleCov::FileList.new(
+        @files.select { |source_file| cover_filters.any? { |filter| filter.matches?(source_file) } }
+      )
+    end
+  end
+end