simplecov 0.22.0 → 1.1.1

data/lib/simplecov/cli.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "color"
+require_relative "cli/dotfile"
+require_relative "cli/clean"
+require_relative "cli/coverage_file"
+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 dispatch(handler, command, 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
+
+    # One rescue covers every subcommand's OptionParser, so a typo'd
+    # flag or a malformed typed argument becomes a one-line error and
+    # exit status 1 instead of an unhandled-exception backtrace.
+    def dispatch(handler, command, rest, stdout:, stderr:)
+      handler.run(rest, stdout: stdout, stderr: stderr)
+    rescue OptionParser::ParseError => e
+      stderr.puts("simplecov #{command}: #{e.message} (run `simplecov help` for 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 (deleted
+                                    files don't count as drops)
+          --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,83 @@
+# 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)
+      # `SimpleCov.color` only exists once the full library is loaded.
+      # The standalone CLI (`exe/simplecov`) loads `simplecov/color`
+      # without `simplecov` itself to stay lightweight, so treat a
+      # missing config the same as its `:auto` default: fall through to
+      # the env vars and tty check below.
+      config = SimpleCov.color if SimpleCov.respond_to?(:color)
+      return config if [true, false].include?(config)
+      return false if env_set?("NO_COLOR")
+      return true  if env_set?("FORCE_COLOR")
+
+      stream.tty?
+    rescue IOError
+      # A parallel runner can close a worker's stdio before its at_exit
+      # hooks run (rspec-conductor does). A closed stream is not a tty.
+      false
+    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

@@ -1,31 +1,78 @@
 # frozen_string_literal: true
 
+require_relative "../source_file/ruby_data_parser"
+require_relative "identity_interner"
+require_relative "interned_counts"
+
 module SimpleCov
   module Combine
     #
     # Combine different branch coverage results on single file.
     #
-    # Should be called through `SimpleCov.combine`.
+    # Should be called through `CoverageAccumulator`.
     module BranchesCombiner
     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]
       #
       def combine(coverage_a, coverage_b)
-        coverage_a.merge(coverage_b) do |_condition, branches_inside_a, branches_inside_b|
-          branches_inside_a.merge(branches_inside_b) do |_branch, a_count, b_count|
-            a_count + b_count
-          end
+        merged = absorb({}, coverage_a) #: Hash[untyped, [untyped, Hash[untyped, untyped]]]
+        materialize(absorb(merged, coverage_b))
+      end
+
+      # Folds `coverage` into `target`, an interned table keyed by condition
+      # identity. Kept interned (rather than turned back into tuple keys per
+      # merge) so a fold over N resultsets interns each condition once
+      # instead of re-interning the whole accumulated table N times.
+      #
+      # @return [Hash] `target`
+      def absorb(target, coverage)
+        return target unless coverage
+
+        coverage.each do |condition, branches_inside|
+          entry = target[identities[condition]] ||= new_condition(condition)
+          InternedCounts.absorb_counts(entry[1], branches_inside, identities)
         end
+
+        target
+      end
+
+      # Split out so the empty arm table has somewhere to carry its type
+      # annotation. Only allocated the first time a condition is seen.
+      def new_condition(condition)
+        arms = {} #: Hash[untyped, untyped]
+        [condition, arms]
+      end
+
+      # Turns an interned table back into the tuple-keyed hash the rest of
+      # SimpleCov reads. Done once, at the end of a fold.
+      #
+      # @return [Hash]
+      def materialize(target)
+        target.values.to_h { |condition, branches| [condition, branches.values.to_h] }
+      end
+
+      # Bounded by the project's branch count, like `RubyDataParser`'s parse
+      # cache.
+      def identities
+        @identities ||= IdentityInterner.build { |tuple| tuple_identity(tuple) }
+      end
+
+      # Branches match on source span, whatever ids the recording processes
+      # handed them (issue #1233).
+      def tuple_identity(tuple)
+        type, _id, start_line, start_column, end_line, end_column = SourceFile::RubyDataParser.call(tuple)
+        [type, start_line, start_column, end_line, end_column].freeze
       end
     end
   end

data/lib/simplecov/combine/coverage_accumulator.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require_relative "branches_combiner"
+require_relative "lines_combiner"
+require_relative "methods_combiner"
+
+module SimpleCov
+  module Combine
+    #
+    # Folds any number of resultsets' coverage into one, absorbing them one
+    # at a time.
+    #
+    # This replaces a pairwise `reduce` over the resultsets, which rebuilt
+    # the entire accumulated structure on every one of its N-1 steps: a
+    # fresh outer file hash, a fresh lines array for every file, and a fresh
+    # branch / method table for every file whose keys were re-interned from
+    # their tuples each time. On a 160-worker run over ~1,800 files that is
+    # ~290,000 whole-file rebuilds to produce ~1,800 files of output.
+    #
+    # The accumulated side is private to the fold, so it can be updated in
+    # place instead, and the interned tables only have to be turned back into
+    # tuple-keyed hashes once, at the end.
+    #
+    # Resultsets are absorbed one at a time rather than taken as a list, so
+    # `ResultMerger.merge_results` can keep reading and discarding them one
+    # file at a time — reading 100s of CI jobs' worth of coverage into memory
+    # at once is what that method is careful not to do.
+    #
+    class CoverageAccumulator
+      # A file some process actually loaded has at least one executed line;
+      # a simulated (never-loaded) file's lines are all `nil` or `0`. This is
+      # the signal the merge reconciles synthesized tuples on, and the one
+      # `ResultMerger` re-derives a merged result's not-loaded set from, so it
+      # lives here rather than being spelled out at each site.
+      #
+      # `Array()` plus the `Numeric` test rather than a bare
+      # `any?(&:positive?)` because this reads straight off a parsed
+      # resultset, which is external input: a file written by another
+      # SimpleCov version, or hand-edited, can carry anything under
+      # "lines" — a Hash coerces to pairs, a String to itself. Keeping a
+      # malformed entry to a wrong answer instead of a NoMethodError out
+      # of the middle of a merge is the point.
+      def self.executed?(lines)
+        counts = Array(lines) #: Array[untyped]
+        counts.any? { |count| count.is_a?(Numeric) && count.positive? }
+      end
+
+      #
+      # Folds `[command_names, coverage]` pairs into one merged coverage.
+      #
+      # `pairs` is only ever iterated, so a caller that reads resultsets off
+      # disk can hand in a lazy enumerable and never hold more than one in
+      # memory — which is what `ResultMerger.merge_results` is careful about.
+      #
+      # @return [Array] the concatenated command names and the merged coverage
+      #
+      def self.fold(pairs)
+        accumulator = new
+        command_names = [] #: Array[String]
+
+        pairs.each do |names, coverage|
+          command_names.concat(names)
+          accumulator.absorb(coverage)
+        end
+
+        [command_names, accumulator.result]
+      end
+
+      def initialize
+        @files = {} #: Hash[String, untyped]
+        @absorbed = false
+        # Whether a criterion is enabled can't change mid-fold, so read it once
+        # here rather than once per file. `branch_coverage?` reaches
+        # `Coverage.supported?`, and a large parallel run merges thousands of
+        # files.
+        @branch_coverage = SimpleCov.branch_coverage?
+        @method_coverage = SimpleCov.method_coverage?
+      end
+
+      #
+      # Folds one resultset's coverage (filename => per-file coverage) into
+      # the accumulator. A `nil` coverage is ignored — a resultset that
+      # carried nothing contributes nothing.
+      #
+      # @return [CoverageAccumulator] self, so absorbs can be chained
+      #
+      def absorb(coverage)
+        return self unless coverage
+
+        @absorbed = true
+        coverage.each do |filename, file_coverage|
+          @files[filename] = merge_file(@files[filename], file_coverage)
+        end
+
+        self
+      end
+
+      #
+      # The merged coverage, or `nil` when nothing was absorbed at all — the
+      # caller needs to tell "no results" apart from "results that cover
+      # nothing", and only the former means there is no report to build.
+      #
+      # A file only one resultset carried is returned exactly as it came in,
+      # untouched: with nothing to merge it into, copying it would only cost
+      # memory.
+      #
+      # @return [Hash, nil]
+      #
+      def result
+        return nil unless @absorbed
+
+        @files.transform_values do |entry|
+          entry.is_a?(MergedFile) ? entry.to_h : entry
+        end
+      end
+
+    private
+
+      # The first sighting of a file is kept as-is; the second promotes it to
+      # a `MergedFile` that owns its state, and every later one folds into
+      # that same object.
+      def merge_file(existing, file_coverage)
+        case existing
+        when nil then file_coverage
+        when MergedFile then existing.absorb(file_coverage)
+        else MergedFile.new(existing, branches: @branch_coverage, methods: @method_coverage).absorb(file_coverage)
+        end
+      end
+
+      #
+      # One file's accumulated coverage, against state this object owns
+      # outright rather than rebuilt for each merged pair.
+      #
+      class MergedFile
+        # A criterion is carried for this file when the data carries it, not
+        # when this process happens to measure it. A merge runs on behalf of
+        # the processes that produced the resultsets and does not necessarily
+        # share their configuration: `simplecov merge` never ran SimpleCov.start
+        # at all, and dropping a table it did not ask for would lose branch data
+        # the producers did measure. A nil table means nobody measured that
+        # criterion; an empty one means it was measured and the file has none.
+        def initialize(coverage, branches:, methods:)
+          @branch_coverage = branches
+          @method_coverage = methods
+          @lines = coverage["lines"]&.dup
+          # Branch coverage always reports a table, even an empty one, so
+          # `SourceFile` can tell "no branches in this file" from "branch
+          # coverage was off". Method coverage stays `nil` until some resultset
+          # actually carries methods.
+          @branches = BranchesCombiner.absorb({}, coverage["branches"]) if branches || coverage["branches"]
+          @methods = MethodsCombiner.absorb(nil, coverage["methods"]) if methods || coverage["methods"]
+        end
+
+        #
+        # Folds one more resultset's coverage for this file in.
+        #
+        # @return [MergedFile] self
+        #
+        def absorb(coverage)
+          reconcile_synthesized(coverage)
+          @lines = LinesCombiner.merge_into(@lines, coverage["lines"])
+          self
+        end
+
+        def to_h
+          merged = {"lines" => @lines} #: Hash[String, untyped]
+          merged["branches"] = BranchesCombiner.materialize(@branches) if @branches
+          merged["methods"] = MethodsCombiner.materialize(@methods) if @methods
+          merged
+        end
+
+      private
+
+        def new_table
+          {} #: Hash[untyped, untyped]
+        end
+
+        # When exactly one side of the merge was actually executed, its branch
+        # and method tuples are authoritative and the other side's are
+        # dropped. A simulated entry (SimulateCoverage backfills
+        # tracked-but-unloaded files) synthesizes those tuples statically, so
+        # a location that drifts from what Coverage emits would otherwise be
+        # unioned in by position and survive as a phantom, permanently-missed
+        # branch (see #1233). This contains any such drift to denominator
+        # inflation for files no process loaded, rather than a false miss on a
+        # covered file. Lines are never dropped: a simulated file's line shape
+        # is correct and carries the unloaded-file denominator (#1059).
+        #
+        # The accumulated side's executed-ness is re-read on every absorb
+        # because folding in an executed resultset can flip it, exactly as it
+        # would have flipped between two steps of the pairwise fold.
+        def reconcile_synthesized(coverage)
+          return absorb_tuples(coverage) unless judgeable?(@lines) && judgeable?(coverage["lines"])
+
+          accumulated_executed = executed?(@lines)
+          incoming_executed = executed?(coverage["lines"])
+
+          if accumulated_executed == incoming_executed
+            absorb_tuples(coverage)
+          elsif incoming_executed
+            replace_tuples(coverage)
+          else
+            drop_incoming_tuples(coverage)
+          end
+        end
+
+        # Both sides agree on whether they ran: union their tuples. A criterion
+        # only the incoming side carries comes into play here, because its
+        # tuples survive. It deliberately does not come into play on the path
+        # that drops them: promoting there would advertise an empty table
+        # sourced from data this merge just discarded, which claims the file
+        # has no branches when what is true is that nobody measured them.
+        def absorb_tuples(coverage)
+          @branches = BranchesCombiner.absorb(@branches || new_table, coverage["branches"]) if
+            @branches || coverage["branches"]
+          @methods = MethodsCombiner.absorb(@methods, coverage["methods"]) if @methods || coverage["methods"]
+        end
+
+        # Only the accumulated side ran, so the incoming tuples are synthesized
+        # and contribute nothing. When the discarded side carried a methods
+        # table, a measuring process still gets one — the empty table stands in
+        # for the blanked side, which is what a pair against a blank one used
+        # to produce for a file that has no methods yet. When no side has
+        # carried methods at all, the table stays nil (the rule `initialize`
+        # documents), the same answer the union path gives.
+        def drop_incoming_tuples(coverage)
+          @methods ||= {} if @method_coverage && coverage["methods"] #: Hash[untyped, untyped]
+        end
+
+        # Only the incoming side ran, so what's accumulated is synthesized:
+        # start its tuples over from the executed side's. The authoritative
+        # side decides which criteria the file carries, not just their tuples.
+        # Keeping a table in play that only the dropped side carried would make
+        # the answer depend on which side was seen first.
+        def replace_tuples(coverage)
+          @branches = authoritative_table(BranchesCombiner, coverage["branches"], @branch_coverage)
+          # Methods stay nil until some resultset carries them (see
+          # `initialize`), so a measuring process keeps an empty table only
+          # when one did.
+          @methods = authoritative_table(MethodsCombiner, coverage["methods"], @method_coverage && !@methods.nil?)
+        end
+
+        # The executed side's tuples when it has them. Otherwise `keep_empty`
+        # decides whether the criterion survives as an empty table, which is
+        # what keeps `SourceFile` able to tell "no branches here" from
+        # "branches were not measured".
+        def authoritative_table(combiner, table, keep_empty)
+          return combiner.absorb(new_table, table) if table
+
+          keep_empty ? new_table : nil
+        end
+
+        # Whether a side can be judged at all. Absent lines do not mean the side
+        # never ran: a branch-only or method-only run omits them even for the
+        # files it loaded, so treating that as synthesized would discard real
+        # tuples. Unknown means union, which is already what happens when
+        # neither side carries lines.
+        def judgeable?(lines)
+          !Array(lines).empty?
+        end
+
+        def executed?(lines)
+          CoverageAccumulator.executed?(lines)
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/combine/identity_interner.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Combine
+    #
+    # Builds the raw-key => interned-identity caches the tuple combiners keep.
+    #
+    # The cache maps a raw key to its interned identity on first sight and
+    # keeps it: the pairwise fold would otherwise re-derive the accumulator's
+    # identities on every one of its merges, always to the same answer.
+    #
+    # Identities exist only to be `combine`'s hash keys, and `Array#hash` is
+    # not memoized, so keying on the identity tuple itself would rehash its
+    # elements for every key of both sides of every merge. An Integer hashes
+    # as an immediate. Two keys share an id exactly when their identities are
+    # equal, so the string and array forms of one key still merge together.
+    #
+    module IdentityInterner
+    module_function
+
+      def build
+        ids = {} #: Hash[::Array[untyped], Integer]
+        Hash.new do |cache, key|
+          identity = yield(key)
+          cache[key] = ids[identity] ||= ids.size
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/combine/interned_counts.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Combine
+    # The inner merge loop the branches and methods combiners share:
+    # fold `source`'s tuple => count pairs into `target`, an interned
+    # table keyed by each tuple's merge identity and holding
+    # `[raw_key, count]` pairs. The first-seen raw key is kept for
+    # display; counts sum. `target` and its pairs are always built by
+    # this loop, so updating them in place can't reach data a caller
+    # still holds.
+    module InternedCounts
+    module_function
+
+      # @return [Hash] `target`
+      def absorb_counts(target, source, identities)
+        source.each do |key, count|
+          interned = identities[key]
+          entry = target[interned]
+          if entry
+            entry[1] += count
+          else
+            target[interned] = [key, count]
+          end
+        end
+        target
+      end
+    end
+  end
+end