ultra-pro-pkg 0.0.1

data/simplecov-1.0.0/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    # Fails when the overall (project-wide) coverage for any criterion is
+    # below the configured minimum.
+    class MinimumOverallCoverageCheck
+      def initialize(result, minimum_coverage)
+        @result = result
+        @minimum_coverage = minimum_coverage
+      end
+
+      def failing?
+        violations.any?
+      end
+
+      def report
+        violations.each { |violation| report_violation(violation) }
+      end
+
+      def exit_code
+        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+      end
+
+    private
+
+      WORST_FILES_LIMIT = 5
+      private_constant :WORST_FILES_LIMIT
+
+      def violations
+        @violations ||= SimpleCov::CoverageViolations.minimum_overall(@result, @minimum_coverage)
+      end
+
+      def report_violation(violation)
+        criterion = violation.fetch(:criterion)
+        actual = violation.fetch(:actual)
+        warn format(
+          "%<criterion>s coverage (%<actual>s) is below the expected minimum coverage (%<expected>.2f%%).",
+          criterion: criterion.capitalize,
+          actual: SimpleCov::Color.colorize_percent(actual),
+          expected: violation.fetch(:expected)
+        )
+        report_worst_files(criterion)
+      end
+
+      def report_worst_files(criterion)
+        worst = worst_files_for(criterion)
+        return if worst.empty?
+
+        warn "  Lowest-coverage files (#{criterion}):"
+        worst.each do |path, percent|
+          warn format(
+            "    %<percent>s  %<path>s",
+            percent: SimpleCov::Color.colorize_percent(percent, format("%6.2f%%", percent)),
+            path: path
+          )
+        end
+      end
+
+      def worst_files_for(criterion)
+        stats_key = SimpleCov.coverage_statistics_key(criterion)
+        with_stats = @result.files.filter_map do |source_file|
+          stats = source_file.coverage_statistics[stats_key]
+          [source_file.project_filename, stats.percent] if stats
+        end
+        with_stats.sort_by { |_path, percent| percent }.first(WORST_FILES_LIMIT)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    SUCCESS = 0
+    EXCEPTION = 1
+    MINIMUM_COVERAGE = 2
+    MAXIMUM_COVERAGE_DROP = 3
+    MAXIMUM_COVERAGE = 4
+  end
+end
+
+require_relative "exit_codes/exit_code_handling"
+require_relative "exit_codes/maximum_coverage_drop_check"
+require_relative "exit_codes/maximum_overall_coverage_check"
+require_relative "exit_codes/minimum_coverage_by_file_check"
+require_relative "exit_codes/minimum_coverage_by_group_check"
+require_relative "exit_codes/minimum_overall_coverage_check"

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "English"
+
+# `at_exit` orchestration: post-suite report generation, threshold
+# checks, deferral when a sibling subprocess already wrote a fresher
+# report, and exit-status propagation.
+module SimpleCov
+  class << self
+    # @api private
+    CoverageLimits = Data.define(
+      :minimum_coverage,
+      :minimum_coverage_by_file,
+      :minimum_coverage_by_file_overrides,
+      :minimum_coverage_by_group,
+      :maximum_coverage,
+      :maximum_coverage_drop
+    )
+
+    def at_exit_behavior
+      # If we are in a different process than called start, don't interfere.
+      return if SimpleCov.pid != Process.pid
+
+      # If Coverage is no longer running (e.g. someone manually stopped it
+      # or a test consumed the result) then don't run exit tasks.
+      return unless Coverage.running?
+
+      # Stand down when we'd only clobber a fresher report. See
+      # `defer_to_existing_report?` and issue #581.
+      return if defer_to_existing_report?
+
+      SimpleCov.run_exit_tasks!
+    end
+
+    # Returns true when our process has no coverage data to contribute
+    # (after the resultset merge) and a newer report already exists on
+    # disk. Typically fires when `SimpleCov.start` ran in a parent
+    # process — e.g. a Rakefile or Rails' `Bundler.require` — that
+    # shelled out to the test runner. See issue #581.
+    def defer_to_existing_report?
+      return false unless existing_report_newer_than_us?
+
+      res = result
+      empty = res.nil? || res.files.empty?
+      warn_about_deferred_report if empty
+      empty
+    end
+
+    def existing_report_newer_than_us?
+      return false unless process_start_time
+
+      last_run_path = File.join(coverage_path, ".last_run.json")
+      File.exist?(last_run_path) && File.mtime(last_run_path) > process_start_time
+    end
+
+    def warn_about_deferred_report
+      return unless print_errors
+
+      warn SimpleCov::Color.colorize(
+        "Skipping SimpleCov report — this process tracked no application code and a newer " \
+        "report already exists at #{coverage_path}. This usually means SimpleCov.start ran in a " \
+        "parent process (e.g. a Rakefile or Rails' Bundler.require) that shelled out to the test " \
+        "runner. See https://github.com/simplecov-ruby/simplecov/issues/581.",
+        :yellow
+      )
+    end
+
+    # @api private — called from the at_exit block.
+    def run_exit_tasks!
+      error_exit_status = exit_status_from_exception
+
+      at_exit.call
+
+      exit_and_report_previous_error(error_exit_status) if previous_error?(error_exit_status)
+      process_results_and_report_error if ready_to_process_results?
+    end
+
+    # @api private — returns the exit status from the exit exception.
+    def exit_status_from_exception
+      @exit_exception = $ERROR_INFO
+      return nil unless @exit_exception
+
+      if @exit_exception.is_a?(SystemExit)
+        @exit_exception.status
+      else
+        SimpleCov::ExitCodes::EXCEPTION
+      end
+    end
+
+    # @api private — strict boolean so rspec-mocks 4's predicate matcher
+    # accepts it. test_unit sets status 0 on success, so SUCCESS must
+    # also be treated as "not a previous error".
+    def previous_error?(error_exit_status)
+      !!(error_exit_status && error_exit_status != SimpleCov::ExitCodes::SUCCESS)
+    end
+
+    # @api private
+    def exit_and_report_previous_error(exit_status)
+      if print_errors
+        warn SimpleCov::Color.colorize(
+          "Stopped processing SimpleCov as a previous error not related to SimpleCov has been detected",
+          :yellow
+        )
+      end
+      Kernel.exit(exit_status)
+    end
+
+    # @api private — the process that owns final merge processing is the
+    # only one that reports against thresholds, and only when its
+    # `wait_for_other_processes` confirmed every sibling reported.
+    # When the wait times out, the merged total is partial and
+    # comparing it against `minimum_coverage` / `maximum_coverage`
+    # would surface a spurious "below minimum" violation about the
+    # missing slice rather than a real shortfall.
+    def ready_to_process_results?
+      merge_finalization_owner? && final_result_process? && result? &&
+        (collating_result? || parallel_results_complete?)
+    end
+
+    def process_results_and_report_error
+      exit_status = process_result(result)
+
+      # Force exit with stored status (see github issue #5)
+      return unless exit_status.positive?
+
+      if print_errors
+        warn SimpleCov::Color.colorize(
+          "SimpleCov failed with exit #{exit_status} due to a coverage related error", :red
+        )
+      end
+      Kernel.exit exit_status
+    end
+
+    # @api private — `exit_status = SimpleCov.process_result(SimpleCov.result)`.
+    def process_result(result)
+      result_exit_status = result_exit_status(result)
+      write_last_run(result) if result_exit_status == SimpleCov::ExitCodes::SUCCESS
+      result_exit_status
+    end
+
+    def result_exit_status(result)
+      ExitCodes::ExitCodeHandling.call(result, coverage_limits: build_coverage_limits)
+    end
+
+  private
+
+    def build_coverage_limits
+      CoverageLimits.new(
+        minimum_coverage: minimum_coverage,
+        minimum_coverage_by_file: minimum_coverage_by_file,
+        minimum_coverage_by_file_overrides: minimum_coverage_by_file_overrides,
+        minimum_coverage_by_group: minimum_coverage_by_group,
+        maximum_coverage: maximum_coverage,
+        maximum_coverage_drop: maximum_coverage_drop
+      )
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # An array of SimpleCov SourceFile instances with additional collection helper
+  # methods for calculating coverage across them etc.
+  class FileList
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :@files,
+                   # For Enumerable
+                   :each,
+                   # also delegating methods implemented in Enumerable as they have
+                   # custom Array implementations which are presumably better/more
+                   # resource efficient
+                   :size, :map, :count,
+                   # surprisingly not in Enumerable
+                   :empty?, :length,
+                   # still act like we're kinda an array
+                   :to_a, :to_ary
+
+    def initialize(files)
+      @files = files
+    end
+
+    # The per-criterion coverage statistics across all files. With no argument
+    # returns the `{line:, branch:, method:}` Hash; pass a criterion symbol
+    # (`:line` / `:branch` / `:method`) to get that one CoverageStatistics.
+    def coverage_statistics(criterion = nil)
+      @coverage_statistics ||= compute_coverage_statistics
+      criterion ? @coverage_statistics[criterion] : @coverage_statistics
+    end
+
+    def coverage_statistics_by_file
+      @coverage_statistics_by_file ||= compute_coverage_statistics_by_file
+    end
+
+    # Returns the count of lines that have coverage
+    def covered_lines
+      coverage_statistics[:line]&.covered
+    end
+
+    # Returns the count of lines that have been missed
+    def missed_lines
+      coverage_statistics[:line]&.missed
+    end
+
+    # Returns the count of lines that are not relevant for coverage
+    def never_lines
+      return 0.0 if empty?
+
+      sum { |f| f.never_lines.size }
+    end
+
+    # Returns the count of skipped lines
+    def skipped_lines
+      return 0.0 if empty?
+
+      sum { |f| f.skipped_lines.size }
+    end
+
+    # Computes the coverage based upon lines covered and lines missed for each file
+    # Returns an array with all coverage percentages
+    def covered_percentages
+      map(&:covered_percent)
+    end
+
+    # Finds the least covered file and returns that file's name
+    def least_covered_file
+      min_by(&:covered_percent).filename
+    end
+
+    # Returns the overall amount of relevant lines of code across all files in this list
+    def lines_of_code
+      coverage_statistics[:line]&.total
+    end
+
+    # The coverage across all files in percent, for the given criterion (line
+    # by default). Returns nil if the criterion was not measured.
+    # @return [Float, nil]
+    def covered_percent(criterion = :line)
+      coverage_statistics(criterion)&.percent
+    end
+
+    # The strength (average hits per relevant unit) for the given criterion
+    # (line by default).
+    # @return [Float, nil]
+    def covered_strength(criterion = :line)
+      coverage_statistics(criterion)&.strength
+    end
+
+    # Return total count of branches in all files
+    def total_branches
+      coverage_statistics[:branch]&.total
+    end
+
+    # Return total count of covered branches
+    def covered_branches
+      coverage_statistics[:branch]&.covered
+    end
+
+    # Return total count of covered branches
+    def missed_branches
+      coverage_statistics[:branch]&.missed
+    end
+
+    def branch_covered_percent
+      coverage_statistics[:branch]&.percent
+    end
+
+    # Return total count of methods in all files
+    def total_methods
+      coverage_statistics[:method]&.total
+    end
+
+    # Return total count of covered methods
+    def covered_methods
+      coverage_statistics[:method]&.covered
+    end
+
+    # Return total count of missed methods
+    def missed_methods
+      coverage_statistics[:method]&.missed
+    end
+
+    def method_covered_percent
+      coverage_statistics[:method]&.percent
+    end
+
+  private
+
+    # Seed the result hash with one entry per criterion the user
+    # enabled — so an empty FileList (e.g. a group with no files) still
+    # yields the right shape — then fold each file's stats into the
+    # matching bucket. `SourceFile#coverage_statistics` always reports
+    # all three criteria; FileList is the layer that filters to the
+    # enabled set so disabled criteria don't surface in totals, JSON,
+    # or the HTML report.
+    def compute_coverage_statistics_by_file
+      seed = enabled_criteria_for_reporting.to_h { |criterion| [criterion, []] }
+      @files.each_with_object(seed) do |file, together|
+        file.coverage_statistics.each do |criterion, stats|
+          together[criterion] << stats if together.key?(criterion)
+        end
+      end
+    end
+
+    def compute_coverage_statistics
+      coverage_statistics_by_file.transform_values { |stats| CoverageStatistics.from(stats) }
+    end
+
+    # `:line` (or its `:oneshot_line` synonym) is reported when either
+    # criterion is enabled; the JRuby-gated branch/method criteria are
+    # reported when they pass their own engine-support check.
+    def enabled_criteria_for_reporting
+      criteria = []
+      criteria << :line   if SimpleCov.coverage_criterion_enabled?(:line) ||
+                             SimpleCov.coverage_criterion_enabled?(:oneshot_line)
+      criteria << :branch if SimpleCov.branch_coverage?
+      criteria << :method if SimpleCov.method_coverage?
+      criteria
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  #
+  # Base filter class. Inherit from this to create custom filters,
+  # and overwrite the matches?(source_file) instance method
+  #
+  # # A sample class that rejects all source files.
+  # class StupidFilter < SimpleCov::Filter
+  #   def matches?(source_file)
+  #     false
+  #   end
+  # end
+  #
+  class Filter
+    attr_reader :filter_argument
+
+    def initialize(filter_argument)
+      @filter_argument = filter_argument
+    end
+
+    def matches?(_source_file)
+      raise NotImplementedError, "The base filter class is not intended for direct use"
+    end
+
+    def self.build_filter(filter_argument)
+      return filter_argument if filter_argument.is_a?(SimpleCov::Filter)
+
+      class_for_argument(filter_argument).new(filter_argument)
+    end
+
+    def self.class_for_argument(filter_argument)
+      filter_classes_by_argument_type.find { |type, _| filter_argument.is_a?(type) }&.last ||
+        raise(SimpleCov::ConfigurationError, "You have provided an unrecognized filter type")
+    end
+
+    def self.filter_classes_by_argument_type
+      @filter_classes_by_argument_type ||= {
+        String => SimpleCov::StringFilter,
+        Regexp => SimpleCov::RegexFilter,
+        Array => SimpleCov::ArrayFilter,
+        Proc => SimpleCov::BlockFilter
+      }.freeze
+    end
+    private_class_method :filter_classes_by_argument_type
+  end
+
+  # Filter that matches when the source file's project path contains the
+  # configured string at a path-segment boundary.
+  class StringFilter < SimpleCov::Filter
+    # Returns true when the given source file's filename matches the
+    # string configured when initializing this Filter with StringFilter.new('somestring').
+    # Matching is path-segment-aware: the argument must appear immediately after a "/"
+    # and be followed by "/" or end-of-string, so "lib" matches "/lib/foo.rb" but not
+    # "/app/models/library.rb".
+    def matches?(source_file)
+      source_file.project_filename.match?(segment_pattern)
+    end
+
+  private
+
+    def segment_pattern
+      @segment_pattern ||= compute_segment_pattern
+    end
+
+    def compute_segment_pattern
+      normalized = filter_argument.delete_prefix("/")
+      escaped    = Regexp.escape(normalized)
+      boundary   = '(?:\A|/)'
+
+      if normalized.include?(".")
+        # Filename pattern (e.g. "test.rb" matches "faked_test.rb"): allow
+        # substring match within the last path segment, anchored to a
+        # segment boundary.
+        %r{#{boundary}[^/]*#{escaped}}
+      elsif normalized.end_with?("/")
+        # Trailing slash signals directory-only matching.
+        /#{boundary}#{escaped}/
+      else
+        # Directory or path: require a segment-boundary match so "lib"
+        # matches "lib/" but not "library/".
+        %r{#{boundary}#{escaped}(?=[/.]|\z)}
+      end
+    end
+  end
+
+  # Filter that matches when the source file's project path matches the
+  # configured Regexp.
+  class RegexFilter < SimpleCov::Filter
+    # Returns true when the given source file's filename matches the
+    # regex configured when initializing this Filter with RegexFilter.new(/someregex/).
+    # Uses `Regexp#match?` so the predicate returns a real boolean — `=~`
+    # would return the match position (an Integer or nil), which trips
+    # rspec-mocks 4's stricter predicate-matcher type check.
+    def matches?(source_file)
+      filter_argument.match?(source_file.project_filename)
+    end
+  end
+
+  # Filter that matches when the configured block returns truthy for the
+  # source file.
+  class BlockFilter < SimpleCov::Filter
+    # Returns true if the block given when initializing this filter with BlockFilter.new {|src_file| ... }
+    # returns true for the given source file.
+    def matches?(source_file)
+      filter_argument.call(source_file)
+    end
+  end
+
+  # Filter that matches when the source file's project path matches the
+  # configured shell glob (e.g. "lib/**/*.rb"). Used by `cover` and
+  # `skip` when callers want glob semantics instead of the substring
+  # match of `StringFilter`.
+  class GlobFilter < SimpleCov::Filter
+    def matches?(source_file)
+      File.fnmatch?(filter_argument, source_file.project_filename, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+    end
+  end
+
+  # Filter that matches when any of its component filters (built from the
+  # array's elements) match the source file.
+  class ArrayFilter < SimpleCov::Filter
+    def initialize(filter_argument)
+      filter_objects = filter_argument.map do |arg|
+        Filter.build_filter(arg)
+      end
+
+      super(filter_objects)
+    end
+
+    # Returns true if any of the filters in the array match the given source file.
+    # Configure this Filter like StringFilter.new(['some/path', /^some_regex/, Proc.new {|src_file| ... }])
+    def matches?(source_files_list)
+      filter_argument.any? do |arg|
+        arg.matches?(source_files_list)
+      end
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/formatter/base.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module SimpleCov
+  module Formatter
+    # @api private
+    #
+    # Shared scaffolding for formatters that write a coverage report to
+    # an output directory and emit a "Coverage report generated for X
+    # to Y" summary on stderr (it's a status message, not data).
+    # Subclasses override `format` to do their actual writing, and may
+    # override `message_prefix` (e.g. JSON prepends "JSON ").
+    class Base
+      # `output_dir` defaults to `SimpleCov.coverage_path` so the at_exit
+      # pipeline keeps working unchanged. Pass it explicitly to write
+      # somewhere else (handy for tests that don't want to clobber the
+      # project's `coverage/` directory).
+      def initialize(silent: false, output_dir: nil)
+        @silent = silent
+        @output_dir = output_dir
+      end
+
+    private
+
+      # Subclasses override to prepend a marker (e.g. "JSON ") to the
+      # summary line. Default empty for the HTML formatter, which has
+      # historically been the unmarked default.
+      def message_prefix
+        ""
+      end
+
+      def output_path
+        @output_dir || SimpleCov.coverage_path
+      end
+
+      # The path shown in the "Coverage report generated for X to Y"
+      # status line. Renders relative to cwd when `output_path` lives
+      # inside cwd (e.g. `coverage` instead of `/Users/me/proj/coverage`)
+      # and appends the formatter's `entry_point_filename` so the line
+      # points at a concrete file the user (or a terminal that
+      # hyperlinks paths) can act on — e.g. `coverage/index.html`
+      # instead of the bare directory `coverage`. Paths outside cwd
+      # stay absolute; a `../../../tmp/cov` display would be more
+      # confusing than the absolute form. See issue #197.
+      def displayable_output_path
+        directory = relative_or_absolute_output_path
+        entry_point_filename ? File.join(directory, entry_point_filename) : directory
+      end
+
+      def relative_or_absolute_output_path
+        absolute = output_path
+        relative = Pathname.new(absolute).relative_path_from(Pathname.pwd).to_s
+        relative.start_with?("..") ? absolute : relative
+      rescue ArgumentError
+        # Pathname#relative_path_from raises across mixed absolute/
+        # relative inputs (and across Windows drives) — keep the
+        # absolute form on any unresolvable case.
+        output_path
+      end
+
+      # Subclasses override to name the report's entry-point file
+      # (e.g. `index.html` for HTML, `coverage.json` for JSON), which
+      # gets appended to the directory in the status line. Default nil
+      # leaves the bare directory in place for any third-party formatter
+      # that has no single canonical entry point.
+      def entry_point_filename
+        nil
+      end
+
+      # Emit one summary line per criterion that the run actually
+      # measured. The header line ("Coverage report generated for X
+      # to Y") is always first; per-criterion lines follow in the
+      # order of `result.coverage_statistics` (which is the same
+      # insertion order as `SourceFile#coverage_statistics`, which in
+      # turn reflects what the user enabled).
+      def output_message(result)
+        header = "#{message_prefix}Coverage report generated for #{result.command_name} to #{displayable_output_path}"
+        body   = result.coverage_statistics.filter_map { |criterion, stat| stats_line(criterion, stat) }
+        [header, *body].join("\n")
+      end
+
+      # Returns nil for branch/method criteria that have nothing to
+      # measure (e.g. a file with no branches under branch coverage).
+      # Showing "Branch coverage: 0 / 0 (100.00%)" is noise; the older
+      # output specifically suppressed it.
+      def stats_line(criterion, stat)
+        return if criterion != :line && !stat.total.positive?
+
+        percent = SimpleCov.round_coverage(stat.percent)
+        Kernel.format(
+          "%<label>s coverage: %<covered>d / %<total>d (%<percent>s)",
+          label: criterion.to_s.capitalize,
+          covered: stat.covered,
+          total: stat.total,
+          percent: SimpleCov::Color.colorize_percent(percent)
+        )
+      end
+    end
+  end
+end