ultra-pro-pkg 0.0.1

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative "color"
+require_relative "cli/dotfile"
+require_relative "cli/clean"
+require_relative "cli/coverage"
+require_relative "cli/diff"
+require_relative "cli/merge"
+require_relative "cli/open"
+require_relative "cli/report"
+require_relative "cli/run"
+require_relative "cli/serve"
+require_relative "cli/uncovered"
+
+module SimpleCov
+  # Lightweight command-line front-end. `run` dispatches a subcommand
+  # (`coverage`, `report`, `uncovered`, `merge`, `diff`, `open`, etc.) —
+  # see the `usage` text below for the full list, or run `simplecov help`.
+  #
+  # Read-only subcommands consume JSONFormatter output (`coverage.json`),
+  # which the bundled HTMLFormatter already drops alongside the HTML, so
+  # no runtime hooking is needed for those. Default paths follow the
+  # project's `.simplecov` `SimpleCov.coverage_dir` setting when one is
+  # present, so a project that writes its report somewhere other than
+  # `coverage/` doesn't have to pass `--input` / `--report` every
+  # invocation.
+  module CLI
+    COMMANDS = {
+      "coverage" => Coverage,
+      "run" => Run,
+      "open" => Open,
+      "report" => Report,
+      "uncovered" => Uncovered,
+      "merge" => Merge,
+      "diff" => Diff,
+      "serve" => Serve,
+      "clean" => Clean
+    }.freeze
+
+  module_function
+
+    # Resolved once per process. Walks up from cwd looking for a
+    # `.simplecov`; if present, the file is loaded with
+    # `SimpleCov.start` neutered so it can't trigger coverage tracking
+    # or an at_exit hook just because we asked it for a config value.
+    def coverage_dir
+      @coverage_dir ||= Dotfile.coverage_dir
+    end
+
+    def default_input
+      File.join(coverage_dir, "coverage.json")
+    end
+
+    # Resolve "should this subcommand colorize?" once per invocation.
+    # `--no-color` (opts[:no_color]) is the per-invocation kill-switch;
+    # otherwise we defer to `SimpleCov::Color.enabled?`, which honors
+    # `NO_COLOR` / `FORCE_COLOR` and falls back to `stream.tty?`.
+    def color_enabled?(opts, stream)
+      return false if opts[:no_color]
+
+      SimpleCov::Color.enabled?(stream)
+    end
+
+    def default_report
+      File.join(coverage_dir, "index.html")
+    end
+
+    def default_resultset
+      File.join(coverage_dir, ".resultset.json")
+    end
+
+    # Returns a process exit status (0 on success, non-zero on error).
+    def run(argv, stdout: $stdout, stderr: $stderr)
+      command, *rest = argv
+      handler = COMMANDS[command]
+      return handler.run(rest, stdout: stdout, stderr: stderr) if handler
+      return stdout.puts(usage) || 0 if [nil, "help", "--help", "-h"].include?(command)
+
+      stderr.puts("simplecov: unknown command #{command.inspect}", usage)
+      1
+    end
+
+    def usage
+      <<~USAGE
+        Usage: simplecov <command> [options]
+
+        Commands:
+          run <command...>          Execute <command> with simplecov pre-loaded
+                                    (so a coverage report is generated even
+                                    when the project has no test_helper hook)
+          coverage <path>           Print coverage stats for the given file
+          report                    Print the overall summary and group totals
+          uncovered                 List the lowest-coverage files
+          merge <files...>          Merge multiple .resultset.json files
+          diff <baseline>           Show per-file coverage delta vs baseline
+          open                      Open the HTML report in the default browser
+          serve                     Serve the coverage report over HTTP
+          clean                     Remove the coverage report directory
+          help                      Show this message
+
+        Default paths follow SimpleCov.coverage_dir from a project's
+        `.simplecov` when one is present (#{coverage_dir} for this run).
+
+        coverage / report / uncovered / diff options:
+          --input PATH              Read from PATH instead of #{default_input}
+          --no-color                Disable colorized percentages
+                                    (also honors NO_COLOR / FORCE_COLOR env)
+
+        coverage options:
+          --json                    Print the file's JSON entry verbatim
+
+        report options:
+          --json                    Emit totals and group sections as JSON
+
+        uncovered options:
+          --threshold N             Only show files below N% coverage
+          --top N                   Show at most N files (default: 10)
+          --criterion C             line, branch, or method (default: line)
+          --json                    Emit results as a JSON array (for CI)
+
+        merge options:
+          --output PATH             Write merged resultset to PATH
+                                    (default: #{default_resultset})
+          --honor-timeout           Drop entries older than merge_timeout
+          --dry-run                 Print what would be written without
+                                    actually writing
+          -q, --quiet               Suppress the success status line
+
+        diff options:
+          --fail-on-drop            Exit non-zero when any file's coverage
+                                    dropped vs the baseline
+          --json                    Emit results as a JSON array (for CI)
+          --threshold N             Only show files whose absolute delta
+                                    in any criterion is at least N%
+
+        open options:
+          --report PATH             Open PATH instead of #{default_report}
+
+        serve options:
+          --port N                  Bind to port N (default: random open port)
+          --host HOST               Bind to HOST (default: 127.0.0.1)
+
+        clean options:
+          --dry-run                 Print what would be removed without
+                                    deleting anything
+          -q, --quiet               Suppress status lines
+      USAGE
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # ANSI colorization for stderr diagnostics. Thresholds mirror the
+  # HTML formatter (>= 90 green, >= 75 yellow, otherwise red) so a
+  # team's mental model of "what's the cutoff" is the same whether
+  # they're reading the terminal output or the HTML report.
+  #
+  # Color precedence, highest first:
+  #
+  # - `SimpleCov.color = true` / `false` (programmatic override, wins
+  #   over everything; default is `:auto` which falls through)
+  # - `NO_COLOR` env var (any non-empty value) → off (see no-color.org)
+  # - `FORCE_COLOR` env var (any non-empty value) → on
+  # - `stream.tty?` fallback
+  #
+  # `NO_COLOR` wins over `FORCE_COLOR` if both env vars are set.
+  module Color
+    GREEN_THRESHOLD  = 90
+    YELLOW_THRESHOLD = 75
+
+    ANSI = {
+      red: "\e[31m",
+      yellow: "\e[33m",
+      green: "\e[32m",
+      reset: "\e[0m"
+    }.freeze
+
+  module_function
+
+    # `stream` is the IO that the colorized text is destined for. The
+    # formatter writes to stderr, so that's the default. CLI subcommands
+    # that print to stdout should pass `$stdout` so a redirected pipe
+    # doesn't get ANSI sequences. See the module-level comment for
+    # precedence.
+    def enabled?(stream = $stderr)
+      config = SimpleCov.color
+      return config if [true, false].include?(config)
+      return false if env_set?("NO_COLOR")
+      return true  if env_set?("FORCE_COLOR")
+
+      stream.tty?
+    end
+
+    def for_percent(percent)
+      return :green  if percent >= GREEN_THRESHOLD
+      return :yellow if percent >= YELLOW_THRESHOLD
+
+      :red
+    end
+
+    # Wrap `text` in the ANSI sequence for `color` (a key of ANSI).
+    # Returns the bare text if color is disabled. The `enabled:`
+    # keyword lets callers (e.g., CLI subcommands honoring `--no-color`)
+    # override the auto-detection without touching env vars.
+    def colorize(text, color, enabled: enabled?)
+      return text unless enabled
+
+      "#{ANSI.fetch(color)}#{text}#{ANSI.fetch(:reset)}"
+    end
+
+    # Render `percent` as a fixed "NN.NN%" string colored by which
+    # threshold band it falls into. Callers that want a different
+    # rendering of the number can pass the pre-rendered `text`.
+    def colorize_percent(percent, text = nil, enabled: enabled?)
+      colorize(text || format("%.2f%%", percent), for_percent(percent), enabled: enabled)
+    end
+
+    def env_set?(name)
+      value = ENV.fetch(name, nil)
+      value && !value.empty?
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/combine/branches_combiner.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../source_file/ruby_data_parser"
+
+module SimpleCov
+  module Combine
+    #
+    # Combine different branch coverage results on single file.
+    #
+    # Should be called through `SimpleCov.combine`.
+    module BranchesCombiner
+    module_function
+
+      #
+      # Return merged branches or the existed branch if other is missing.
+      #
+      # Branches inside files are always same if they exist, the difference only in coverage count.
+      # Branch coverage report for any conditional case is built from hash, it's key is a condition and
+      # it's body is a hash << keys from condition and value is coverage rate >>.
+      # ex: branches => { [:if, 3, 8, 6, 8, 36] =>
+      #                     {[:then, 4, 8, 6, 8, 12] => 1, [:else, 5, 8, 6, 8, 36] => 2}, ... }
+      # We create copy of result and update it values depending on the combined branches coverage values.
+      #
+      # @return [Hash]
+      #
+      def combine(coverage_a, coverage_b)
+        combined = [coverage_a, coverage_b].each_with_object({}) do |coverage, memo|
+          coverage.each do |condition, branches_inside|
+            condition_key = tuple_identity(condition)
+            condition_tuple, merged_branches = memo[condition_key] ||= [condition, {}]
+            merge_branches(merged_branches, branches_inside)
+            memo[condition_key] = [condition_tuple, merged_branches]
+          end
+        end
+
+        combined.values.to_h { |condition, branches| [condition, branches.values.to_h] }
+      end
+
+      def merge_branches(target, source)
+        source.each do |branch, count|
+          branch_key = tuple_identity(branch)
+          branch_tuple, existing_count = target[branch_key]
+          target[branch_key] = [branch_tuple || branch, existing_count ? existing_count + count : count]
+        end
+      end
+
+      def tuple_identity(tuple)
+        tuple = SourceFile::RubyDataParser.call(tuple)
+        type, _id, start_line, start_column, end_line, end_column = tuple
+        [type, start_line, start_column, end_line, end_column]
+      end
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/combine/files_combiner.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Combine
+    #
+    # Handle combining two coverage results for same file
+    #
+    # Should be called through `SimpleCov.combine`.
+    module FilesCombiner
+    module_function
+
+      #
+      # Combines the results for 2 coverages of a file.
+      #
+      # @return [Hash]
+      #
+      def combine(coverage_a, coverage_b)
+        combination = {"lines" => Combine.combine(LinesCombiner, coverage_a["lines"], coverage_b["lines"])}
+        if SimpleCov.branch_coverage?
+          combined_branches = Combine.combine(BranchesCombiner, coverage_a["branches"], coverage_b["branches"])
+          combination["branches"] = combined_branches || {}
+        end
+        if SimpleCov.method_coverage?
+          combination["methods"] = Combine.combine(MethodsCombiner, coverage_a["methods"], coverage_b["methods"])
+        end
+        combination
+      end
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/combine/lines_combiner.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Combine
+    #
+    # Combine two different lines coverage results on same file
+    #
+    # Should be called through `SimpleCov.combine`.
+    module LinesCombiner
+    module_function
+
+      # Build a fresh array sized to the longer input. The previous
+      # implementation mutated whichever input was longer in place,
+      # which could surprise callers holding a reference to that array
+      # (e.g. the parsed `coverage` key of a resultset hash being
+      # passed into a second merge).
+      def combine(coverage_a, coverage_b)
+        size = [coverage_a.size, coverage_b.size].max
+        Array.new(size) { |i| merge_line_coverage(coverage_a[i], coverage_b[i]) }
+      end
+
+      # Two runs of the same source file should agree on which lines
+      # are coverage-relevant (`nil` for comments / whitespace, `0`+
+      # for executable). When they don't, treat "relevant on either
+      # side" as relevant rather than masking a real `0` as `nil`,
+      # which would silently drop an uncovered line from the
+      # denominator and inflate the percentage.
+      #
+      # Logic:
+      #
+      # => nil + nil = nil
+      # => nil + int = int (preserves a relevant-but-uncovered 0)
+      # => int + int = int (sum)
+      #
+      # @param [Integer || nil] first_val
+      # @param [Integer || nil] second_val
+      # @return [Integer || nil]
+      def merge_line_coverage(first_val, second_val)
+        return nil if first_val.nil? && second_val.nil?
+
+        first_val.to_i + second_val.to_i
+      end
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/combine/methods_combiner.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Combine
+    #
+    # Combine different method coverage results on a single file.
+    #
+    # Should be called through `SimpleCov.combine`.
+    module MethodsCombiner
+    module_function
+
+      #
+      # Return merged methods or the existing methods if other is missing.
+      #
+      # Method coverage is a flat hash mapping method identifiers to hit counts.
+      # Combining sums the hit counts for matching methods and preserves methods
+      # that only appear in one result.
+      #
+      # @return [Hash]
+      #
+      def combine(coverage_a, coverage_b)
+        coverage_a.merge(coverage_b) { |_key, a_count, b_count| a_count + b_count }
+      end
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/combine/results_combiner.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Combine
+    # There might be reports from different kinds of tests,
+    # e.g. RSpec and Cucumber. We need to combine their results
+    # into unified one. This class does that.
+    # To unite the results on file basis, it leverages
+    # the combine of lines and branches inside each file within given results.
+    module ResultsCombiner
+    module_function
+
+      #
+      # Combine process explanation
+      # => ResultCombiner: define all present files between results and start combine on file level.
+      # ==> FileCombiner: collect result of next combine levels lines, branches, and methods.
+      # ===> LinesCombiner: combine lines results.
+      # ===> BranchesCombiner: combine branches results.
+      # ===> MethodsCombiner: combine methods results.
+      #
+      # @return [Hash]
+      #
+      def combine(*results)
+        results.reduce({}) do |combined_results, next_result|
+          combine_result_sets(combined_results, next_result)
+        end
+      end
+
+      #
+      # Manage combining results on files level
+      #
+      # @param [Hash] combined_results
+      # @param [Hash] result
+      #
+      # @return [Hash]
+      #
+      def combine_result_sets(combined_results, result)
+        results_files = combined_results.keys | result.keys
+
+        results_files.to_h do |file_name|
+          [file_name, combine_file_coverage(
+            combined_results[file_name],
+            result[file_name]
+          )]
+        end
+      end
+
+      #
+      # Combine two files coverage results
+      #
+      # @param [Hash] coverage_a
+      # @param [Hash] coverage_b
+      #
+      # @return [Hash]
+      #
+      def combine_file_coverage(coverage_a, coverage_b)
+        Combine.combine(Combine::FilesCombiner, coverage_a, coverage_b)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Functionally for combining coverage results
+  #
+  module Combine
+  module_function
+
+    #
+    # Combine two coverage based on the given combiner_module.
+    #
+    # Combiners should always be called through this interface,
+    # as it takes care of short-circuiting of one of the coverages is nil.
+    #
+    # @return [Hash]
+    def combine(combiner_module, coverage_a, coverage_b)
+      return existing_coverage(coverage_a, coverage_b) if empty_coverage?(coverage_a, coverage_b)
+
+      combiner_module.combine(coverage_a, coverage_b)
+    end
+
+    def empty_coverage?(coverage_a, coverage_b)
+      !(coverage_a && coverage_b)
+    end
+
+    def existing_coverage(coverage_a, coverage_b)
+      coverage_a || coverage_b
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  #
+  # Helper that tries to find out what test suite is running (for SimpleCov.command_name)
+  #
+  module CommandGuesser
+    class << self
+      # Storage for the original command line call that invoked the test suite.
+      # This has got to be stored as early as possible because i.e. rake and test/unit 2
+      # have a habit of tampering with ARGV, which makes i.e. the automatic distinction
+      # between rails unit/functional/integration tests impossible without this cached
+      # item.
+      attr_accessor :original_run_command
+
+      def guess
+        [from_command_line_options || from_defined_constants, parallel_data].compact.join(" ")
+      end
+
+    private
+
+      # When parallel_tests (or a compatible runner) is driving the suite,
+      # tag the command name with this worker's position in the pool.
+      def parallel_data
+        groups, number = ENV.values_at("PARALLEL_TEST_GROUPS", "TEST_ENV_NUMBER")
+        return unless groups && number
+
+        # parallel_tests sets the first worker's TEST_ENV_NUMBER to "" rather
+        # than "1"; restore the position so the rendered label reads cleanly.
+        number = "1" if number.empty?
+        "(#{number}/#{groups})"
+      end
+
+      COMMAND_LINE_FRAMEWORKS = {
+        %r{test/functional/} => "Functional Tests",
+        %r{test/\{.*functional.*\}/} => "Functional Tests",
+        %r{test/integration/} => "Integration Tests",
+        %r{test/} => "Unit Tests",
+        /spec/ => "RSpec",
+        /cucumber/ => "Cucumber Features",
+        /features/ => "Cucumber Features"
+      }.freeze
+      private_constant :COMMAND_LINE_FRAMEWORKS
+
+      def from_command_line_options
+        COMMAND_LINE_FRAMEWORKS.find { |pattern, _| pattern.match?(original_run_command.to_s) }&.last
+      end
+
+      # Inner array literals after the first are flagged uncovered by Ruby's
+      # Coverage module even though the constant evaluates as a whole — known
+      # quirk with multi-line array literals.
+      DEFINED_CONSTANT_FRAMEWORKS = [
+        ["RSpec",      -> { defined?(::RSpec) }],
+        ["Unit Tests", -> { defined?(Test::Unit) }],   # simplecov:disable
+        ["Minitest",   -> { defined?(::Minitest) }],   # simplecov:disable
+        ["MiniTest",   -> { defined?(MiniTest) }]      # simplecov:disable
+      ].freeze
+      private_constant :DEFINED_CONSTANT_FRAMEWORKS
+
+      # If the command regexps fail, let's try checking defined constants.
+      def from_defined_constants
+        # simplecov:disable branch — first iter returns when ::RSpec is defined; later branches unreachable
+        DEFINED_CONSTANT_FRAMEWORKS.each { |name, defined_check| return name if defined_check.call }
+        # simplecov:enable branch
+
+        # TODO: Provide link to docs/wiki article
+        # simplecov:disable — only fires when no framework is detected, which
+        # is impossible while our own specs are running under rspec
+        warn(
+          "SimpleCov failed to recognize the test framework and/or suite used. " \
+          "Please specify manually using SimpleCov.command_name 'Unit Tests'."
+        )
+        "Unknown Test Framework"
+        # simplecov:enable
+      end
+    end
+  end
+end