simplecov 0.22.0 → 1.0.2

data/doc/alternate-formatters.md

@@ -64,8 +64,3 @@ t_wada AA formatter for SimpleCov
 *by [Chiefpansancolt](https://github.com/chiefpansancolt)*
 
 A TailwindCSS & TailwindUI Designed HTML formatter with clean and easy search of files with a tabular left Navigation.
-
-#### [simplecov-material](https://github.com/chiefpansancolt/simplecov-material)
-*by [Chiefpansancolt](https://github.com/chiefpansancolt)*
-
-A Material Designed HTML formatter with clean and easy search of files with a tabular left Navigation.

data/doc/commercial-services.md

@@ -9,11 +9,6 @@ these integrations with their respective owners.
 
 Upload coverage reports to [codacy.com](https://www.codacy.com/), a hosted (or self-hosted) software quality analysis platform that also includes coverage reporting.
 
-#### [codeclimate](https://github.com/codeclimate/ruby-test-reporter)
-*by [Code Climate](https://codeclimate.com/)*
-
-Upload coverage reports to [codeclimate.com](https://codeclimate.com/), a hosted software quality analysis and that also includes coverage reporting.
-
 #### [codecov](https://github.com/codecov/codecov-ruby)
 *by [Codecov](https://codecov.io/)*
 
@@ -23,3 +18,8 @@ Upload coverage reports to [codecov.io](https://codecov.io/), a hosted coverage
 *by [Coveralls](https://coveralls.io/)*
 
 Upload coverage reports to [coveralls.io](https://coveralls.io/), a hosted coverage reporting solution.
+
+#### [Qlty Cloud](https://github.com/qltysh/qlty)
+*by [Qlty Software](https://qlty.sh/)*
+
+Upload coverage reports to [Qlty Cloud](https://qlty.sh/), a hosted software quality analysis and that also includes coverage reporting.

data/exe/simplecov

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Make `./exe/simplecov` work from a fresh checkout, not only via
+# `bundle exec`. RubyGems and Bundler already inject lib/ for an
+# installed gem; this is a no-op in that case.
+lib = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "simplecov/cli"
+exit SimpleCov::CLI.run(ARGV)

data/lib/minitest/simplecov_plugin.rb

@@ -2,14 +2,22 @@
 
 # How minitest plugins. See https://github.com/simplecov-ruby/simplecov/pull/756 for why we need this.
 # https://github.com/seattlerb/minitest#writing-extensions
+#
+# Handles the SimpleCov-first / Minitest-second ordering: SimpleCov.start
+# runs before `require "minitest/autorun"`, so the SimpleCov.start-time
+# detection in `install_at_exit_hook` can't see Minitest yet. By the time
+# this plugin fires (inside `Minitest.run`), Minitest is loaded and we
+# can flip the same switch. The opposite ordering (Minitest first) is
+# handled in `SimpleCov.install_at_exit_hook` — see `#minitest_autorun_pending?`.
 module Minitest
   def self.plugin_simplecov_init(_options)
-    if defined?(SimpleCov)
-      SimpleCov.external_at_exit = true
+    return unless defined?(SimpleCov)
+    return if SimpleCov.external_at_exit?
 
-      Minitest.after_run do
-        SimpleCov.at_exit_behavior
-      end
+    SimpleCov.external_at_exit = true
+
+    Minitest.after_run do
+      SimpleCov.at_exit_behavior
     end
   end
 end

data/lib/simplecov/autostart.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Loaded via `RUBYOPT="-rsimplecov/autostart"` from `simplecov run`. The
+# `require "simplecov"` here also auto-loads `~/.simplecov` and the
+# project's `.simplecov` (per simplecov/defaults.rb), which may already
+# call `SimpleCov.start`. `SimpleCov.start` is idempotent — it won't
+# restart Coverage if it's already running, and `install_at_exit_hook`
+# guards against double-installing — so calling it unconditionally is
+# the safe way to ensure the report is formatted at exit.
+require "simplecov"
+SimpleCov.start

data/lib/simplecov/cli/clean.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module SimpleCov
+  module CLI
+    # `simplecov clean [--dry-run]` — remove the coverage report
+    # directory (or whatever `SimpleCov.coverage_dir` resolves to). The
+    # `--dry-run` flag prints what would be deleted without touching
+    # disk, for when you're not sure what's in there.
+    module Clean
+    module_function
+
+      def run(args, stdout:, **)
+        opts = parse(args)
+        dir = SimpleCov::CLI.coverage_dir
+        return announce(stdout, opts, "#{dir} doesn't exist; nothing to do") || 0 unless File.directory?(dir)
+
+        sweep(dir, opts, stdout)
+        0
+      end
+
+      def sweep(dir, opts, stdout)
+        if opts[:dry_run]
+          announce(stdout, opts, "would remove #{dir} (#{Dir["#{dir}/**/*"].size} entries)")
+        else
+          require "fileutils"
+          FileUtils.rm_rf(dir)
+          announce(stdout, opts, "removed #{dir}")
+        end
+      end
+
+      def announce(stdout, opts, message)
+        stdout.puts("simplecov clean: #{message}") unless opts[:quiet]
+      end
+
+      def parse(args)
+        opts = {dry_run: false, quiet: false}
+        OptionParser.new do |o|
+          o.on("--dry-run") { opts[:dry_run] = true }
+          o.on("-q", "--quiet") { opts[:quiet] = true }
+        end.parse(args)
+        opts
+      end
+    end
+  end
+end

data/lib/simplecov/cli/coverage.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+
+module SimpleCov
+  module CLI
+    # `simplecov coverage <path>` — print per-criterion stats for one
+    # file from a JSONFormatter coverage.json.
+    module Coverage
+      CRITERIA = [
+        {label: "Line",   pct: "lines_covered_percent",    cov: "covered_lines",    tot: "total_lines"},
+        {label: "Branch", pct: "branches_covered_percent", cov: "covered_branches", tot: "total_branches"},
+        {label: "Method", pct: "methods_covered_percent",  cov: "covered_methods",  tot: "total_methods"}
+      ].freeze
+
+    module_function
+
+      def run(args, stdout:, stderr:)
+        opts = parse(args, stderr: stderr)
+        return 1 unless opts
+
+        match = locate_match(opts, stderr)
+        return 1 unless match
+
+        emit(match, opts, stdout)
+        0
+      end
+
+      def parse(args, stderr:)
+        opts = {input: SimpleCov::CLI.default_input, json: false, no_color: false} #: Hash[Symbol, untyped]
+        rest =
+          OptionParser.new do |o|
+            o.on("--input PATH") { |v| opts[:input] = v }
+            o.on("--json") { opts[:json] = true }
+            o.on("--no-color") { opts[:no_color] = true }
+          end.parse(args)
+        return stderr.puts("simplecov coverage: missing file argument") && nil if rest.empty?
+
+        opts[:path] = rest.first
+        opts
+      end
+
+      def locate_match(opts, stderr)
+        return stderr.puts("simplecov coverage: #{opts[:input]} not found") && nil unless File.exist?(opts[:input])
+
+        data = JSON.parse(File.read(opts[:input]))
+        none = {} #: Hash[String, untyped]
+        match = lookup(data.fetch("coverage", none), opts[:path])
+        return match if match
+
+        stderr.puts("simplecov coverage: no entry for #{opts[:path]} in #{opts[:input]}")
+        nil
+      end
+
+      # Match either the absolute path, the literal string passed, or
+      # any coverage entry whose absolute filename ends with "/<path>".
+      # That covers the three natural ways a user types a path: relative
+      # to project root ("app/foo.rb"), absolute, or basename-only.
+      def lookup(coverage_hash, path)
+        absolute = File.expand_path(path)
+        suffix   = "/#{path}"
+        coverage_hash.find { |fname, _| fname == absolute || fname == path || fname.end_with?(suffix) }
+      end
+
+      def emit(match, opts, stdout)
+        filename, payload = match
+        if opts[:json]
+          entry = {filename => payload} #: Hash[untyped, untyped]
+          stdout.puts(JSON.pretty_generate(entry))
+        else
+          print_human(filename, payload, stdout, SimpleCov::CLI.color_enabled?(opts, stdout))
+        end
+      end
+
+      def print_human(filename, payload, stdout, color)
+        stdout.puts(filename)
+        CRITERIA.each { |c| emit_criterion(stdout, payload, c, color) }
+      end
+
+      def emit_criterion(stdout, payload, criterion, color)
+        return unless payload.key?(criterion[:pct])
+
+        pct = payload[criterion[:pct]].to_f
+        stdout.puts(format("  %<label>-7s %<pct>s (%<covered>d / %<total>d)",
+                           label: "#{criterion[:label]}:",
+                           pct: SimpleCov::Color.colorize_percent(pct, enabled: color),
+                           covered: payload[criterion[:cov]] || 0,
+                           total: payload[criterion[:tot]] || 0))
+      end
+    end
+  end
+end

data/lib/simplecov/cli/diff.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+
+module SimpleCov
+  module CLI
+    # `simplecov diff <baseline>` — print the per-file line-coverage
+    # delta between coverage.json (--input) and a baseline coverage.json
+    # checked in alongside the suite. Only files whose coverage moved
+    # are listed; --fail-on-drop exits non-zero when any file regressed,
+    # so this composes with CI as a "coverage of this PR didn't drop"
+    # gate. Resolves the long-standing "diff coverage" feature request.
+    module Diff
+      EPSILON = 0.005 # tolerance below which a delta is considered noise
+
+      # Per-criterion key map. coverage.json carries `lines_covered_percent`
+      # plus `branches_covered_percent` / `methods_covered_percent` when
+      # the corresponding criterion is enabled, so the diff can describe
+      # whichever criteria the baseline + current both report on.
+      CRITERIA = %i[lines branches methods].freeze
+      CRITERION_FIELDS = {
+        lines: {pct: "lines_covered_percent", total: "total_lines"},
+        branches: {pct: "branches_covered_percent", total: "total_branches"},
+        methods: {pct: "methods_covered_percent", total: "total_methods"}
+      }.freeze
+
+      STATUS_SUFFIX = {"added" => "(new file)", "removed" => "(removed)"}.freeze
+
+    module_function
+
+      def run(args, stdout:, stderr:, **)
+        opts = parse(args, stderr)
+        return 1 unless opts
+
+        rows = compute_rows(opts[:current], opts[:baseline], opts[:threshold])
+        rows.sort_by! { |row| row[:line_delta] }
+        if opts[:json]
+          emit_json(stdout, rows)
+        else
+          emit_text(stdout, rows, SimpleCov::CLI.color_enabled?(opts, stdout))
+        end
+        opts[:fail_on_drop] && rows.any? { |row| row[:line_delta].negative? } ? 1 : 0
+      end
+
+      def parse(args, stderr)
+        opts = parse_flags(args)
+        return stderr.puts("simplecov diff: missing baseline argument") && nil if opts[:rest].empty?
+
+        opts[:baseline] = load_coverage(opts[:rest].first, stderr) or return nil
+        opts[:current]  = load_coverage(opts[:input], stderr) or return nil
+        opts
+      end
+
+      def parse_flags(args)
+        opts = {input: SimpleCov::CLI.default_input, fail_on_drop: false, json: false, threshold: 0.0, no_color: false}
+        opts.merge(rest: option_parser(opts).parse(args))
+      end
+
+      def option_parser(opts)
+        OptionParser.new do |o|
+          o.on("--input PATH")         { |v| opts[:input] = v }
+          o.on("--fail-on-drop")       { opts[:fail_on_drop] = true }
+          o.on("--json")               { opts[:json] = true }
+          o.on("--threshold N", Float) { |v| opts[:threshold] = v }
+          o.on("--no-color")           { opts[:no_color] = true }
+        end
+      end
+
+      def load_coverage(path, stderr)
+        no_coverage = {} #: Hash[String, untyped]
+        return normalize_keys(JSON.parse(File.read(path)).fetch("coverage", no_coverage)) if File.exist?(path)
+
+        stderr.puts("simplecov diff: #{path} not found")
+        nil
+      end
+
+      # Strip a leading slash so coverage.json files written before the
+      # `project_filename` change (keys like "/lib/foo.rb") still diff
+      # cleanly against newer reports (keys like "lib/foo.rb").
+      def normalize_keys(coverage)
+        coverage.transform_keys { |key| key.delete_prefix("/") }
+      end
+
+      def compute_rows(current, baseline, threshold)
+        files = current.keys | baseline.keys
+        files.filter_map { |fname| compute_row(fname, current[fname], baseline[fname], threshold) }
+      end
+
+      def compute_row(fname, current_payload, baseline_payload, threshold)
+        deltas = CRITERIA.to_h { |c| [c, pct_for(c, current_payload) - pct_for(c, baseline_payload)] }
+        floor = [threshold.abs, EPSILON].max
+        return nil unless deltas.values.any? { |delta| delta.abs > floor }
+
+        {
+          file: fname,
+          status: status_for(current_payload, baseline_payload),
+          line_delta: deltas[:lines],
+          branch_delta: deltas[:branches],
+          method_delta: deltas[:methods]
+        }
+      end
+
+      def status_for(current_payload, baseline_payload)
+        return "added"   if baseline_payload.nil?
+        return "removed" if current_payload.nil?
+
+        "changed"
+      end
+
+      def pct_for(criterion, payload)
+        fields = CRITERION_FIELDS.fetch(criterion)
+        return 0.0 unless payload.is_a?(Hash) && payload[fields[:total]].to_i.positive?
+
+        payload[fields[:pct]].to_f
+      end
+
+      def emit_text(stdout, rows, color)
+        return stdout.puts("simplecov diff: no per-file coverage changes") if rows.empty?
+
+        rows.each { |row| stdout.puts(format_row(row, color)) }
+      end
+
+      def format_row(row, color)
+        line = "  #{delta_parts(row, color).join('  ')}  #{row[:file]}"
+        suffix = STATUS_SUFFIX[row[:status]]
+        suffix ? "#{line}  #{suffix}" : line
+      end
+
+      def delta_parts(row, color)
+        [
+          format_delta(row[:line_delta], "lines", color),
+          (format_delta(row[:branch_delta], "branches", color) if row[:branch_delta].abs > EPSILON),
+          (format_delta(row[:method_delta], "methods", color)  if row[:method_delta].abs > EPSILON)
+        ].compact
+      end
+
+      # Deltas are sign-based, not threshold-based: a +5% bump is good
+      # (green) and a -5% drop is bad (red), regardless of where the
+      # absolute coverage level lands.
+      def format_delta(delta, label, color)
+        sign = delta.positive? ? "+" : ""
+        text = format("%<sign>s%<delta>6.2f%% %<label>s", sign: sign, delta: delta, label: label)
+        SimpleCov::Color.colorize(text, delta.negative? ? :red : :green, enabled: color)
+      end
+
+      def emit_json(stdout, rows)
+        stdout.puts(JSON.pretty_generate(rows))
+      end
+    end
+  end
+end

data/lib/simplecov/cli/dotfile.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module SimpleCov
+  module CLI
+    # Loads a project's `.simplecov` config file purely to read
+    # `coverage_dir` from it, with `SimpleCov.start` and the at_exit
+    # hook installer neutered so the load doesn't trigger coverage
+    # tracking. Used by the CLI to default `--input` / `--report`
+    # paths to whatever the project's dotfile declares, without making
+    # every read-only subcommand pay for actually starting Coverage.
+    module Dotfile
+    module_function
+
+      def coverage_dir
+        dotfile = find
+        return "coverage" unless dotfile
+
+        with_simplecov_loaded { read_from(dotfile) }
+      rescue LoadError, StandardError => e
+        # simplecov:disable — defensive fallback for a bad dotfile (parse
+        # error, EACCES, etc.); never fires in the project's own dogfood run
+        warn "simplecov: failed to read coverage_dir from #{dotfile}: #{e.class}: #{e.message}"
+        "coverage"
+        # simplecov:enable
+      end
+
+      # Load the dotfile, snapshot+restore `SimpleCov.coverage_dir` so we
+      # don't quietly clobber it in a host process that's already
+      # configured (e.g. when the CLI is exercised inline by simplecov's
+      # own spec suite). The snapshot is intentionally narrow: a dotfile
+      # can still mutate other SimpleCov configuration (filters, groups,
+      # formatters, command_name, ...) via `SimpleCov.configure` or
+      # `SimpleCov.start { ... }` blocks. The CLI normally runs as a
+      # top-level process where that's harmless; callers driving it from
+      # inside a Ruby host that cares about isolation should arrange that
+      # themselves.
+      def read_from(dotfile)
+        snapshot = SimpleCov.instance_variable_get(:@coverage_dir)
+        load_with_start_neutered(dotfile)
+        dir = SimpleCov.coverage_dir
+        SimpleCov.instance_variable_set(:@coverage_dir, snapshot)
+        dir
+      end
+
+      def find
+        dir = Pathname.new(Dir.pwd)
+        loop do
+          candidate = dir.join(".simplecov")
+          return candidate.to_s if candidate.exist?
+          break if dir.root?
+
+          dir = dir.parent
+        end
+        nil
+      end
+
+      def with_simplecov_loaded
+        previous_no_defaults = ENV.fetch("SIMPLECOV_NO_DEFAULTS", nil) #: String?
+        previous_cli         = ENV.fetch("SIMPLECOV_CLI", nil) #: String?
+        ENV["SIMPLECOV_NO_DEFAULTS"] = "1"
+        # SIMPLECOV_CLI lets a project's `.simplecov` opt some config into
+        # CLI-only behavior — e.g. simplecov itself sets `coverage_dir`
+        # to the dogfood path here but skips that for descendants.
+        ENV["SIMPLECOV_CLI"] = "1"
+        require "simplecov"
+        yield
+      ensure
+        # @type var previous_no_defaults: String?
+        # @type var previous_cli: String?
+        ENV["SIMPLECOV_NO_DEFAULTS"] = previous_no_defaults
+        ENV["SIMPLECOV_CLI"]         = previous_cli
+      end
+
+      # Load `path` with `SimpleCov.start` and the at_exit installer
+      # turned into no-ops, so a project whose dotfile calls
+      # `SimpleCov.start` doesn't trigger Coverage just because we asked
+      # for `coverage_dir`. Config inside any `SimpleCov.start { ... }`
+      # block still runs.
+      def load_with_start_neutered(path)
+        klass = SimpleCov.singleton_class
+        names = %i[start_tracking install_at_exit_hook]
+        stash = names.to_h { |name| [name, klass.instance_method(name)] } #: Hash[Symbol, UnboundMethod]
+        # define_method over an existing method emits a "method redefined"
+        # warning under $VERBOSE; the override and restore are intentional.
+        silence_verbose { names.each { |name| klass.define_method(name) { nil } } }
+        load path
+      ensure
+        # @type var stash: Hash[Symbol, UnboundMethod]
+        # @type var klass: Class
+        silence_verbose { stash.each { |name, method| klass.define_method(name, method) } }
+      end
+
+      def silence_verbose
+        previous = $VERBOSE #: bool?
+        $VERBOSE = nil
+        yield
+      ensure
+        # @type var previous: bool?
+        $VERBOSE = previous
+      end
+    end
+  end
+end

data/lib/simplecov/cli/merge.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+
+module SimpleCov
+  module CLI
+    # `simplecov merge <files...>` — wrap SimpleCov::ResultMerger so a
+    # CI matrix that produces one .resultset.json per worker can stitch
+    # them together from the shell instead of dropping a Rake task into
+    # every project. Requires the full simplecov library to be on the
+    # load path; lazy-required so the read-only subcommands above don't
+    # pay for ResultMerger (and its Coverage runtime guard).
+    module Merge
+    module_function
+
+      def run(args, stdout:, stderr:, **)
+        opts = parse(args)
+        return error(stderr, "missing input files") if opts[:files].empty?
+        return 1 unless valid_inputs?(opts[:files], stderr)
+
+        require "simplecov"
+        result = SimpleCov::ResultMerger.merge_results(*opts[:files], ignore_timeout: !opts[:honor_timeout])
+        return error(stderr, "no mergeable results in input files") unless result
+
+        commit(opts, result, stdout)
+        0
+      end
+
+      def commit(opts, result, stdout)
+        verb = opts[:dry_run] ? "would write" : "wrote"
+        write(opts[:output], result) unless opts[:dry_run]
+        stdout.puts("simplecov merge: #{verb} #{opts[:output]}") unless opts[:quiet]
+      end
+
+      def valid_inputs?(files, stderr)
+        parsed = parse_inputs(files, stderr) or return false
+
+        warn_about_duplicate_command_names(parsed, stderr)
+        true
+      end
+
+      def parse(args)
+        opts = {output: SimpleCov::CLI.default_resultset, honor_timeout: false, dry_run: false, quiet: false}
+        files =
+          OptionParser.new do |o|
+            o.on("--output PATH") { |v| opts[:output] = v }
+            o.on("--honor-timeout") { opts[:honor_timeout] = true }
+            o.on("--dry-run") { opts[:dry_run] = true }
+            o.on("-q", "--quiet") { opts[:quiet] = true }
+          end.parse(args)
+        opts.merge(files: files)
+      end
+
+      # Validate every input file up-front and return a {path => parsed}
+      # hash. Surfacing per-file errors here turns ResultMerger's
+      # generic "no mergeable results" into a message that points at
+      # the specific input causing the failure.
+      def parse_inputs(files, stderr)
+        parsed = {} #: Hash[String, Hash[String, untyped]]
+        files.each_with_object(parsed) do |path, memo|
+          data = parse_input(path, stderr) or return nil
+
+          memo[path] = data
+        end
+      end
+
+      def parse_input(path, stderr)
+        return parse_input_error(stderr, path, "not found") unless File.exist?(path)
+
+        data = JSON.parse(File.read(path))
+        return data if data.is_a?(Hash) && !data.empty?
+
+        parse_input_error(stderr, path, "has no resultset entries")
+      rescue JSON::ParserError => e
+        parse_input_error(stderr, path, "isn't valid JSON (#{e.message})")
+      end
+
+      def parse_input_error(stderr, path, reason)
+        stderr.puts("simplecov merge: input file #{path.inspect} #{reason}")
+        nil
+      end
+
+      # When two input files share a command_name, ResultMerger folds
+      # them together with last-write-wins on the timestamp — easy to
+      # mistake for "no merge happened." Surface the overlap so the
+      # operator can rename the workers or accept the merge knowingly.
+      def warn_about_duplicate_command_names(parsed, stderr)
+        files_per_command = {} #: Hash[String, Array[String]]
+        parsed.each do |path, data|
+          data.each_key { |command_name| (files_per_command[command_name] ||= []) << path }
+        end
+        files_per_command.each do |command_name, paths|
+          next if paths.size < 2
+
+          stderr.puts(duplicate_warning(command_name, paths))
+        end
+      end
+
+      def duplicate_warning(command_name, paths)
+        "simplecov merge: warning — command_name #{command_name.inspect} " \
+          "appears in #{paths.size} input files (#{paths.join(', ')}); " \
+          "entries will be merged"
+      end
+
+      def write(path, result)
+        require "fileutils"
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, JSON.pretty_generate(result.to_hash))
+      end
+
+      def error(stderr, message)
+        stderr.puts("simplecov merge: #{message}")
+        1
+      end
+    end
+  end
+end

data/lib/simplecov/cli/open.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module SimpleCov
+  module CLI
+    # `simplecov open [--report PATH]` — open the HTML report in the
+    # platform's default browser. Tiny QoL wrapper around `xdg-open` /
+    # `open` / `start` so users don't have to type a file:// URL.
+    module Open
+    module_function
+
+      def run(args, stderr:, **)
+        path = parse(args)
+        return error(stderr, "#{path} not found") unless File.exist?(path)
+
+        opener = browser_opener
+        return error(stderr, "no known opener for #{RbConfig::CONFIG['host_os']}") unless opener
+
+        system(*opener, path) ? 0 : 1
+      end
+
+      def error(stderr, message)
+        stderr.puts("simplecov open: #{message}")
+        1
+      end
+
+      def parse(args)
+        path = SimpleCov::CLI.default_report
+        OptionParser.new do |o|
+          o.on("--report PATH") { |v| path = v }
+        end.parse(args)
+        path
+      end
+
+      # Returns the argv for the platform's "open this file" command, or
+      # nil if the host OS isn't recognized. On Windows, `start` is a
+      # cmd.exe builtin (not an executable), so route through `cmd /c`;
+      # the empty string is the window-title positional `start` takes
+      # before the path so a quoted path isn't mis-parsed as the title.
+      def browser_opener
+        case RbConfig::CONFIG["host_os"]
+        when /darwin/             then ["open"]
+        when /mswin|mingw|cygwin/ then ["cmd", "/c", "start", ""]
+        when /linux|bsd|solaris/  then ["xdg-open"]
+        end
+      end
+    end
+  end
+end