ultra-pro-pkg 0.0.1

data/simplecov-1.0.0/lib/simplecov/source_file/statistics.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class SourceFile
+    # Builds the `CoverageStatistics` triple (`:line`, `:branch`, `:method`)
+    # for a SourceFile, regardless of which criteria were actually enabled
+    # during the run — disabled or empty criteria collapse to 0/0/0 so
+    # downstream consumers don't have to special-case enable-state.
+    class Statistics
+      def initialize(source_file)
+        @source_file = source_file
+      end
+
+      def call
+        {
+          **line_statistics,
+          **branch_statistics,
+          **method_statistics
+        }
+      end
+
+    private
+
+      def line_statistics
+        sf = @source_file
+        {
+          line: CoverageStatistics.new(
+            total_strength: sf.lines.sum { |line| line.coverage.to_i },
+            covered: sf.covered_lines.size,
+            missed: sf.missed_lines.size,
+            omitted: sf.never_lines.size
+          )
+        }
+      end
+
+      def branch_statistics
+        sf = @source_file
+        # Files added via track_files but never loaded/required have no
+        # branch data. Report 0% instead of misleading 100% (see #902).
+        if sf.not_loaded? && sf.covered_branches.empty? && sf.missed_branches.empty?
+          return {branch: CoverageStatistics.new(covered: 0, missed: 0, percent: 0.0)}
+        end
+
+        {branch: CoverageStatistics.new(covered: sf.covered_branches.size, missed: sf.missed_branches.size)}
+      end
+
+      def method_statistics
+        sf = @source_file
+        if sf.not_loaded? && sf.covered_methods.empty? && sf.missed_methods.empty?
+          return {method: CoverageStatistics.new(covered: 0, missed: 0, percent: 0.0)}
+        end
+
+        {method: CoverageStatistics.new(covered: sf.covered_methods.size, missed: sf.missed_methods.size)}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative "directive"
+require_relative "static_coverage_extractor"
+require_relative "source_file/ruby_data_parser"
+require_relative "source_file/source_loader"
+require_relative "source_file/skip_chunks"
+require_relative "source_file/builder_context"
+require_relative "source_file/line_builder"
+require_relative "source_file/branch_builder"
+require_relative "source_file/method_builder"
+require_relative "source_file/statistics"
+
+module SimpleCov
+  #
+  # Representation of a source file including it's coverage data, source code,
+  # source lines and featuring helpers to interpret that data.
+  #
+  class SourceFile
+    include BuilderContext
+
+    # The full path to this source file (e.g. /User/colszowka/projects/simplecov/lib/simplecov/source_file.rb)
+    attr_reader :filename
+    # The array of coverage data received from the Coverage.result
+    attr_reader :coverage_data
+
+    def initialize(filename, coverage_data, loaded: true)
+      @filename = filename
+      @coverage_data = coverage_data
+      @loaded = loaded
+    end
+
+    # The path to this source file relative to the projects directory
+    def project_filename
+      @filename.delete_prefix(SimpleCov.root).sub(%r{\A[/\\]}, "")
+    end
+
+    # The source code for this file. Aliased as :source.
+    # Intentionally read lazily to suppress reading unused source code.
+    def src
+      @src ||= SourceLoader.call(filename)
+    end
+    alias source src
+
+    # Returns a hash keyed by every supported coverage criterion. Each
+    # value is a CoverageStatistics, even for criteria that weren't
+    # enabled during the run — those collapse to 0/0/0. Consumers
+    # (FileList, formatters) decide which keys to surface based on
+    # `SimpleCov.coverage_criterion_enabled?`.
+    # The per-criterion coverage statistics for this file. 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 ||= Statistics.new(self).call
+      criterion ? @coverage_statistics[criterion] : @coverage_statistics
+    end
+
+    # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,
+    # and thus including coverage data. Aliased as :source_lines
+    def lines
+      @lines ||= LineBuilder.new(self).call
+    end
+    alias source_lines lines
+
+    # Returns all covered lines as SimpleCov::SourceFile::Line
+    def covered_lines
+      @covered_lines ||= lines.select(&:covered?)
+    end
+
+    # Returns all lines that should have been, but were not covered
+    # as instances of SimpleCov::SourceFile::Line
+    def missed_lines
+      @missed_lines ||= lines.select(&:missed?)
+    end
+
+    # Returns all lines that are not relevant for coverage as
+    # SimpleCov::SourceFile::Line instances
+    def never_lines
+      @never_lines ||= lines.select(&:never?)
+    end
+
+    # Returns all lines that were skipped as SimpleCov::SourceFile::Line instances
+    def skipped_lines
+      @skipped_lines ||= lines.select(&:skipped?)
+    end
+
+    # Returns the number of relevant lines (covered + missed)
+    def lines_of_code
+      coverage_statistics[:line]&.total || 0
+    end
+
+    # Access SimpleCov::SourceFile::Line source lines by line number
+    def line(number)
+      lines[number - 1]
+    end
+
+    # The coverage for this file in percent, for the given criterion (line by
+    # default). Returns nil if the criterion was not measured.
+    def covered_percent(criterion = :line)
+      coverage_statistics(criterion)&.percent
+    end
+
+    def covered_strength(criterion = :line)
+      coverage_statistics(criterion)&.strength
+    end
+
+    def no_lines?
+      lines.empty? || (lines.length == never_lines.size)
+    end
+
+    def relevant_lines
+      lines.size - never_lines.size - skipped_lines.size
+    end
+
+    # Return all the branches inside current source file
+    def branches
+      @branches ||= BranchBuilder.new(self).call
+    end
+
+    def no_branches?
+      total_branches.empty?
+    end
+
+    # DEPRECATED: use `covered_percent(:branch)`.
+    def branches_coverage_percent
+      SimpleCov::Deprecation.warn("`SimpleCov::SourceFile#branches_coverage_percent` is deprecated. " \
+                                  "Use `covered_percent(:branch)`.")
+      covered_percent(:branch)
+    end
+
+    # Return the relevant branches to source file
+    def total_branches
+      @total_branches ||= covered_branches + missed_branches
+    end
+
+    # Return hash with key of line number and branch coverage count as value
+    def branches_report
+      @branches_report ||=
+        branches.reject(&:skipped?).group_by(&:report_line).transform_values { |bs| bs.map(&:report) }
+    end
+
+    # Select the covered branches. We use a tree schema here because
+    # some conditions like `case` may have an additional `else` that
+    # isn't declared in code but is given by default by the coverage
+    # report.
+    def covered_branches
+      @covered_branches ||= branches.select(&:covered?)
+    end
+
+    # Select the missed branches with coverage equal to zero
+    def missed_branches
+      @missed_branches ||= branches.select(&:missed?)
+    end
+
+    def branches_for_line(line_number)
+      branches_report.fetch(line_number, [])
+    end
+
+    # Check if any branches missing on given line number
+    def line_with_missed_branch?(line_number)
+      branches_for_line(line_number).any? { |_type, count| count.zero? }
+    end
+
+    # Return all methods detected in this source file
+    def methods
+      @methods ||= MethodBuilder.new(self).call
+    end
+
+    def covered_methods
+      @covered_methods ||= methods.select(&:covered?)
+    end
+
+    def missed_methods
+      @missed_methods ||= methods.select(&:missed?)
+    end
+
+    # DEPRECATED: use `covered_percent(:method)`.
+    def methods_coverage_percent
+      SimpleCov::Deprecation.warn("`SimpleCov::SourceFile#methods_coverage_percent` is deprecated. " \
+                                  "Use `covered_percent(:method)`.")
+      covered_percent(:method)
+    end
+
+    # Whether this file was added via track_files but never loaded/required.
+    def not_loaded?
+      !@loaded
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/static_coverage_extractor/method_collector.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # Visitor mixin that collects method tuples and tracks the lexical
+    # class / module nesting that names them, in the shape Ruby's
+    # `Coverage` reports methods. Mixed into `Visitor`, it shares that
+    # visitor's `@methods` / `@class_stack` state and keeps the
+    # method-collection concern separate from branch extraction.
+    module MethodCollector
+      # Track class/module nesting so method tuples carry the lexical
+      # class name. Module + Class are both treated as namespaces here
+      # since `Coverage` reports both as the constant.
+      def visit_class_node(node)
+        with_class(constant_name(node.constant_path)) { super }
+      end
+
+      def visit_module_node(node)
+        with_class(constant_name(node.constant_path)) { super }
+      end
+
+      # `def name(...)` and `def self.name(...)` both produce DefNode.
+      # The class context is the surrounding lexical class/module (or
+      # `Object` at the top level, matching `Coverage`'s convention).
+      def visit_def_node(node)
+        loc = node.location
+        class_name = @class_stack.last || "Object"
+        key = [class_name, node.name, loc.start_line, loc.start_column, loc.end_line, loc.end_column]
+        @methods[key] = 0
+        super
+      end
+
+    private
+
+      # Render a constant path (e.g., `Foo::Bar`) as its source-form
+      # string. Defensive nil / to_s fallbacks: ClassNode and ModuleNode
+      # always carry a constant_path in practice.
+      # simplecov:disable
+      def constant_name(node)
+        return "<anonymous>" if node.nil?
+        return node.slice if node.respond_to?(:slice)
+
+        node.to_s
+      end
+      # simplecov:enable
+
+      def with_class(name)
+        @class_stack.push(name)
+        yield
+      ensure
+        @class_stack.pop
+      end
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/static_coverage_extractor/visitor.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require_relative "method_collector"
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # `Prism::IfNode#subsequent` was renamed from `consequent` in Prism
+    # 1.3 (Dec 2024). Ruby 3.3's stdlib still ships an older Prism that
+    # only exposes `consequent`; 3.4+ and any project that's done
+    # `gem install prism` exposes `subsequent`. Resolve the method name
+    # ONCE here so the per-node hot path stays branch-free. The
+    # not-taken arm on whichever Prism version we're on can't be
+    # exercised by our own dogfood (we only run on one Prism at a time).
+    # simplecov:disable
+    IF_NODE_SUBSEQUENT_METHOD =
+      if ::Prism::IfNode.method_defined?(:subsequent)
+        :subsequent
+      else
+        :consequent
+      end
+    # simplecov:enable
+
+    # Prism visitor that accumulates branch and method tuples in the
+    # shape Ruby's `Coverage` reports. Tuple ids are sequential across
+    # the file — `Coverage` uses sequential ids too, so this matches the
+    # conventional shape. Only defined when Prism is loadable;
+    # `StaticCoverageExtractor.available?` is the runtime gate.
+    class Visitor < ::Prism::Visitor
+      # Method tuples and the class/module nesting that names them are
+      # collected by this mixin; this class focuses on branch extraction.
+      include MethodCollector
+
+      attr_reader :branches, :methods
+
+      def initialize
+        super
+        @branches = {}
+        @methods = {}
+        @next_id = 0
+        @class_stack = []
+      end
+
+      # `if` / `unless` / postfix-if / postfix-unless / ternary all parse
+      # as IfNode (or UnlessNode). Both carry a `then` arm (the
+      # statements body) and an optional `subsequent` (an ElseNode for
+      # `else`, another IfNode for `elsif`). When the subsequent is
+      # missing, Coverage synthesizes a `:else` arm attributed to the
+      # whole condition's range — we do the same.
+      def visit_if_node(node)
+        emit_if_like(node, :if)
+        super
+      end
+
+      def visit_unless_node(node)
+        emit_if_like(node, :unless)
+        super
+      end
+
+      def visit_call_node(node)
+        emit_safe_navigation(node) if node.respond_to?(:safe_navigation?) && node.safe_navigation?
+        super
+      end
+
+      # `case`/`when` and `case`/`in` (pattern matching) parse as CaseNode
+      # and CaseMatchNode respectively. When there's no explicit `else`,
+      # Coverage synthesizes one at the case's range.
+      def visit_case_node(node)
+        emit_case_like(node, :when)
+        super
+      end
+
+      def visit_case_match_node(node)
+        emit_case_like(node, :in)
+        super
+      end
+
+      # `while` / `until` loops get a single `:body` arm. No synthetic
+      # else (the loop either runs the body or doesn't).
+      def visit_while_node(node)
+        emit_loop(node, :while)
+        super
+      end
+
+      def visit_until_node(node)
+        emit_loop(node, :until)
+        super
+      end
+
+    private
+
+      # IfNode and UnlessNode share a shape (predicate + then body +
+      # optional else/elsif) but expose the trailing arm under different
+      # accessors. `if_like_else_location` hides that split.
+      def emit_if_like(node, type)
+        then_loc = arm_location(node.statements, node.location)
+        else_loc = if_like_else_location(node)
+        @branches[build_tuple(type, node.location)] = {
+          build_tuple(:then, then_loc) => 0,
+          build_tuple(:else, else_loc) => 0
+        }
+      end
+
+      def emit_safe_navigation(node)
+        loc = node.location
+        @branches[build_tuple(:"&.", loc)] = {
+          build_tuple(:then, loc) => 0,
+          build_tuple(:else, loc) => 0
+        }
+      end
+
+      # Resolve the source range Coverage attributes to a real-or-synthetic
+      # `:else` arm of an if-like construct. IfNode uses
+      # `subsequent` / `consequent` depending on Prism version (resolved
+      # to `IF_NODE_SUBSEQUENT_METHOD` at load time); UnlessNode uses
+      # `else_clause`. When neither is present, the synthesized else
+      # inherits the whole condition's range (matches Coverage's
+      # convention).
+      def if_like_else_location(node)
+        sub = node.is_a?(::Prism::IfNode) ? node.public_send(IF_NODE_SUBSEQUENT_METHOD) : node.else_clause
+        return node.location unless sub
+
+        arm_location(else_body_of(sub), sub.location)
+      end
+
+      def emit_case_like(node, when_type)
+        arms = node.conditions.to_h do |when_node|
+          loc = arm_location(when_node.statements, when_node.location)
+          [build_tuple(when_type, loc), 0]
+        end
+        arms[build_tuple(:else, else_arm_location(node))] = 0
+        @branches[build_tuple(:case, node.location)] = arms
+      end
+
+      # Resolve the source range Coverage attributes to a synthetic-or-real
+      # `:else` arm of a case construct: the body of an explicit else,
+      # or the case's full range when no else is present.
+      def else_arm_location(node)
+        return node.location unless node.else_clause
+
+        arm_location(else_body_of(node.else_clause), node.else_clause.location)
+      end
+
+      def emit_loop(node, type)
+        cond_tuple = build_tuple(type, node.location)
+        body_loc = arm_location(node.statements, node.location)
+        @branches[cond_tuple] = {build_tuple(:body, body_loc) => 0}
+      end
+
+      # Body location for an arm. Prism's `statements` is a StatementsNode
+      # whose span covers the contained expressions; fall back to the
+      # parent when the arm body is empty (e.g., `if cond then end`).
+      def arm_location(statements, fallback_location)
+        statements&.location || fallback_location
+      end
+
+      # simplecov:disable branch
+      # The `else_node` fallback is defensive: every Prism node passed
+      # in here in practice responds to `:statements`.
+      def else_body_of(else_node)
+        else_node.respond_to?(:statements) ? else_node.statements : else_node
+      end
+      # simplecov:enable branch
+
+      def build_tuple(type, location)
+        id = @next_id
+        @next_id += 1
+        [type, id, location.start_line, location.start_column, location.end_line, location.end_column]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+begin
+  require "prism"
+rescue LoadError
+  # Prism isn't available on this Ruby (older than 3.3 without the gem).
+  # `StaticCoverageExtractor.available?` will return false and callers
+  # fall back to the previous "empty hashes" behavior.
+end
+
+module SimpleCov
+  # Static enumeration of the branches and methods Ruby's `Coverage` library
+  # WOULD have reported if a file had been loaded with `branches: true` /
+  # `methods: true`. Used by `SimulateCoverage` to backfill data for files
+  # added via `cover` / `track_files` that were never `require`'d during the
+  # run — so unloaded files contribute to the branch/method denominators
+  # symmetrically with their line coverage, instead of vanishing from the
+  # totals (see #1059).
+  #
+  # Implementation uses Prism (stdlib in Ruby 3.3+, gem on older Rubies).
+  # When Prism isn't available, `available?` returns false and SimulateCoverage
+  # falls back to the previous behavior — older Rubies keep working, just
+  # without the synthesized data.
+  #
+  # The emitted shape mirrors `Coverage.result[path]` for the same file:
+  # branches are nested as `{condition_tuple => {arm_tuple => 0, ...}}` and
+  # methods as `{["ClassName", :name, lines/cols] => 0}`. Position info
+  # comes from Prism's reported source locations; it doesn't always match
+  # `Coverage`'s byte-for-byte (the two parsers report slightly different
+  # column conventions for some constructs), but lines are reliable and
+  # downstream consumers that key off line numbers (the HTML formatter,
+  # SonarQube, etc.) see the data they expect.
+  module StaticCoverageExtractor
+  module_function
+
+    # simplecov:disable branch
+    # The Prism-unavailable arm of this ternary is unreachable when Prism
+    # itself IS loadable — i.e., on every engine that exercises the dogfood
+    # report. Asserted-on by callers; tested indirectly via the
+    # `available?`-returns-false fallback path in SimulateCoverage's spec.
+    def available?
+      defined?(::Prism) ? true : false
+    end
+    # simplecov:enable branch
+
+    # Parse `source` (a string of Ruby) and return a hash of the form
+    # `{"branches" => {...}, "methods" => {...}}` matching the shape that
+    # `Coverage.result[path]` produces. Returns nil on parse failure or
+    # when Prism isn't available; callers should treat that as "couldn't
+    # extract — fall back to empty hashes."
+    def call(source)
+      # simplecov:disable branch — `then` arm unreachable when Prism IS loadable
+      return nil unless available?
+
+      # simplecov:enable branch
+
+      result = ::Prism.parse(source)
+      return nil if result.failure?
+
+      visitor = Visitor.new
+      visitor.visit(result.value)
+      {"branches" => visitor.branches, "methods" => visitor.methods}
+    rescue StandardError
+      # simplecov:disable line
+      # Parser errors beyond the .failure? check, unsupported AST shapes,
+      # or anything else: fall back to empty hashes rather than crashing
+      # the whole report. Defensive; hard to trigger from a real source
+      # input that Prism accepts at parse time.
+      nil
+      # simplecov:enable line
+    end
+
+    # Summarize a source file's REAL branch and method positions, for the
+    # `:eval_generated` filter (SimpleCov.ignore_branches /
+    # SimpleCov.ignore_methods, #1046). Returns a hash:
+    #
+    #   {
+    #     branches: Set[start_line, ...],         # e.g., [3, 12, 20]
+    #     methods:  Set[[name, start_line], ...]  # e.g., [[:foo, 7], [:bar, 13]]
+    #   }
+    #
+    # Branch matching is start_line-only rather than by the full tuple.
+    # Static extraction and Coverage can still disagree on a branch's exact
+    # column positions (and, for some constructs, its type), so matching on
+    # start_line alone is the conservative choice that tolerates those
+    # differences. Coincidental line-sharing between a real branch and an
+    # eval-generated one will keep both, which is an acceptable
+    # false-negative for an opt-in filter. Method matching uses
+    # (name, start_line) since a method name is unique at any line.
+    #
+    # Returns nil when Prism is unavailable or parsing fails, signaling
+    # callers to keep every Coverage entry (no false drops).
+    def real_source_positions(source)
+      extracted = call(source)
+      return nil unless extracted
+
+      {
+        branches: extracted["branches"].keys.to_set { |tuple| tuple[2] },
+        methods: extracted["methods"].keys.to_set { |tuple| [tuple[1], tuple[2]] }
+      }
+    end
+  end
+end
+
+# simplecov:disable branch
+# The `else` arm (Prism missing) is unreachable on engines where the
+# dogfood report runs; the Visitor class only matters when Prism is
+# loadable.
+require_relative "static_coverage_extractor/visitor" if SimpleCov::StaticCoverageExtractor.available?
+# simplecov:enable branch

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Drop coverage entries whose paths live outside `SimpleCov.root` so the
+  # report only reflects the project's own source. Vendored gems, stdlib
+  # files, and anything else that happens to have been touched during the
+  # run never make it into the formatted result.
+  module UselessResultsRemover
+    def self.call(coverage_result)
+      coverage_result.select { |path, _coverage| path.match?(root_regex) }
+    end
+
+    # The `/i` flag covers case-insensitive matches on Windows / macOS-HFS+
+    # where the on-disk path's case can differ from `SimpleCov.root`'s.
+    def self.root_regex
+      root = SimpleCov.root
+      return @root_regex if root == @root_regex_root
+
+      @root_regex_root = root
+      @root_regex = /\A#{Regexp.escape(root.chomp(File::SEPARATOR) + File::SEPARATOR)}/i
+    end
+
+    def self.root_regx
+      root_regex
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  VERSION = "1.0.0"
+end

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

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Backward-compatibility shim: simplecov-html is now part of simplecov.
+require_relative "simplecov/formatter/html_formatter"