simplecov 0.22.0 → 1.0.0.rc1

data/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/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/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/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

data/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/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/lib/simplecov/combine/branches_combiner.rb

@@ -10,12 +10,13 @@ module SimpleCov
     module_function
 
       #
-      # Return merged branches or the existed brach if other is missing.
+      # 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}, other conditions...}
+      # 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]

data/lib/simplecov/combine/files_combiner.rb

@@ -16,7 +16,13 @@ module SimpleCov
       #
       def combine(coverage_a, coverage_b)
         combination = {"lines" => Combine.combine(LinesCombiner, coverage_a["lines"], coverage_b["lines"])}
-        combination["branches"] = Combine.combine(BranchesCombiner, coverage_a["branches"], coverage_b["branches"]) if SimpleCov.branch_coverage?
+        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

data/lib/simplecov/combine/lines_combiner.rb

@@ -9,34 +9,36 @@ module SimpleCov
     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)
-        coverage_a
-          .zip(coverage_b)
-          .map do |coverage_a_val, coverage_b_val|
-            merge_line_coverage(coverage_a_val, coverage_b_val)
-          end
+        size = [coverage_a.size, coverage_b.size].max
+        Array.new(size) { |i| merge_line_coverage(coverage_a[i], coverage_b[i]) }
       end
 
-      # Return depends on coverage in a specific line
-      #
-      # @param [Integer || nil] first_val
-      # @param [Integer || nil] second_val
+      # 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 + 0 = nil
       # => nil + nil = nil
-      # => int + int = int
+      # => 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)
-        sum = first_val.to_i + second_val.to_i
+        return nil if first_val.nil? && second_val.nil?
 
-        if sum.zero? && (first_val.nil? || second_val.nil?)
-          nil
-        else
-          sum
-        end
+        first_val.to_i + second_val.to_i
       end
     end
   end