ultra-pro-pkg 0.0.1

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

@@ -0,0 +1,100 @@
+# 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)
+        previous_cli         = ENV.fetch("SIMPLECOV_CLI", nil)
+        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
+        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)] }
+        # 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
+        silence_verbose { stash.each { |name, method| klass.define_method(name, method) } }
+      end
+
+      def silence_verbose
+        previous = $VERBOSE
+        $VERBOSE = nil
+        yield
+      ensure
+        $VERBOSE = previous
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# 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)
+        files.each_with_object({}) 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 = parsed.each_with_object({}) do |(path, data), memo|
+          data.each_key { |command_name| (memo[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/simplecov-1.0.0/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

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+
+module SimpleCov
+  module CLI
+    # `simplecov report [--input PATH]` — pretty-print the overall
+    # totals row plus per-group totals from a JSONFormatter
+    # coverage.json. Same numbers as the HTML report's totals row, for
+    # contexts where opening a browser isn't an option (CI logs, ssh
+    # sessions, terminal-only workflows).
+    module Report
+      SECTIONS = [%w[Line lines], %w[Branch branches], %w[Method methods]].freeze
+
+    module_function
+
+      def run(args, stdout:, stderr:)
+        opts = parse(args)
+        return 1 unless (data = load_data(opts[:input], stderr))
+
+        if opts[:json]
+          emit_json(stdout, data)
+        else
+          emit_text(stdout, data, SimpleCov::CLI.color_enabled?(opts, stdout))
+        end
+        0
+      end
+
+      def parse(args)
+        opts = {input: SimpleCov::CLI.default_input, json: false, no_color: false}
+        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)
+        opts
+      end
+
+      def load_data(input, stderr)
+        return JSON.parse(File.read(input)) if File.exist?(input)
+
+        stderr.puts("simplecov report: #{input} not found")
+        nil
+      end
+
+      def emit_text(stdout, data, color)
+        emit_totals(stdout, "All Files", data.fetch("total", {}), color)
+        data.fetch("groups", {}).each { |name, group| emit_totals(stdout, name, group, color) }
+      end
+
+      def emit_totals(stdout, label, totals, color)
+        stdout.puts(label)
+        SECTIONS.each { |display, key| emit_section(stdout, display, totals[key], color) }
+        stdout.puts
+      end
+
+      def emit_section(stdout, display, section, color)
+        return unless section.is_a?(Hash) && section["total"].to_i.positive?
+
+        stdout.puts(format("  %<label>-7s %<pct>s (%<covered>d / %<total>d)",
+                           label: "#{display}:",
+                           pct: SimpleCov::Color.colorize_percent(section["percent"].to_f, enabled: color),
+                           covered: section["covered"] || 0,
+                           total: section["total"] || 0))
+      end
+
+      def emit_json(stdout, data)
+        payload = {"All Files" => collect_section(data.fetch("total", {}))}
+        data.fetch("groups", {}).each { |name, group| payload[name] = collect_section(group) }
+        stdout.puts(JSON.pretty_generate(payload))
+      end
+
+      def collect_section(totals)
+        SECTIONS.each_with_object({}) do |(_, key), out|
+          section = totals[key]
+          next unless section.is_a?(Hash) && section["total"].to_i.positive?
+
+          out[key] = {"percent" => section["percent"], "covered" => section["covered"], "total" => section["total"]}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module CLI
+    # `simplecov run <command...>` — exec the given command with
+    # simplecov auto-loaded so a coverage report drops into the
+    # project's coverage/ directory at the end. Useful for projects
+    # without a test_helper that already calls SimpleCov.start (e.g.
+    # plain `bundle exec rake test` on an unconfigured library).
+    module Run
+      AUTOSTART = File.expand_path("../autostart", __dir__)
+
+    module_function
+
+      def run(args, stderr:, **)
+        cmd = args.first == "--" ? args.drop(1) : args
+        if cmd.empty?
+          stderr.puts("simplecov run: missing command")
+          return 1
+        end
+
+        Kernel.exec(rubyopt_env, *cmd)
+      rescue Errno::ENOENT => e
+        stderr.puts("simplecov run: #{e.message}")
+        127
+      end
+
+      def rubyopt_env
+        existing = ENV["RUBYOPT"].to_s.strip
+        injection = "-r#{AUTOSTART}"
+        merged = existing.empty? ? injection : "#{existing} #{injection}"
+        ENV.to_hash.merge("RUBYOPT" => merged)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module SimpleCov
+  module CLI
+    # `simplecov serve [--port N] [--host HOST]` — serve the coverage
+    # report over HTTP. A 30-line static file server backed by stdlib
+    # `socket`, so there's no extra dependency just for "view a local
+    # report on a CI box where `file://` doesn't work."
+    module Serve
+      MIME = {
+        ".html" => "text/html; charset=utf-8",
+        ".htm" => "text/html; charset=utf-8",
+        ".css" => "text/css",
+        ".js" => "application/javascript",
+        ".json" => "application/json",
+        ".svg" => "image/svg+xml",
+        ".png" => "image/png",
+        ".gif" => "image/gif",
+        ".jpg" => "image/jpeg",
+        ".jpeg" => "image/jpeg",
+        ".ico" => "image/x-icon",
+        ".txt" => "text/plain; charset=utf-8"
+      }.freeze
+      STATUS_TEXT = {
+        200 => "OK", 400 => "Bad Request", 403 => "Forbidden",
+        404 => "Not Found", 405 => "Method Not Allowed"
+      }.freeze
+
+    module_function
+
+      def run(args, stdout:, stderr:, **)
+        opts = parse(args)
+        dir = SimpleCov::CLI.coverage_dir
+        return error(stderr, "#{dir} doesn't exist; run your test suite first") unless File.directory?(dir)
+
+        require "socket"
+        server = TCPServer.new(opts[:host], opts[:port])
+        announce(stdout, server, dir)
+        serve_loop(server, dir, stdout)
+        0
+      ensure
+        server&.close
+      end
+
+      def parse(args)
+        opts = {port: 0, host: "127.0.0.1"}
+        OptionParser.new do |o|
+          o.on("--port N", Integer) { |v| opts[:port] = v }
+          o.on("--host HOST")       { |v| opts[:host] = v }
+        end.parse(args)
+        opts
+      end
+
+      def announce(stdout, server, dir)
+        port = server.addr[1]
+        host = server.addr[3]
+        stdout.puts("simplecov serve: serving #{dir} at http://#{host}:#{port}/")
+        stdout.puts("Press Ctrl-C to stop.")
+      end
+
+      def serve_loop(server, dir, stdout)
+        loop { handle_connection(server.accept, dir) }
+      rescue Interrupt
+        stdout.puts("\nsimplecov serve: stopping")
+      end
+
+      # Reads one HTTP request line, drains headers, serves the file or
+      # writes a status response. Wide rescue so a misbehaving client
+      # can't crash the server.
+      def handle_connection(client, root)
+        method, path = client.readline.split
+        drain_headers(client)
+        return respond(client, 405) unless method == "GET"
+
+        file = resolve(path, root)
+        return respond(client, file == :forbidden ? 403 : 404) unless file.is_a?(String)
+
+        respond(client, 200, File.binread(file), MIME[File.extname(file).downcase])
+      rescue StandardError
+        # Misbehaving clients (truncated requests, connection resets,
+        # invalid encoding) shouldn't take the whole server down.
+        nil
+      ensure
+        # simplecov:disable — `client` is the parameter, never nil here;
+        # the `&.` is purely defensive in case of future refactors
+        client&.close
+        # simplecov:enable
+      end
+
+      def drain_headers(client)
+        loop { break if client.readline.strip.empty? }
+      end
+
+      # Returns the absolute path of the file to serve, :forbidden for
+      # a traversal attempt (including symlinks that escape root), or
+      # nil for "not found".
+      def resolve(request_path, root)
+        path = request_path.split("?", 2).first.to_s.sub(%r{^/}, "")
+        absolute_root = File.realpath(root)
+        candidate = File.expand_path(path.empty? ? "index.html" : path, absolute_root)
+        # Reject `..` traversal and absolute-path attempts before
+        # touching disk so they're 403, not 404.
+        return :forbidden unless inside?(candidate, absolute_root)
+
+        candidate = File.join(candidate, "index.html") if File.directory?(candidate)
+        return nil unless File.file?(candidate)
+
+        # Resolve symlinks last and re-check: a file inside root could
+        # be a symlink pointing outside (e.g. /etc/passwd).
+        real = File.realpath(candidate)
+        inside?(real, absolute_root) ? real : :forbidden
+      rescue Errno::ENOENT
+        # simplecov:disable — TOCTOU: candidate vanished between
+        # File.file? and File.realpath. Treat as "not found".
+        nil
+        # simplecov:enable
+      end
+
+      def inside?(path, root)
+        path == root || path.start_with?(root + File::SEPARATOR)
+      end
+
+      def respond(client, status, body = "", content_type = "text/plain")
+        client.write("HTTP/1.1 #{status} #{STATUS_TEXT[status] || 'Error'}\r\n",
+                     "Content-Type: #{content_type || 'application/octet-stream'}\r\n",
+                     "Content-Length: #{body.bytesize}\r\n",
+                     "Connection: close\r\n\r\n")
+        client.write(body)
+      end
+
+      def error(stderr, message)
+        stderr.puts("simplecov serve: #{message}")
+        1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+require_relative "report"
+
+module SimpleCov
+  module CLI
+    # `simplecov uncovered [--threshold N] [--top N] [--criterion C]` — list
+    # the lowest-coverage files (by the chosen criterion, ascending), so a
+    # developer can answer "where should I add tests next?" without
+    # opening a browser. Reads coverage.json directly.
+    module Uncovered
+      DEFAULT_TOP = 10
+
+      # The coverage.json fields backing each criterion.
+      CRITERION_KEYS = {
+        line: {percent: "lines_covered_percent", covered: "covered_lines", total: "total_lines"},
+        branch: {percent: "branches_covered_percent", covered: "covered_branches", total: "total_branches"},
+        method: {percent: "methods_covered_percent", covered: "covered_methods", total: "total_methods"}
+      }.freeze
+
+    module_function
+
+      def run(args, stdout:, stderr:, **)
+        opts = parse(args)
+        keys = CRITERION_KEYS[opts[:criterion]]
+        return unknown_criterion(opts[:criterion], stderr) unless keys
+
+        report(opts, keys, stdout, stderr)
+      end
+
+      def report(opts, keys, stdout, stderr)
+        return 1 unless (data = Report.load_data(opts[:input], stderr))
+
+        files = rank(data.fetch("coverage", {}), opts[:threshold], keys).first(opts[:top])
+        return stdout.puts(empty_message(opts[:json])) || 0 if files.empty?
+
+        emit(stdout, files, opts)
+        0
+      end
+
+      def unknown_criterion(criterion, stderr)
+        stderr.puts("simplecov uncovered: unknown --criterion #{criterion.inspect} (expected line, branch, or method)")
+        1
+      end
+
+      def emit(stdout, files, opts)
+        opts[:json] ? emit_json(stdout, files) : emit_text(stdout, files, SimpleCov::CLI.color_enabled?(opts, stdout))
+      end
+
+      def parse(args)
+        opts = {input: SimpleCov::CLI.default_input, threshold: 100.0, top: DEFAULT_TOP, criterion: :line, no_color: false}
+        build_parser(opts).parse(args)
+        opts
+      end
+
+      # Option parsing with per-flag coercions is inherently ABC-heavy; the
+      # metric is noise here.
+      def build_parser(opts) # rubocop:disable Metrics/AbcSize
+        OptionParser.new do |o|
+          o.on("--input PATH")         { |v| opts[:input] = v }
+          o.on("--threshold N", Float) { |v| opts[:threshold] = v }
+          o.on("--top N", Integer)     { |v| opts[:top] = v }
+          o.on("--criterion C")        { |v| opts[:criterion] = v.to_sym }
+          o.on("--json")               { opts[:json] = true }
+          o.on("--no-color")           { opts[:no_color] = true }
+        end
+      end
+
+      def emit_text(stdout, files, color)
+        files.each { |fname, pct, covered, total| stdout.puts(format_row(fname, pct, covered, total, color)) }
+      end
+
+      def emit_json(stdout, files)
+        rows = files.map do |fname, pct, covered, total|
+          {"file" => fname, "percent" => pct, "covered" => covered, "total" => total}
+        end
+        stdout.puts(JSON.pretty_generate(rows))
+      end
+
+      def empty_message(json)
+        json ? "[]" : "simplecov uncovered: nothing to report"
+      end
+
+      def rank(coverage_hash, threshold, keys)
+        rows = coverage_hash.filter_map { |fname, payload| row_for(fname, payload, threshold, keys) }
+        rows.sort_by { |_fname, pct, _c, _t| pct }
+      end
+
+      def row_for(fname, payload, threshold, keys)
+        return unless payload.is_a?(Hash) && payload[keys[:total]].to_i.positive?
+
+        pct = payload[keys[:percent]].to_f
+        return if pct >= threshold
+
+        [fname, pct, payload[keys[:covered]].to_i, payload[keys[:total]].to_i]
+      end
+
+      def format_row(fname, pct, covered, total, color)
+        format("%<pct>s  %<covered>d/%<total>d  %<fname>s",
+               pct: SimpleCov::Color.colorize_percent(pct, format("%6.2f%%", pct), enabled: color),
+               covered: covered, total: total, fname: fname)
+      end
+    end
+  end
+end