simplecov 1.1.1 → 1.2.0

data/lib/simplecov/cli/ratchet/output.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module CLI
+    module Ratchet
+      module Output
+        extend CommandHelpers
+
+        extend self
+
+        def emit(stdout, opts, outcome, generated)
+          return stdout.puts(JSON.generate(json_summary(opts, outcome, generated))) if opts.fetch(:json)
+
+          verb = opts.fetch(:dry_run) ? "would write" : "wrote"
+          stdout.puts("simplecov ratchet: #{verb} #{opts.fetch(:baseline)} (#{change_summary(outcome, generated)})")
+          report_regressed(stdout, outcome.regressed)
+        end
+
+        def change_summary(outcome, generated)
+          files = outcome.baseline.entries.size
+          return "#{files} #{one?(files) ? "file" : "files"}" if generated
+
+          "#{outcome.tightened.size} tightened, #{outcome.pruned.size} pruned, #{outcome.unchanged.size} unchanged"
+        end
+
+        def report_regressed(stdout, regressed)
+          return if regressed.empty?
+
+          noun = one?(regressed.size) ? "1 file below its floor" : "#{regressed.size} files below their floors"
+          stdout.puts("simplecov ratchet: #{noun}, entries kept unchanged")
+        end
+
+        def json_summary(opts, outcome, generated)
+          {
+            written: !opts.fetch(:dry_run), path: opts.fetch(:baseline), generated: generated,
+            files: outcome.baseline.entries.size,
+            tightened: outcome.tightened, pruned: outcome.pruned,
+            regressed: outcome.regressed, unchanged: outcome.unchanged
+          }
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/cli/ratchet.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../atomic_file"
+require_relative "command_helpers"
+require_relative "coverage_file"
+require_relative "ratchet/output"
+
+module SimpleCov
+  module CLI
+    # `simplecov ratchet`: rewrite the checked-in per-file coverage baseline
+    # (#1268) from the current report. Floors only ever tighten, entries for
+    # files the report no longer carries are pruned, and files without an entry
+    # are never given one, so new code stays answerable to the global thresholds
+    # rather than to a floor cut at whatever it launched with. `--init`
+    # regenerates the whole file from the current state.
+    #
+    # The baseline path follows the project's `.simplecov` `baseline_file`
+    # setting when one is present, the same way the read-only commands follow
+    # `coverage_dir`.
+    module Ratchet
+      extend CommandHelpers
+
+      extend self
+
+      def run(args, stdout:, stderr:, **)
+        require "simplecov"
+        opts = parse(args, stderr) or return 1
+        coverage = CoverageFile.load_coverage(opts.fetch(:input), command: "ratchet", stderr: stderr) or return 1
+
+        outcome, generated = compute(opts, current_floors(coverage))
+        AtomicFile.write(opts.fetch(:baseline), outcome.baseline.to_yaml) unless opts.fetch(:dry_run)
+        Output.emit(stdout, opts, outcome, generated)
+        0
+      rescue ConfigurationError => e
+        error(stderr, e)
+      end
+
+      def parse(args, stderr)
+        opts, rest = parse_common(args, init: false, dry_run: false) do |parser, options|
+          parser.on("--baseline PATH") { |v| options[:baseline] = v }
+          parser.on("--init") { options[:init] = true }
+          parser.on("--dry-run") { options[:dry_run] = true }
+        end
+        return error_nil(stderr, "unexpected argument #{rest.first.inspect}") unless rest.empty?
+
+        opts[:baseline] ||= Dotfile.baseline_file
+        opts
+      end
+
+      # Only criteria the report carries for a file appear, so a line-only report
+      # leaves existing branch floors alone.
+      def current_floors(coverage)
+        initial = {} #: Baseline::current_floors
+        coverage.each_with_object(initial) do |(path, entry), floors|
+          criteria = CoverageFile::CRITERIA.filter_map do |criterion, keys|
+            percent = entry[keys.fetch(:percent)]
+            missed = entry[keys.fetch(:missed)]
+            [criterion, {percent: SimpleCov.round_coverage(percent), missed: missed}] if usable?(percent, missed)
+          end.to_h
+          floors[path] = criteria unless criteria.empty?
+        end
+      end
+
+      # A report row from another tool may be missing counts; only a complete pair
+      # can become a floor.
+      def usable?(percent, missed)
+        percent.is_a?(Numeric) && missed.instance_of?(Integer)
+      end
+
+      def compute(opts, current)
+        existing = Baseline.read_if_exists(opts.fetch(:baseline)) unless opts.fetch(:init)
+        return [existing.ratchet(current), false] if existing
+
+        none = [] #: Array[String]
+        outcome = Baseline::Outcome.new(
+          baseline: Baseline.generate(current),
+          tightened: none, pruned: none, regressed: none, unchanged: none
+        )
+        [outcome, true]
+      end
+    end
+  end
+end

data/lib/simplecov/cli/report.rb

@@ -6,46 +6,40 @@ require_relative "command_helpers"
 
 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
       extend CommandHelpers
 
       TOTAL_LABEL = "All Files"
-      SECTIONS = [%w[Line lines], %w[Branch branches], %w[Method methods]].freeze
+      SECTIONS = [%w[Line lines], %w[Branch branches], %w[Method methods]].freeze #: Array[[String, String]]
 
-    module_function
+      extend self
 
       def run(args, stdout:, stderr:)
         opts, = parse_common(args)
-        return 1 unless (data = load_data(opts[:input], stderr))
+        return 1 unless (data = load_data(opts.fetch(:input), stderr))
 
-        if opts[:json]
+        if opts.fetch(:json)
           emit_json(stdout, data)
         else
-          emit_text(stdout, data, SimpleCov::CLI.color_enabled?(opts, stdout))
+          emit_text(stdout, data, CLI.color_enabled?(opts, stdout))
         end
         0
       end
 
-      # Valid JSON isn't enough: a wrong-typed "total" or "groups" (or a
-      # wrong-typed group entry) used to escape here and crash the
-      # emitters with a backtrace instead of the one-line error the
-      # sibling commands print.
+      # Valid JSON isn't enough: a wrong-typed "total" or "groups" used to escape
+      # here and crash the emitters with a backtrace instead of the one-line error
+      # the sibling commands print.
       def load_data(input, stderr)
         data = CoverageFile.load_document(input, command: "report", stderr: stderr)
         return unless data
 
         none = {} #: Hash[String, untyped]
-        unless data.fetch("total", none).is_a?(Hash)
+        unless data.fetch("total", none).instance_of?(Hash)
           return CoverageFile.report_invalid(stderr, "report", input, '"total" must be an object')
         end
 
         groups = data.fetch("groups", none)
-        return data if groups.is_a?(Hash) && groups.each_value.all?(Hash)
+        return data if groups.instance_of?(Hash) && groups.each_value.all?(Hash)
 
         CoverageFile.report_invalid(stderr, "report", input, '"groups" must be an object of objects')
       end
@@ -54,7 +48,7 @@ module SimpleCov
         none = {} #: Hash[String, untyped]
         emit_totals(stdout, TOTAL_LABEL, data.fetch("total", none), color)
         data.fetch("groups", none).each do |name, group|
-          label = name == TOTAL_LABEL ? "#{name} (group)" : name
+          label = name.eql?(TOTAL_LABEL) ? "#{name} (group)" : name
           emit_totals(stdout, label, group, color)
         end
       end
@@ -66,12 +60,12 @@ module SimpleCov
       end
 
       def emit_section(stdout, display, section, color)
-        return unless section.is_a?(Hash) && section["total"].to_i.positive?
+        return unless section.instance_of?(Hash) && section["total"].to_i.positive?
 
         stdout.puts(stats_row(display,
-                              SimpleCov::Color.colorize_percent(section["percent"].to_f, enabled: color),
-                              section["covered"],
-                              section["total"]))
+          Color.colorize_percent(section["percent"].to_f, enabled: color),
+          section["covered"],
+          section.fetch("total")))
       end
 
       def emit_json(stdout, data)
@@ -85,10 +79,10 @@ module SimpleCov
         sections = {} #: Hash[String, untyped]
         SECTIONS.each_with_object(sections) do |(_, key), out|
           section = totals[key]
-          next unless section.is_a?(Hash) && section["total"].to_i.positive?
+          next unless section.instance_of?(Hash) && section["total"].to_i.positive?
 
-          out[key.to_s] = {
-            "percent" => section["percent"], "covered" => section["covered"], "total" => section["total"]
+          out[key] = {
+            "percent" => section["percent"], "covered" => section["covered"], "total" => section.fetch("total")
           }
         end
       end

data/lib/simplecov/cli/run.rb

@@ -2,29 +2,28 @@
 
 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__.to_s)
 
-    module_function
+      extend self
 
       def run(args, stderr:, **)
-        cmd = args.first == "--" ? args.drop(1) : args
+        cmd = args.first.eql?("--") ? args.drop(1) : args
         if cmd.empty?
           stderr.puts("simplecov run: missing command")
           return 1
         end
 
-        Kernel.exec(rubyopt_env, *cmd)
+        exec_command(rubyopt_env, cmd)
       rescue Errno::ENOENT => e
-        stderr.puts("simplecov run: #{e.message}")
+        stderr.puts("simplecov run: #{e}")
         127
       end
 
+      def exec_command(env, cmd)
+        Kernel.exec(env, *cmd)
+      end
+
       def rubyopt_env
         existing = ENV["RUBYOPT"].to_s.strip
         injection = "-r#{AUTOSTART}"

data/lib/simplecov/cli/serve/report_preparer.rb

@@ -5,9 +5,6 @@ require_relative "../../coverage_json"
 module SimpleCov
   module CLI
     module Serve
-      # Ensures the coverage directory has a renderable entry point before
-      # the HTTP server binds. Existing self-contained reports take priority
-      # over their optional JSON sidecar.
       module ReportPreparer
         def self.call(dir)
           index_path = File.join(dir, "index.html")
@@ -17,11 +14,15 @@ module SimpleCov
 
           return "#{dir} has no index.html or coverage.json; run your test suite first" unless File.file?(json_path)
 
+          build_index(json_path, dir)
+        rescue CoverageJSON::Error, SystemCallError => e
+          "cannot build index.html from #{json_path}: #{e}"
+        end
+
+        def self.build_index(json_path, dir)
           require_relative "../../formatter/html_formatter"
-          SimpleCov::Formatter::HTMLFormatter.new.format_from_json(json_path, dir)
+          Formatter::HTMLFormatter.new.format_from_json(json_path, dir)
           nil
-        rescue SimpleCov::CoverageJSON::Error, SystemCallError => e
-          "cannot build index.html from #{json_path}: #{e.message}"
         end
       end
     end

data/lib/simplecov/cli/serve/static_file_handler.rb

@@ -3,10 +3,10 @@
 module SimpleCov
   module CLI
     module Serve
-      # The HTTP mechanics behind `simplecov serve`: reads one request
-      # per connection and answers it from the report directory, with
-      # traversal-safe path resolution. Kept apart from the CLI wiring
-      # (option parsing, binding, the accept loop) in serve.rb.
+      # The HTTP mechanics behind `simplecov serve`: reads one request per
+      # connection and answers it from the report directory, with
+      # traversal-safe path resolution. Kept apart from the CLI wiring in
+      # serve.rb.
       module StaticFileHandler
         MIME = {
           ".html" => "text/html; charset=utf-8", ".htm" => "text/html; charset=utf-8",
@@ -24,96 +24,102 @@ module SimpleCov
         STATUS_TEXT = {200 => "OK", 400 => "Bad Request", 403 => "Forbidden",
                        404 => "Not Found", 405 => "Method Not Allowed"}.freeze
 
-        # Seconds a connection may sit idle mid-request before its reads
-        # raise IO::TimeoutError and the connection is dropped.
+        # Seconds a connection may sit idle mid-request before its reads raise
+        # IO::TimeoutError and the connection is dropped.
         READ_TIMEOUT = 5
 
-      module_function
-
-        # 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. The read timeout keeps idle connections
-        # from pinning their threads forever.
-        def handle_connection(client, root)
-          # simplecov:disable branch — support for IO#timeout= is fixed by the engine
-          # JRuby and TruffleRuby don't implement IO#timeout=. Without
-          # the guard the NoMethodError lands in the wide rescue below
-          # and every connection closes with an empty response. On those
-          # engines an idle connection pins its thread instead of timing
-          # out, which only leaks a thread in an interactive dev server.
+        extend self
+
+        # 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.
+        #
+        # `routes` maps exact request paths (query string excluded) to callables
+        # that take over the connection, the seam `simplecov watch` mounts its
+        # /events stream on. A route may hold the socket for as long as it
+        # likes; the ensure below closes it when the route returns.
+        def handle_connection(client, root, routes = {})
+          # JRuby doesn't implement IO#timeout=. Without the guard the
+          # NoMethodError lands in the wide rescue below and every connection
+          # closes with an empty response. An idle connection then pins its
+          # thread instead of timing out, which only leaks a thread in an
+          # interactive dev server.
           client.timeout = READ_TIMEOUT if client.respond_to?(:timeout=)
-          # simplecov:enable branch
           method, path = client.readline.split
           drain_headers(client)
-          # A request line without both tokens used to raise on
-          # `path.split` inside the wide rescue, closing the connection
-          # with an empty response instead of the 400 defined below.
+          # A request line without both tokens used to raise on `path.split` inside
+          # the wide rescue, closing the connection with an empty response
+          # instead of the 400 below.
           return respond(client, 400) if path.nil?
-          return respond(client, 405) unless method == "GET"
 
-          serve_file(client, path, root)
-        rescue StandardError
-          # Misbehaving clients (truncated requests, connection resets,
-          # invalid encoding) shouldn't take the whole server down.
+          dispatch(client, method, path, root, routes)
+        rescue
+          # 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
+          client.close
+        end
+
+        def dispatch(client, method, path, root, routes)
+          return respond(client, 405) unless method.eql?("GET")
+
+          route = routes[path.split("?").first]
+          return route.call(client) if route
+
+          serve_file(client, path, root)
         end
 
         def serve_file(client, path, root)
           file = resolve(path, root)
-          return respond(client, file == :forbidden ? 403 : 404) unless file.is_a?(String)
+          # `resolve` answers a path, nothing for a file that is not there, or the
+          # refusal itself.
+          return respond(client, file ? 403 : 404) unless file.instance_of?(String)
 
           respond(client, 200, File.binread(file), MIME[File.extname(file).downcase])
         end
 
         def drain_headers(client)
-          loop { break if client.readline.strip.empty? }
+          loop { break if client.readline.rstrip.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".
+        # Answers the absolute path of the file to serve, :forbidden for a
+        # traversal attempt (symlinks that escape root included), or nil for
+        # "not found".
         #
-        # The request path is deliberately NOT percent-decoded: filenames
-        # needing escapes don't occur in generated reports, and keeping
-        # `%2e%2e%2f` as literal bytes is part of the traversal defense.
-        # If decoding is ever added, it must happen BEFORE the `inside?`
-        # check below.
+        # The request path is deliberately NOT percent-decoded: filenames needing
+        # escapes don't occur in generated reports, and keeping `%2e%2e%2f` as
+        # literal bytes is part of the traversal defense. If decoding is ever
+        # added, it must happen BEFORE the `inside?` check.
         def resolve(request_path, root)
-          path = request_path.split("?", 2).first.to_s.sub(%r{^/}, "")
+          path = request_path.split("?").first.to_s.delete_prefix("/")
           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.
+          candidate = File.expand_path(path, absolute_root)
+          # Rejected before touching disk, so traversal and absolute-path attempts
+          # are 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).
+          # Symlinks are resolved last and re-checked: a file inside root could be
+          # a symlink pointing outside.
           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".
+          # TOCTOU: candidate vanished between File.file? and File.realpath.
           nil
-          # simplecov:enable
         end
 
         def inside?(path, root)
-          path == root || path.start_with?(root + File::SEPARATOR)
+          path.eql?(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("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
       end

data/lib/simplecov/cli/serve.rb

@@ -7,24 +7,22 @@ require_relative "serve/static_file_handler"
 
 module SimpleCov
   module CLI
-    # `simplecov serve [--port N] [--host HOST]` — serve the coverage
-    # report over HTTP. A small 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." This module is
-    # the CLI wiring (options, binding, the accept loop); the HTTP
-    # mechanics live in StaticFileHandler.
+    # `simplecov serve`: a small static file server backed by stdlib `socket`, so
+    # there is no extra dependency just for viewing a local report on a box where
+    # `file://` doesn't work. This module is the CLI wiring; the HTTP mechanics
+    # live in StaticFileHandler.
     module Serve
       extend CommandHelpers
 
-    module_function
+      extend self
 
       def run(args, stdout:, stderr:, **)
         opts = parse(args)
-        dir = SimpleCov::CLI.coverage_dir
+        dir = CLI.coverage_dir
         message = ReportPreparer.call(dir)
         return error(stderr, message) if message
 
-        require "socket"
+        require_socket
         with_server(opts, stderr) do |server|
           announce(stdout, server, dir)
           serve_loop(server, dir, stdout)
@@ -32,14 +30,20 @@ module SimpleCov
         end
       end
 
-      # Returns the block's exit status, or 1 when the socket can't be
-      # bound (port already taken, privileged port, unresolvable host).
+      # Required here rather than at load time so the other subcommands do not pay
+      # for sockets.
+      def require_socket
+        require "socket"
+      end
+
+      # Answers 1 when the socket can't be bound: port already taken, privileged
+      # port, unresolvable host. The receiver cast works around an rbs stdlib gap,
+      # where TCPSocket's explicit `self.new` shadows TCPServer#initialize's
+      # (host, port) form.
       def with_server(opts, stderr)
-        # The receiver cast works around an rbs stdlib gap: TCPSocket's
-        # explicit `self.new` shadows TCPServer#initialize's (host, port) form.
-        server = (_ = TCPServer).new(opts[:host], opts[:port]) #: TCPServer
+        server = (_ = TCPServer).new(opts.fetch(:host), opts.fetch(:port)) #: TCPServer
       rescue SystemCallError, SocketError => e
-        error(stderr, "cannot bind to #{opts[:host]}:#{opts[:port]} (#{e.message})")
+        error(stderr, "cannot bind to #{opts.fetch(:host)}:#{opts.fetch(:port)} (#{e})")
       else
         begin
           yield server
@@ -50,29 +54,28 @@ module SimpleCov
 
       def parse(args)
         opts = {port: 0, host: "127.0.0.1"} #: Hash[Symbol, untyped]
-        OptionParser.new do |o|
+        build_parser do |o|
           o.on("--port N", Integer) { |v| opts[:port] = v }
-          o.on("--host HOST")       { |v| opts[:host] = v }
+          o.on("--host HOST") { |v| opts[:host] = v }
         end.parse(args)
         opts
       end
 
       def announce(stdout, server, dir)
-        port = server.addr[1]
-        host = url_host(server.addr[3])
+        port = server.addr.fetch(1)
+        host = url_host(server.addr.fetch(3))
         stdout.puts("simplecov serve: serving #{dir} at http://#{host}:#{port}/")
         stdout.puts("Press Ctrl-C to stop.")
       end
 
-      # IPv6 literals need brackets in a URL (--host ::1 must announce
-      # http://[::1]:PORT/, not the invalid http://::1:PORT/).
+      # IPv6 literals need brackets in a URL: `--host ::1` must announce
+      # http://[::1]:PORT/, not the invalid http://::1:PORT/.
       def url_host(host)
         host.include?(":") ? "[#{host}]" : host
       end
 
-      # One thread per connection: browsers open speculative sockets
-      # that send no bytes, and a serial loop would stall every real
-      # request (the report's assets included) behind them.
+      # One thread per connection: browsers open speculative sockets that send no
+      # bytes, and a serial loop would stall every real request behind them.
       def serve_loop(server, dir, stdout)
         loop do
           Thread.new(server.accept) { |client| StaticFileHandler.handle_connection(client, dir) }

data/lib/simplecov/cli/show/annotator.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module CLI
+    module Show
+      # Renders one file's annotated source: a right-aligned line-number gutter,
+      # the hit count beside it, and a caret line naming each miss under the line
+      # it happened on.
+      module Annotator
+        extend self
+
+        def call(source, entry, stdout, color:)
+          markers = markers_for(entry)
+          widths = {number: source.size.to_s.length, count: count_width(entry)}
+          source.each_with_index do |line, index|
+            rendered = row(index + 1, entry.fetch("lines").at(index), line, widths, color)
+            emit(stdout, rendered, markers[index + 1], widths, color)
+          end
+        end
+
+        def emit(stdout, rendered, labels, widths, color)
+          stdout.puts(rendered)
+          return if labels.empty?
+
+          gutter = " " * (widths.fetch(:number) + widths.fetch(:count) + 4)
+          stdout.puts(gutter + paint("^ #{labels.join(", ")}", :red, color))
+        end
+
+        def missed_lines(entry)
+          entry.fetch("lines").each_with_index.filter_map do |hit, index|
+            index + 1 if hit.instance_of?(Integer) && hit.zero?
+          end
+        end
+
+        def markers_for(entry)
+          markers = Hash.new { |hash, line| hash[line] = [] } #: Hash[Integer, Array[String]]
+          missed_lines(entry).each { |line| markers[line] << "missed" }
+          each_missed(entry["branches"]) { |line| markers[line] << "branch missed" }
+          each_missed(entry["methods"]) { |line| markers[line] << "method missed" }
+          markers
+        end
+
+        def each_missed(items)
+          return unless items.instance_of?(Array)
+
+          items.each do |item|
+            line = missed_line_of(item)
+            yield line if line
+          end
+        end
+
+        # The reported line of a zero-hit item, nil for a covered or malformed one,
+        # the same tolerance the patch subcommand applies to branch entries.
+        def missed_line_of(item)
+          return nil unless item.instance_of?(Hash)
+
+          hits = item["coverage"]
+          return nil unless hits.instance_of?(Integer) && hits.zero?
+
+          line = item["report_line"] || item["start_line"]
+          line if line.instance_of?(Integer)
+        end
+
+        def count_width(entry)
+          entry.fetch("lines").grep(Integer) { |hit| hit.to_s.length }.max || 1
+        end
+
+        def row(number, hit, line, widths, color)
+          format("%#{widths.fetch(:number)}d  %s  %s", number, count(hit, widths, color), line).rstrip
+        end
+
+        # Padded to width before it is painted, so escape codes can't skew the
+        # column, and blank for a line carrying no count.
+        def count(hit, widths, color)
+          padded = (hit.instance_of?(Integer) ? hit.to_s : "").rjust(widths.fetch(:count))
+          return padded unless hit.instance_of?(Integer)
+
+          paint(padded, hit.zero? ? :red : :green, color)
+        end
+
+        def paint(text, tint, color)
+          Color.colorize(text, tint, enabled: color)
+        end
+      end
+    end
+  end
+end