ultra-pro-pkg 0.0.1

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  #
+  # Responsible for adapting the format of the coverage result whether it's default or with statistics
+  #
+  class ResultAdapter
+    attr_reader :result
+
+    def initialize(result)
+      @result = result
+    end
+
+    def self.call(*)
+      new(*).adapt
+    end
+
+    def adapt
+      return unless result
+
+      result.to_h do |file_name, cover_statistic|
+        [file_name, adapt_one(file_name, cover_statistic)]
+      end
+    end
+
+  private
+
+    # Pre-0.18 resultsets pointed each filename straight at a line-coverage
+    # array; everything since uses the `{lines:, branches:, methods:}`
+    # shape. Newer entries also need their methods table massaged before
+    # downstream code merges across processes.
+    def adapt_one(file_name, cover_statistic)
+      return {"lines" => cover_statistic} if cover_statistic.is_a?(Array)
+
+      adapt_oneshot_lines_if_needed(file_name, cover_statistic)
+      normalize_method_keys(cover_statistic)
+      cover_statistic
+    end
+
+    # Normalize memory addresses in method coverage keys so that results
+    # from different processes can be merged. Anonymous class names like
+    # "#<Class:0x00007ff19ab24790>" get inconsistent addresses across runs.
+    # Address widths vary by runtime (32-bit hosts: 8 hex chars; 64-bit
+    # CRuby: 16; some JVM/TruffleRuby formats may differ), so match any
+    # length of hex digits and collapse to a single placeholder.
+    ADDRESS_PATTERN = /0x\h+/
+    private_constant :ADDRESS_PATTERN
+
+    ADDRESS_PLACEHOLDER = "0x0"
+    private_constant :ADDRESS_PLACEHOLDER
+
+    # Strip the `#<Class:Foo>` wrapper Ruby's Coverage adds to singleton-class
+    # method keys. `module_function` and class methods get recorded both as
+    # singleton (`[#<Class:Foo>, :m, …]`) and instance/module (`[Foo, :m, …]`)
+    # entries pointing at the same source location; only one of the two is
+    # ever reachable at runtime, so we merge them. Only applies to named
+    # constants — anonymous-class addresses like `#<Class:0x0>` are left
+    # alone (handled by ADDRESS_PATTERN above).
+    SINGLETON_WRAPPER_PATTERN = /\A#<Class:([A-Z_][\w:]*)>\z/
+    private_constant :SINGLETON_WRAPPER_PATTERN
+
+    def normalize_method_keys(cover_statistic)
+      methods = cover_statistic[:methods]
+      return unless methods
+
+      cover_statistic[:methods] = methods.each_with_object({}) do |(key, count), normalized|
+        normalized_key = key.dup
+        normalized_key[0] = key[0].to_s
+                                  .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
+                                  .sub(SINGLETON_WRAPPER_PATTERN, '\1')
+        # Keys may collide after normalization (anonymous classes sharing a
+        # method name, or singleton + instance forms of a module_function method).
+        normalized[normalized_key] = normalized.fetch(normalized_key, 0) + count
+      end
+    end
+
+    def adapt_oneshot_lines_if_needed(file_name, cover_statistic)
+      return unless cover_statistic.key?(:oneshot_lines)
+
+      oneshot_lines = cover_statistic.delete(:oneshot_lines)
+      line_stub     = build_line_stub(file_name, oneshot_lines)
+      oneshot_lines.each { |covered_line| line_stub[covered_line - 1] = 1 }
+      cover_statistic[:lines] = line_stub
+    end
+
+    def build_line_stub(file_name, oneshot_lines)
+      Coverage.line_stub(file_name)
+    rescue Errno::ENOENT, SyntaxError
+      Array.new(oneshot_lines.max || 0, nil)
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/result_merger/legacy_format_adapter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ResultMerger
+    # We changed the format of the raw result data in simplecov, as people
+    # are likely to have "old" resultsets lying around (but not too old so
+    # that they're still considered we can adapt them). See
+    # https://github.com/simplecov-ruby/simplecov/pull/824#issuecomment-576049747
+    module LegacyFormatAdapter
+    module_function
+
+      def call(result)
+        pre_0_18?(result) ? upgrade(result) : result
+      end
+
+      # Pre-0.18 coverage data pointed from file directly to an array of
+      # line coverage rather than a `{"lines" => [...]}` hash.
+      def pre_0_18?(result)
+        _key, data = result.first
+        data.is_a?(Array)
+      end
+
+      def upgrade(result)
+        result.transform_values { |line_coverage_data| {"lines" => line_coverage_data} }
+      end
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/result_merger/resultset_file.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SimpleCov
+  module ResultMerger
+    # Read + parse a `.resultset.json` file with the same tolerance the
+    # historical `ResultMerger` had: missing file returns `{}`, an empty
+    # or unparseable file warns and returns `{}`, parse success returns
+    # the decoded Hash.
+    module ResultsetFile
+    module_function
+
+      def parse(path)
+        data = read(path)
+        decode(data)
+      end
+
+      def read(path)
+        return unless File.exist?(path)
+
+        data = File.read(path)
+        return if data.nil? || data.length < 2
+
+        data
+      end
+
+      def decode(content)
+        return {} unless content
+
+        JSON.parse(content) || {}
+      rescue StandardError
+        warn "[SimpleCov]: Warning! Parsing JSON content of resultset file failed"
+        {}
+      end
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/result_merger/resultset_store.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module SimpleCov
+  module ResultMerger
+    # Reads and writes the persistent `.resultset.json` cache, including
+    # file-lock synchronization between processes and atomic temp-file
+    # renames so concurrent readers don't observe a truncated file.
+    module ResultsetStore
+    module_function
+
+      def resultset_path
+        File.join(SimpleCov.coverage_path, ".resultset.json")
+      end
+
+      def writelock_path
+        File.join(SimpleCov.coverage_path, ".resultset.json.lock")
+      end
+
+      def write(resultset)
+        FileUtils.mkdir_p(SimpleCov.coverage_path)
+        temp_path = "#{resultset_path}.#{Process.pid}.tmp"
+        File.open(temp_path, "w") { |f| f.puts JSON.pretty_generate(resultset) }
+        File.rename(temp_path, resultset_path)
+      end
+
+      # Ensure only one process is reading or writing the resultset at
+      # any given time. Reentrant: the lock is acquired once per outer
+      # call no matter how deeply nested.
+      def synchronize(&)
+        return yield if @locked
+
+        @locked = true
+        with_flock(&)
+      ensure
+        @locked = false
+      end
+
+      def with_flock
+        FileUtils.mkdir_p(SimpleCov.coverage_path)
+        File.open(writelock_path, "w+") do |f|
+          f.flock(File::LOCK_EX)
+          yield
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative "result_merger/legacy_format_adapter"
+require_relative "result_merger/resultset_file"
+require_relative "result_merger/resultset_store"
+
+module SimpleCov
+  #
+  # Singleton that is responsible for caching, loading and merging
+  # SimpleCov::Results into a single result for coverage analysis based
+  # upon multiple test suites.
+  #
+  module ResultMerger
+    class << self
+      def resultset_path
+        ResultsetStore.resultset_path
+      end
+
+      def merge_and_store(*file_paths, ignore_timeout: false)
+        result = merge_results(*file_paths, ignore_timeout: ignore_timeout)
+        store_result(result) if result
+        result
+      end
+
+      def merge_results(*file_paths, ignore_timeout: false)
+        # It is intentional here that files are only read in and parsed one at a time.
+        #
+        # In big CI setups you might deal with 100s of CI jobs and each one producing Megabytes
+        # of data. Reading them all in easily produces Gigabytes of memory consumption which
+        # we want to avoid.
+        #
+        # For similar reasons a SimpleCov::Result is only created in the end as that'd create
+        # even more data especially when it also reads in all source files.
+        initial_memo = valid_results(file_paths.shift, ignore_timeout: ignore_timeout)
+
+        command_names, coverage = file_paths.reduce(initial_memo) do |memo, file_path|
+          merge_coverage(memo, valid_results(file_path, ignore_timeout: ignore_timeout))
+        end
+
+        create_result(command_names, coverage)
+      end
+
+      def valid_results(file_path, ignore_timeout: false)
+        merge_valid_results(ResultsetFile.parse(file_path), ignore_timeout: ignore_timeout)
+      end
+
+      def merge_valid_results(results, ignore_timeout: false)
+        results = drop_expired_results(results) unless ignore_timeout
+
+        command_plus_coverage = results.map do |command_name, data|
+          [[command_name], LegacyFormatAdapter.call(data.fetch("coverage"))]
+        end
+
+        # one file itself _might_ include multiple test runs
+        merge_coverage(*command_plus_coverage)
+      end
+
+      def drop_expired_results(results)
+        fresh, expired = results.partition { |_command_name, data| within_merge_timeout?(data) }
+        return results if expired.empty?
+
+        warn_about_expired_results(expired.map(&:first))
+        fresh.to_h
+      end
+
+      def within_merge_timeout?(data)
+        (Time.now - Time.at(data.fetch("timestamp"))) < SimpleCov.merge_timeout
+      end
+
+      def warn_about_expired_results(expired_command_names)
+        # Subprocesses merge the resultset too (each forked worker calls
+        # `SimpleCov.result` to store its slice), and the default `at_fork`
+        # sets `print_errors false` for them. Without this guard the warning
+        # is emitted once per worker — N copies of the same message for an
+        # N-worker run. Gate on `print_errors` like every other SimpleCov
+        # warning so only the reporting process speaks up.
+        return unless SimpleCov.print_errors
+
+        warn "[SimpleCov]: Excluded #{expired_command_names.size} result(s) older than " \
+             "merge_timeout (#{SimpleCov.merge_timeout}s) from the merged report: " \
+             "#{expired_command_names.sort.join(', ')}. " \
+             "Increase SimpleCov.merge_timeout to include them."
+      end
+
+      def create_result(command_names, coverage)
+        return nil unless coverage
+
+        command_name = command_names.reject(&:empty?).sort.join(", ")
+        # The merged result is the authoritative one users actually see, so
+        # it's the one that warns about source files dropped because they no
+        # longer exist on disk (issue #980). The per-process slices built in
+        # `process_coverage_result` stay quiet to avoid one warning per worker.
+        SimpleCov::Result.new(coverage, command_name: command_name, report: true)
+      end
+
+      def merge_coverage(*results)
+        return [[""], nil] if results.empty?
+        return results.first if results.size == 1
+
+        results.reduce do |(memo_command, memo_coverage), (command, coverage)|
+          # timestamp is dropped here, which is intentional (we merge it, it gets a new time stamp as of now)
+          merged_coverage = Combine.combine(Combine::ResultsCombiner, memo_coverage, coverage)
+          [memo_command + command, merged_coverage]
+        end
+      end
+
+      #
+      # Gets all SimpleCov::Results stored in resultset, merges them and produces a new
+      # SimpleCov::Result with merged coverage data and the command_name
+      # for the result consisting of a join on all source result's names
+      def merged_result
+        command_names, coverage = merge_valid_results(read_resultset)
+        create_result(command_names, coverage)
+      end
+
+      def read_resultset
+        content = synchronize_resultset { ResultsetFile.read(resultset_path) }
+        ResultsetFile.decode(content)
+      end
+
+      # Saves the given SimpleCov::Result in the resultset cache
+      def store_result(result) # rubocop:disable Naming/PredicateMethod
+        synchronize_resultset do
+          # Ensure we have the latest, in case it was already cached
+          new_resultset = read_resultset
+
+          # A single result only ever has one command_name, see `SimpleCov::Result#to_hash`
+          command_name, data = result.to_hash.first
+          new_resultset[command_name] = merged_entry(new_resultset[command_name], data)
+
+          ResultsetStore.write(new_resultset)
+        end
+        true
+      end
+
+      # If an entry with the same command_name was written AFTER our process
+      # started, a sibling test runner (typically a subprocess our parent
+      # process shelled out to) wrote it. Combine coverage data rather than
+      # overwriting, so an empty parent-process result doesn't clobber the
+      # subprocess's real data. See https://github.com/simplecov-ruby/simplecov/issues/581.
+      def merged_entry(existing, incoming)
+        return incoming unless concurrent_runner_entry?(existing)
+
+        incoming.merge(
+          "coverage" => Combine.combine(Combine::ResultsCombiner, existing["coverage"], incoming["coverage"])
+        )
+      end
+
+      def concurrent_runner_entry?(entry)
+        return false unless entry.is_a?(Hash)
+
+        timestamp = entry["timestamp"]
+        process_start = SimpleCov.process_start_time
+        timestamp && process_start && timestamp.to_i >= process_start.to_i
+      end
+
+      def synchronize_resultset(&)
+        ResultsetStore.synchronize(&)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+# Result-building façade: turns the raw `Coverage.result` hash into a
+# `SimpleCov::Result`, applies filters and groups, drives merging
+# across test suites via `SimpleCov::ResultMerger`, and exposes the
+# `collate` entry point for stitching disparate resultsets together.
+module SimpleCov
+  class << self
+    #
+    # Collate a series of SimpleCov result files into a single SimpleCov output.
+    #
+    # See README for usage. By default `collate` ignores the merge_timeout
+    # so all results in all files specified will be merged. Pass
+    # `ignore_timeout: false` to honor it.
+    #
+    def collate(result_filenames, profile = nil, ignore_timeout: true, &)
+      raise ArgumentError, "There are no reports to be merged" if result_filenames.empty?
+
+      initial_setup(profile, &)
+
+      # Use the ResultMerger to produce a single, merged result, ready to use.
+      @result = ResultMerger.merge_and_store(*result_filenames, ignore_timeout: ignore_timeout)
+
+      @collating_result = true
+      run_exit_tasks!
+    ensure
+      @collating_result = false
+    end
+
+    #
+    # Returns the result for the current coverage run, merging it across test suites
+    # from cache using SimpleCov::ResultMerger if use_merging is activated (default)
+    #
+    def result
+      return @result if result?
+
+      use_merging = merging
+
+      # Collect our coverage result. When merging is off there is no merge
+      # step, so this per-process result is the final one and reports any
+      # dropped source files; otherwise the merged result does the reporting.
+      process_coverage_result(report: !use_merging) if defined?(Coverage) && Coverage.running?
+
+      # If we're using merging of results, store the current result
+      # first (if there is one), then merge the results and return those
+      if use_merging
+        SimpleCov::ResultMerger.store_result(@result) if result?
+        return @result unless finalize_merge?
+
+        wait_for_other_processes
+        @result = SimpleCov::ResultMerger.merged_result
+      end
+
+      @result
+    end
+
+    # Returns nil if the result has not been computed, otherwise the result.
+    def result?
+      defined?(@result) && @result
+    end
+
+    # @api private — true while `SimpleCov.collate` is running its finalizer.
+    def collating_result?
+      defined?(@collating_result) && @collating_result
+    end
+
+    # Applies the configured filters to the given array of SimpleCov::SourceFile items
+    def filtered(files)
+      result = files.clone
+      filters.each do |filter|
+        result = result.reject { |source_file| filter.matches?(source_file) }
+      end
+      SimpleCov::FileList.new result
+    end
+
+    # Bin the given source files by group filter. `groups:` defaults to
+    # `SimpleCov.groups`; pass a Hash explicitly to bin against a
+    # different group config (e.g., the snapshot a Result captured at
+    # construction). Files matched by no group fall into the implicit
+    # "Ungrouped" bucket.
+    def grouped(files, groups: SimpleCov.groups)
+      return {} if groups.empty?
+
+      grouped = groups.transform_values do |filter|
+        SimpleCov::FileList.new(files.select { |source_file| filter.matches?(source_file) })
+      end
+
+      in_group  = grouped_file_set(grouped)
+      ungrouped = files.reject { |source_file| in_group.include?(source_file) }
+      grouped["Ungrouped"] = SimpleCov::FileList.new(ungrouped) if ungrouped.any?
+
+      grouped
+    end
+
+    # Applies the profile of given name on SimpleCov configuration
+    def load_profile(name)
+      profiles.load(name)
+    end
+
+    # Clear out the previously cached .result. Primarily useful in testing.
+    def clear_result
+      @result = nil
+    end
+
+    # @api private — persist the per-criterion coverage percentages
+    # rounded down (see #679) so the next run can compute drift.
+    def write_last_run(result)
+      SimpleCov::LastRun.write(
+        result: result.coverage_statistics.transform_values { |stats| round_coverage(stats.percent) }
+      )
+    end
+
+    # @api private — round down to two decimals to be extra strict.
+    def round_coverage(coverage)
+      coverage.floor(2)
+    end
+
+  private
+
+    def initial_setup(profile, &block)
+      load_profile(profile) if profile
+      configure(&block) if block
+    end
+
+    def grouped_file_set(grouped)
+      grouped.values.each_with_object(Set.new) { |file_list, set| set.merge(file_list) }
+    end
+
+    # Finds files that were to be tracked but were not loaded, and
+    # initializes their line-by-line coverage to zero (or nil for
+    # comments / whitespace).
+    def add_not_loaded_files(result)
+      globs = unloaded_file_discovery_globs
+      return [result, Set.new] if globs.empty?
+
+      inject_unloaded_files(result.dup, discover_unloaded_paths(globs))
+    end
+
+    # Globs to expand on disk when injecting unloaded files into the
+    # result. Combines the legacy `track_files` glob (additive only)
+    # with every string glob declared via `cover` (also restrictive,
+    # but the restriction lives in `Result#apply_cover_filters!`).
+    def unloaded_file_discovery_globs
+      [tracked_files, *cover_globs].compact
+    end
+
+    # Expand the given globs relative to SimpleCov.root, not Dir.pwd —
+    # test runners that chdir (or CI scripts that invoke the suite
+    # from a subdir) would otherwise silently miss the unloaded-file
+    # injection and produce a different file set per environment. See
+    # issue #1106.
+    def discover_unloaded_paths(globs)
+      globs.flat_map { |glob| Dir.glob(glob, base: root) }.uniq
+    end
+
+    def inject_unloaded_files(result, candidate_paths)
+      not_loaded_files = candidate_paths.each_with_object(Set.new) do |file, set|
+        absolute_path = File.expand_path(file, root)
+        next if result.key?(absolute_path)
+
+        result[absolute_path] = SimulateCoverage.call(absolute_path)
+        set << absolute_path
+      end
+
+      [result, not_loaded_files]
+    end
+
+    # Run all the steps that handle processing the raw coverage result.
+    # `report:` is true only when this slice is the final result (merging
+    # off); with merging on the merged result reports dropped source files,
+    # so the per-process slice stays quiet to avoid one warning per worker.
+    def process_coverage_result(report:)
+      @result = SimpleCov::UselessResultsRemover.call(Coverage.result)
+      @result = SimpleCov::ResultAdapter.call(@result)
+      result, not_loaded_files = add_not_loaded_files(@result)
+      @result = SimpleCov::Result.new(result, not_loaded_files: not_loaded_files, report: report)
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "static_coverage_extractor"
+
+module SimpleCov
+  #
+  # Responsible for producing file coverage metrics.
+  #
+  module SimulateCoverage
+  module_function
+
+    #
+    # Simulate a file coverage report for a file that was tracked but never
+    # required. Returns the same hash shape as `Coverage.result` (lines,
+    # branches, methods).
+    #
+    # The line classification comes from `Coverage.line_stub` — the same
+    # classification the runtime would have produced if the file had been
+    # required — overlaid with SimpleCov's `# :nocov:` toggles and
+    # `# simplecov:disable line` directive ranges, which `Coverage` doesn't
+    # know about. This keeps "relevant lines" identical whether a file was
+    # loaded or just tracked, fixing the multi-line statement discrepancy
+    # in https://github.com/simplecov-ruby/simplecov/issues/654.
+    #
+    # Branches and methods are enumerated by static analysis (via
+    # `StaticCoverageExtractor`, which uses Prism). Earlier behavior left
+    # both as empty hashes, which made unloaded files invisible to the
+    # branch/method denominators while their lines DID count — so a
+    # `track_files`/`cover` glob that picked up files without specs
+    # silently inflated branch% relative to line%. See
+    # https://github.com/simplecov-ruby/simplecov/issues/1059. When Prism
+    # isn't loadable (Ruby < 3.3 without the prism gem) or the file
+    # can't be parsed, fall back to the old empty hashes — old behavior,
+    # old tradeoff.
+    #
+    # @return [Hash]
+    #
+    def call(absolute_path)
+      source_lines = read_lines(absolute_path)
+      lines = coverage_stub(absolute_path, source_lines) ||
+              LinesClassifier.new.classify(source_lines)
+      synthesized = StaticCoverageExtractor.call(source_lines.join) ||
+                    {"branches" => {}, "methods" => {}}
+
+      {
+        "lines" => lines,
+        "branches" => synthesized["branches"],
+        "methods" => synthesized["methods"]
+      }
+    end
+
+    def read_lines(path)
+      File.readlines(path)
+    rescue Errno::ENOENT
+      []
+    end
+
+    # Combine `Coverage.line_stub` (which gets multi-line statements right)
+    # with `LinesClassifier` (which knows about `# :nocov:` toggles and
+    # `# simplecov:disable line` ranges). Returns nil — and the caller
+    # falls back to `LinesClassifier` alone — when `Coverage` can't read
+    # or parse the file, or when the runtime doesn't expose `line_stub`
+    # (JRuby and TruffleRuby).
+    def coverage_stub(path, source_lines)
+      return nil unless Coverage.respond_to?(:line_stub)
+
+      stub = Coverage.line_stub(path)
+      classifier_output = LinesClassifier.new.classify(source_lines)
+      stub.each_index { |idx| stub[idx] = nil if classifier_output[idx].nil? }
+      stub
+    rescue Errno::ENOENT, SyntaxError
+      nil
+    end
+  end
+end