ultra-pro-pkg 0.0.1

data/simplecov-1.0.0/lib/simplecov/configuration/ignored_entries.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Coverage-entry filters scoped to branch / method criteria. See
+  # `ignore_branches` and `ignore_methods`, and #1033 /
+  # #1046 for the synthetic-entry detection rationale.
+  module Configuration
+    # Branch types accepted by `ignore_branches`.
+    IGNORABLE_BRANCH_TYPES = %i[implicit_else eval_generated].freeze
+    # Method types accepted by `ignore_methods`.
+    IGNORABLE_METHOD_TYPES = %i[eval_generated].freeze
+
+    # Variadic; multiple calls union. Setting is recorded regardless
+    # of whether branch coverage is enabled at call time. See #1033, #1046.
+    def ignore_branches(*types)
+      types.each { |type| raise_if_branch_type_unsupported(type) }
+      ignored_branches.concat(types).uniq!
+      ignored_branches
+    end
+
+    def ignored_branches
+      @ignored_branches ||= []
+    end
+
+    def ignored_branch?(type)
+      ignored_branches.include?(type)
+    end
+
+    # See `ignore_branches`. The only supported method-type token today
+    # is `:eval_generated`; see #1046 for the rationale.
+    def ignore_methods(*types)
+      types.each { |type| raise_if_method_type_unsupported(type) }
+      ignored_methods.concat(types).uniq!
+      ignored_methods
+    end
+
+    def ignored_methods
+      @ignored_methods ||= []
+    end
+
+    def ignored_method?(type)
+      ignored_methods.include?(type)
+    end
+
+  private
+
+    def raise_if_branch_type_unsupported(type)
+      return if IGNORABLE_BRANCH_TYPES.member?(type)
+
+      raise SimpleCov::ConfigurationError,
+            "Unsupported branch type #{type.inspect} for `ignore_branches`. " \
+            "Supported values are #{IGNORABLE_BRANCH_TYPES.inspect}"
+    end
+
+    def raise_if_method_type_unsupported(type)
+      return if IGNORABLE_METHOD_TYPES.member?(type)
+
+      raise SimpleCov::ConfigurationError,
+            "Unsupported method type #{type.inspect} for `ignore_methods`. " \
+            "Supported values are #{IGNORABLE_METHOD_TYPES.inspect}"
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/configuration/merging.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Result merging and subprocess / parallel-test coordination:
+  # `merging`, `merge_subprocesses`, `merge_timeout`, `parallel_tests`.
+  module Configuration
+    #
+    # Get or set whether SimpleCov should hook `Process._fork` to
+    # attach itself to subprocesses. Required when the suite uses
+    # parallel test workers (e.g. Rails' `parallelize(workers:)`).
+    # Defaults to false.
+    #
+    def merge_subprocesses(value = nil)
+      return @enable_for_subprocesses if defined?(@enable_for_subprocesses) && value.nil?
+
+      @enable_for_subprocesses = value || false
+    end
+
+    # @api private — predicate used by `start_tracking` to decide
+    # whether to install the fork hook.
+    def enabled_for_subprocesses?
+      defined?(@enable_for_subprocesses) ? @enable_for_subprocesses : false
+    end
+
+    #
+    # Get or set whether SimpleCov should auto-require the
+    # `parallel_tests` gem when it sees `TEST_ENV_NUMBER` /
+    # `PARALLEL_TEST_GROUPS` in the environment. Defaults to auto-detect
+    # (nil). See #1018.
+    #
+    def parallel_tests(value = :__no_arg__)
+      return defined?(@parallel_tests) ? @parallel_tests : nil if value == :__no_arg__
+
+      @parallel_tests = value
+    end
+
+    # DEPRECATED: alias for `merge_subprocesses`. Same value/behavior.
+    def enable_for_subprocesses(value = nil)
+      SimpleCov::Deprecation.warn("`SimpleCov.enable_for_subprocesses` is deprecated. " \
+                                  "Replace with `SimpleCov.merge_subprocesses` (same value, same behavior).")
+      return @enable_for_subprocesses if defined?(@enable_for_subprocesses) && value.nil?
+
+      @enable_for_subprocesses = value || false
+    end
+
+    #
+    # Get or set whether to merge results from multiple test suites
+    # (test:units, test:functionals, cucumber, ...) into a single
+    # coverage report. Defaults to true.
+    #
+    def merging(use = nil)
+      @use_merging = use unless use.nil?
+      @use_merging = true unless defined?(@use_merging) && @use_merging == false
+      @use_merging
+    end
+
+    #
+    # Get or set whether this process owns final merge processing:
+    # waiting for sibling workers, building the merged result, formatting,
+    # enforcing thresholds, and writing `.last_run.json`.
+    #
+    # Defaults to true, except for recognized multi-worker parallel runs
+    # that explicitly write to a custom coverage destination while merging
+    # is enabled. Those runs are likely using an external `SimpleCov.collate`
+    # step to finalize the merge.
+    #
+    def finalize_merge(value = :__no_arg__)
+      unless value == :__no_arg__
+        @finalize_merge = value
+        @finalize_merge_explicit = true
+      end
+
+      return @finalize_merge if defined?(@finalize_merge_explicit) && @finalize_merge_explicit
+
+      inferred = inferred_finalize_merge?
+      warn_about_inferred_finalize_merge unless inferred
+      inferred
+    end
+
+    def finalize_merge?
+      finalize_merge
+    end
+
+    # @api private
+    def merge_finalization_owner?
+      collating_result? || finalize_merge?
+    end
+
+    # DEPRECATED: alias for `merging`. Same value, same behavior.
+    def use_merging(use = nil)
+      SimpleCov::Deprecation.warn("`SimpleCov.use_merging` is deprecated. " \
+                                  "Replace with `SimpleCov.merging` (same value, same behavior).")
+      @use_merging = use unless use.nil?
+      @use_merging = true unless defined?(@use_merging) && @use_merging == false
+    end
+
+    #
+    # Defines the maximum age (in seconds) of a resultset to still be
+    # included in merged results. Default is 600 seconds (10 minutes).
+    #
+    def merge_timeout(seconds = nil)
+      @merge_timeout = seconds if seconds.is_a?(Integer)
+      @merge_timeout ||= 600
+    end
+
+    #
+    # Defines how long (in seconds) the reporting process waits for the
+    # remaining parallel-test workers to write their resultsets before it
+    # proceeds with a partial merge. Default is 60 seconds. Raise it when a
+    # slow worker routinely finishes well after the others, so its coverage
+    # is still included and the minimum / maximum coverage checks aren't
+    # skipped against a partial total.
+    #
+    def parallel_wait_timeout(seconds = nil)
+      @parallel_wait_timeout = seconds if seconds.is_a?(Integer)
+      @parallel_wait_timeout ||= 60
+    end
+
+  private
+
+    def inferred_finalize_merge?
+      return true unless merging
+
+      adapter = SimpleCov::ParallelAdapters.current
+      return true unless adapter
+      return true unless adapter.expected_worker_count > 1
+      return true unless parallel_worker_environment?
+      return true unless explicit_custom_coverage_destination?
+
+      false
+    end
+
+    def parallel_worker_environment?
+      ENV.key?("TEST_ENV_NUMBER") || ENV.key?("PARALLEL_TEST_GROUPS")
+    end
+
+    def explicit_custom_coverage_destination?
+      return false unless explicit_coverage_destination?
+
+      coverage_path != File.expand_path("coverage", root)
+    end
+
+    def explicit_coverage_destination?
+      (defined?(@coverage_path_explicit) && @coverage_path_explicit) ||
+        (defined?(@coverage_dir_explicit) && @coverage_dir_explicit)
+    end
+
+    def warn_about_inferred_finalize_merge
+      return if defined?(@finalize_merge_inference_warned) && @finalize_merge_inference_warned
+      return unless print_errors
+
+      @finalize_merge_inference_warned = true
+      warn SimpleCov::Color.colorize(inferred_finalize_merge_warning, :yellow)
+    end
+
+    def inferred_finalize_merge_warning
+      "SimpleCov inferred `finalize_merge false` because this parallel worker is merging " \
+        "into a custom coverage destination. Set `SimpleCov.finalize_merge false` to keep " \
+        "external collation ownership, or `SimpleCov.finalize_merge true` if this worker " \
+        "should wait, merge, format, enforce thresholds, and write `.last_run.json`. " \
+        "See https://github.com/simplecov-ruby/simplecov#merge-finalization-ownership."
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/configuration/thresholds.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Coverage threshold configuration: `minimum_coverage`,
+  # `maximum_coverage`, `expected_coverage`, `maximum_coverage_drop`,
+  # `minimum_coverage_by_file`, `minimum_coverage_by_group`,
+  # `refuse_coverage_drop`, and friends.
+  module Configuration
+    #
+    # Defines the minimum overall coverage required for the testsuite to pass.
+    # Returns non-zero if the current coverage is below this threshold.
+    # Default is 0% (disabled).
+    #
+    def minimum_coverage(coverage = nil)
+      return @minimum_coverage ||= {} unless coverage
+
+      coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
+      raise_on_invalid_coverage(coverage, "minimum_coverage")
+      @minimum_coverage = coverage
+    end
+
+    def raise_on_invalid_coverage(coverage, coverage_setting)
+      coverage.each_key { |criterion| raise_if_criterion_disabled(criterion) }
+      coverage.each_value do |percent|
+        minimum_possible_coverage_exceeded(coverage_setting) if percent && percent > 100
+      end
+    end
+
+    #
+    # Defines the maximum overall coverage allowed for the testsuite to
+    # pass. Useful paired with `minimum_coverage` (or via
+    # `expected_coverage`) to pin coverage to an exact value, so an
+    # unexpected jump up fails the build. See #187.
+    #
+    def maximum_coverage(coverage = nil)
+      return @maximum_coverage ||= {} unless coverage
+
+      coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
+      raise_on_invalid_coverage(coverage, "maximum_coverage")
+      @maximum_coverage = coverage
+    end
+
+    #
+    # Pins the suite to an exact coverage figure by setting both
+    # `minimum_coverage` and `maximum_coverage`. See #187.
+    #
+    def expected_coverage(coverage = nil)
+      return minimum_coverage if coverage.nil?
+
+      minimum_coverage(coverage)
+      maximum_coverage(coverage)
+    end
+
+    #
+    # Defines the maximum coverage drop at once allowed for the
+    # testsuite to pass. Default is 100% (disabled).
+    #
+    def maximum_coverage_drop(coverage_drop = nil)
+      return @maximum_coverage_drop ||= {} unless coverage_drop
+
+      coverage_drop = {primary_coverage => coverage_drop} if coverage_drop.is_a?(Numeric)
+      raise_on_invalid_coverage(coverage_drop, "maximum_coverage_drop")
+      @maximum_coverage_drop = coverage_drop
+    end
+
+    #
+    # Defines the minimum coverage per file required for the testsuite
+    # to pass. Accepts a Numeric (global threshold on the primary
+    # criterion), a Symbol-keyed Hash (per-criterion globals), or a
+    # Hash mixing Symbol keys with String / Regexp keys to declare
+    # per-path overrides. See README and #575.
+    #
+    def minimum_coverage_by_file(coverage = nil)
+      return @minimum_coverage_by_file ||= {} unless coverage
+
+      coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
+      defaults, overrides = partition_per_file_thresholds(coverage)
+
+      SimpleCov::Deprecation.warn("`SimpleCov.minimum_coverage_by_file` is deprecated. " \
+                                  "Replace it with:\n#{per_file_coverage_replacement(defaults, overrides)}")
+
+      raise_on_invalid_coverage(defaults, "minimum_coverage_by_file")
+      overrides.each_value { |criteria| raise_on_invalid_coverage(criteria, "minimum_coverage_by_file") }
+
+      @minimum_coverage_by_file = defaults
+      @minimum_coverage_by_file_overrides = overrides
+    end
+
+    # Returns the per-path overrides set via `minimum_coverage_by_file`.
+    def minimum_coverage_by_file_overrides
+      @minimum_coverage_by_file_overrides ||= {}
+    end
+
+    #
+    # Defines the minimum coverage per group required for the testsuite
+    # to pass. Default is 0% (disabled).
+    #
+    def minimum_coverage_by_group(coverage = nil)
+      return @minimum_coverage_by_group ||= {} unless coverage
+
+      SimpleCov::Deprecation.warn("`SimpleCov.minimum_coverage_by_group` is deprecated. " \
+                                  "Replace it with:\n#{per_group_coverage_replacement(coverage)}")
+      @minimum_coverage_by_group = coverage.dup.transform_values do |group_coverage|
+        group_coverage = {primary_coverage => group_coverage} if group_coverage.is_a?(Numeric)
+        raise_on_invalid_coverage(group_coverage, "minimum_coverage_by_group")
+        group_coverage
+      end
+    end
+
+    #
+    # Refuses any coverage drop. Coverage is only allowed to increase.
+    #
+    def refuse_coverage_drop(*criteria)
+      criteria = coverage_criteria if criteria.empty?
+      maximum_coverage_drop(criteria.to_h { |c| [c, 0] })
+    end
+
+  private
+
+    # Split a `minimum_coverage_by_file` argument into Symbol-keyed
+    # criterion defaults and String/Regexp-keyed per-path overrides;
+    # normalize Numeric override values to `{primary_coverage => N}`
+    # so downstream code only has one shape to handle.
+    def partition_per_file_thresholds(coverage)
+      coverage.each_key { |key| validate_per_file_key(key) }
+      defaults, raw = coverage.partition { |key, _| key.is_a?(Symbol) }.map(&:to_h)
+      overrides = raw.transform_values { |value| value.is_a?(Numeric) ? {primary_coverage => value} : value }
+      [defaults, overrides]
+    end
+
+    def validate_per_file_key(key)
+      return if key.is_a?(Symbol) || key.is_a?(String) || key.is_a?(Regexp)
+
+      raise SimpleCov::ConfigurationError,
+            "minimum_coverage_by_file keys must be Symbol (criterion), String, or Regexp; got #{key.inspect}"
+    end
+
+    def minimum_possible_coverage_exceeded(coverage_option)
+      warn "The coverage you set for #{coverage_option} is greater than 100%"
+    end
+
+    # Render the `coverage` configuration equivalent to a (deprecated)
+    # `minimum_coverage_by_file` argument so the deprecation warning can be
+    # copy-pasted verbatim into the user's config.
+    def per_file_coverage_replacement(defaults, overrides)
+      by_criterion = Hash.new { |hash, criterion| hash[criterion] = [] }
+      defaults.each { |criterion, percent| by_criterion[criterion] << "minimum_per_file #{percent}" }
+      overrides.each do |target, criteria|
+        criteria.each do |criterion, percent|
+          by_criterion[criterion] << "minimum_per_file #{percent}, only: #{target.inspect}"
+        end
+      end
+      render_coverage_blocks(by_criterion)
+    end
+
+    # Same, for a (deprecated) `minimum_coverage_by_group` argument.
+    def per_group_coverage_replacement(coverage)
+      by_criterion = Hash.new { |hash, criterion| hash[criterion] = [] }
+      coverage.each do |group_name, group_coverage|
+        group_coverage = {primary_coverage => group_coverage} if group_coverage.is_a?(Numeric)
+        group_coverage.each do |criterion, percent|
+          by_criterion[criterion] << "minimum_per_group #{percent}, only: #{group_name.inspect}"
+        end
+      end
+      render_coverage_blocks(by_criterion)
+    end
+
+    def render_coverage_blocks(by_criterion)
+      by_criterion.map do |criterion, statements|
+        "  coverage(#{criterion.inspect}) { #{statements.join('; ')} }"
+      end.join("\n")
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module SimpleCov
+  #
+  # Bundles the configuration options used for SimpleCov. All methods
+  # defined here are usable from SimpleCov directly. Please check out
+  # SimpleCov documentation for further info.
+  #
+  module Configuration
+    #
+    # The root for the project. This defaults to the
+    # current working directory.
+    #
+    # Configure with SimpleCov.root('/my/project/path')
+    #
+    def root(root = nil)
+      return @root if defined?(@root) && root.nil?
+
+      @coverage_path = nil unless @coverage_path_explicit # invalidate cache
+      @root = File.expand_path(root || Dir.getwd)
+    end
+
+    #
+    # The name of the output and cache directory. Defaults to 'coverage'
+    #
+    # Configure with SimpleCov.coverage_dir('cov')
+    #
+    def coverage_dir(dir = nil)
+      return @coverage_dir if defined?(@coverage_dir) && dir.nil?
+
+      @coverage_path = nil unless @coverage_path_explicit # invalidate cache
+      @coverage_dir_explicit = true unless dir.nil?
+      @coverage_dir = dir || "coverage"
+    end
+
+    #
+    # Returns the full path to the output directory. By default
+    # constructed from `SimpleCov.root` + `SimpleCov.coverage_dir`, but
+    # callers can override with an arbitrary absolute path — handy for
+    # out-of-tree build directories. See #716.
+    #
+    # Reading is pure: the directory is only created when a path is
+    # explicitly assigned (the user has signaled they intend to write
+    # there). The codepaths that actually write into the directory
+    # (formatters, `LastRun`, `ResultsetStore`) ensure existence
+    # themselves, so read-only CLI subcommands that interpolate the
+    # path into status text don't materialize a stray `coverage/`
+    # directory.
+    #
+    def coverage_path(path = nil)
+      if path
+        @coverage_path = File.expand_path(path)
+        @coverage_path_explicit = true
+        FileUtils.mkdir_p @coverage_path
+      end
+
+      @coverage_path ||= File.expand_path(coverage_dir, root)
+    end
+
+    #
+    # The name of the command (a.k.a. Test Suite) currently running.
+    # Used for result merging and caching. Auto-detected; set explicitly
+    # with SimpleCov.command_name("test:units").
+    #
+    def command_name(name = nil)
+      @name = name unless name.nil?
+      @name ||= SimpleCov::CommandGuesser.guess
+      @name
+    end
+
+    # Returns the hash of available profiles
+    def profiles
+      @profiles ||= SimpleCov::Profiles.new
+    end
+
+    #
+    # Allows you to configure simplecov in a block instead of
+    # prepending SimpleCov to each config method.
+    #
+    def configure(&block)
+      block_context = block.binding.receiver
+
+      # If the block was defined in our own context, instance_exec is sufficient
+      return instance_exec(&block) if equal?(block_context)
+
+      # Copy the caller's instance variables in so that references like @filter
+      # inside the block resolve to the caller's values, not ours.
+      saved = swap_ivars_from(block_context)
+      instance_exec(&block)
+    ensure
+      restore_ivars(block_context, saved) if defined?(saved) && saved
+    end
+
+    #
+    # Gets or sets the behavior to process coverage results.
+    # By default, it stores/merges the current result and formats only
+    # from the final reporting process.
+    #
+    def at_exit(&block)
+      @at_exit = block if block
+      return @at_exit if @at_exit
+      return proc {} unless active_session?
+
+      @at_exit = proc do
+        result = SimpleCov.result
+        result.format! if result && SimpleCov.merge_finalization_owner? && SimpleCov.final_result_process?
+      end
+    end
+
+    # Whether SimpleCov has anything to do at exit: the Coverage module
+    # is actively tracking, or a `@result` has already been assembled
+    # (e.g. by `SimpleCov.collate`, which never starts Coverage).
+    def active_session?
+      SimpleCov.result? || (defined?(Coverage) && Coverage.running?)
+    end
+
+    #
+    # Gets or sets the behavior to start a new forked Process.
+    # Defaults to adding " (subprocess: #{serial})" to command_name and
+    # starting SimpleCov in quiet mode.
+    #
+    def at_fork(&block)
+      @at_fork = block if block
+      @at_fork ||= lambda { |_pid|
+        # Needs a name that's unique per worker within a run yet identical
+        # across runs. Build it from SimpleCov's stable fork serial rather
+        # than the OS pid: with the pid, every run produced uniquely-named
+        # results that never overwrote the previous run's, so they piled up
+        # in .resultset.json until merge_timeout and the merged report's
+        # file set drifted from run to run. See issue #1171.
+        SimpleCov.command_name "#{SimpleCov.command_name} (subprocess: #{SimpleCov.subprocess_serial})"
+        # be quiet, the parent process will use the regular formatter
+        SimpleCov.print_errors false
+        SimpleCov.formatter SimpleCov::Formatter::SimpleFormatter
+        SimpleCov.minimum_coverage 0
+        SimpleCov.start
+      }
+    end
+
+    #
+    # Returns the project name — defaults to the last dirname in
+    # SimpleCov.root, capitalized with underscores → spaces.
+    #
+    def project_name(new_name = nil)
+      return @project_name if defined?(@project_name) && @project_name && new_name.nil?
+
+      @project_name = new_name if new_name.is_a?(String)
+      @project_name ||= File.basename(root).capitalize.tr("_", " ")
+    end
+
+  private
+
+    # Copy instance variables from block_context into self, saving any
+    # of ours that would be clobbered. Returns the saved values for
+    # later restoration.
+    def swap_ivars_from(block_context)
+      saved = {}
+      our_ivars = instance_variables
+      block_context.instance_variables.each do |ivar|
+        saved[ivar] = instance_variable_get(ivar) if our_ivars.include?(ivar)
+        instance_variable_set(ivar, block_context.instance_variable_get(ivar))
+      end
+      saved
+    end
+
+    # Copy instance variables back to block_context and restore our saved values.
+    def restore_ivars(block_context, saved)
+      block_context.instance_variables.each do |ivar|
+        block_context.instance_variable_set(ivar, instance_variable_get(ivar))
+      end
+      saved.each { |ivar, value| instance_variable_set(ivar, value) }
+    end
+  end
+end
+
+require_relative "configuration/coverage"
+require_relative "configuration/coverage_criteria"
+require_relative "configuration/filters"
+require_relative "configuration/formatting"
+require_relative "configuration/ignored_entries"
+require_relative "configuration/merging"
+require_relative "configuration/thresholds"

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Holds the individual data of a coverage result.
+  #
+  # This is uniform across coverage criteria as they all have:
+  #
+  # * total - how many things to cover there are (total relevant loc/branches)
+  # * covered - how many of the coverables are hit
+  # * missed - how many of the coverables are missed
+  # * omitted - how many lines cannot be covered (blank lines/comments); only meaningful for line coverage
+  # * percent - percentage as covered/missed
+  # * strength - average hits per/coverable (will not exist for one shot lines format)
+  class CoverageStatistics
+    attr_reader :total, :covered, :missed, :omitted, :strength, :percent
+
+    def self.from(coverage_statistics)
+      sum_covered, sum_missed, sum_omitted, sum_total_strength =
+        coverage_statistics.reduce([0, 0, 0, 0.0]) do |(covered, missed, omitted, total_strength), stats|
+          [
+            covered + stats.covered,
+            missed + stats.missed,
+            omitted + stats.omitted,
+            # gotta remultiply with loc because files have different strength and loc
+            # giving them a different "weight" in total
+            total_strength + (stats.strength * stats.total)
+          ]
+        end
+
+      new(covered: sum_covered, missed: sum_missed, omitted: sum_omitted, total_strength: sum_total_strength)
+    end
+
+    # Requires only covered, missed and strength to be initialized.
+    #
+    # Other values are computed by this class.
+    def initialize(covered:, missed:, omitted: 0, total_strength: 0.0, percent: nil)
+      @covered  = covered
+      @missed   = missed
+      @omitted  = omitted
+      @total    = covered + missed
+      @percent  = percent || compute_percent(covered, missed, total)
+      @strength = compute_strength(total_strength, total)
+    end
+
+  private
+
+    def compute_percent(covered, missed, total)
+      return 100.0 if missed.zero?
+
+      covered * 100.0 / total
+    end
+
+    def compute_strength(total_strength, total)
+      return 0.0 if total.zero?
+
+      total_strength.to_f / total
+    end
+  end
+end