simplecov 0.22.0 → 1.3.0

data/lib/simplecov/context_map.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  #
+  # Records which context covered which line: a list of context ids and, per
+  # source file, a bitmap of covered lines for each context that touched the
+  # file. A context is any labeled region of execution, and the vocabulary is
+  # deliberately the general one (coverage.py calls the same idea dynamic
+  # contexts), so the stored format doesn't bake simplecov's current use into
+  # a name.
+  #
+  # The naive shape of this data, a list of ids on every line, is
+  # O(contexts x lines) strings. Context ids are interned instead, and each
+  # context's covered lines within a file are a single Integer bitmap with bit
+  # N set when line N+1 was executed, which packs a thousand-line file into
+  # ~125 bytes and makes the union of two recordings a bitwise OR.
+  #
+  # Serialized into `.resultset.json` as `{"version" => 1, "contexts" =>
+  # [...ids...], "files" => {path => {context index => bitmap as hex}}}`. The
+  # format is tolerated, not trusted: `.from_hash` returns nil for anything
+  # malformed or future-versioned, which the merge treats the same as a map
+  # that was never recorded.
+  #
+  class ContextMap
+    # Bumped on any change an older reader could misread, so `.from_hash` can
+    # treat a future format as absent instead of answering from it wrongly.
+    VERSION = 1
+
+    def initialize
+      @contexts = [] #: Array[String]
+      @indices = {} #: Hash[String, Integer]
+      @files = {} #: Hash[String, Hash[Integer, Integer]]
+    end
+
+    # `lines_by_file` maps a source path to the bitmap of lines the context
+    # executed there. The id is interned even when the delta is empty: the
+    # context ran, and keeping it distinguishes "covered nothing of its own"
+    # from "never recorded".
+    def record(context_id, lines_by_file)
+      index = intern(context_id)
+      lines_by_file.each do |path, bitmap|
+        next if bitmap.zero?
+
+        table = (@files[path] ||= {})
+        table[index] = (table[index] || 0) | bitmap
+      end
+      self
+    end
+
+    # Sorted for stable output, since recording order varies between runs and
+    # merges. The path is resolved against `SimpleCov.root`, so callers can
+    # pass either an absolute or a project-relative one.
+    #
+    # A line number below 1 needs no guard of its own: it shifts the probe bit
+    # right off the end of the bitmap, leaving a mask no line can match.
+    def covering(path, line)
+      table = @files[File.expand_path(path, SimpleCov.root)]
+      return [] unless table
+
+      bit = 1 << (line - 1)
+      table.filter_map { |index, bitmap| @contexts.fetch(index) if bitmap.anybits?(bit) }.sort
+    end
+
+    def contexts
+      @contexts.dup
+    end
+
+    def empty?
+      @contexts.empty?
+    end
+
+    # Other's contexts are re-interned, so maps recorded by different processes
+    # merge by id, and a context both sides saw contributes one entry.
+    def absorb(other)
+      remap = other.interned_contexts.map { |context_id| intern(context_id) }
+      other.file_tables.each do |path, table|
+        target = (@files[path] ||= {})
+        table.each do |index, bitmap|
+          key = remap.fetch(index)
+          target[key] = (target[key] || 0) | bitmap
+        end
+      end
+      self
+    end
+
+    # `only:` restricts the files to a given set of paths, so the map follows
+    # the same universe as the coverage it sits beside. The context list is
+    # never restricted: which contexts ran is true regardless of which files
+    # survived filtering.
+    def to_h(only: nil)
+      # Selected rather than sliced: `only` is a Set, and splatting one into
+      # `slice` is a call `to_a` answers for, which makes dropping the `to_a` a
+      # mutation nothing can observe.
+      tables = only ? @files.select { |path, _table| only.include?(path) } : @files # rubocop:disable Style/HashSlice
+      serialized = tables.transform_values { |table| serialize_table(table) }
+      {"version" => VERSION, "contexts" => @contexts.dup, "files" => serialized}
+    end
+
+    # Index string => hex bitmap, the wire encoding `to_h` writes.
+    # coverage.json shares the resultset's encoding through this, so the format
+    # has one owner.
+    def serialized_bitmaps_for(path)
+      serialize_table(@files[File.expand_path(path, SimpleCov.root)] || {})
+    end
+
+    # @api private
+    def intern(context_id)
+      @indices[context_id] ||= begin
+        @contexts << context_id
+        @contexts.size - 1
+      end
+    end
+
+    class << self
+      # nil when the data is not a well-formed map of this format version.
+      # All-or-nothing on purpose: a partially salvaged map would answer
+      # `covering` queries with silent gaps, and the merge already drops an
+      # absent map consistently.
+      def from_hash(data)
+        # `eql?` rather than `==`: a version written as 1.0 is not this format,
+        # and reading it as if it were is what the version gate exists to stop.
+        return nil unless data.instance_of?(Hash) && data["version"].eql?(VERSION)
+
+        contexts = data["contexts"]
+        files = data["files"]
+        return nil unless contexts.instance_of?(Array) && contexts.all?(String) && files.instance_of?(Hash)
+
+        build(contexts, files)
+      end
+
+      private
+
+      def build(contexts, files)
+        map = new
+        contexts.each { |context_id| map.intern(context_id) }
+        files.each do |path, table|
+          return nil unless path.instance_of?(String) && table.instance_of?(Hash)
+          return nil unless absorb_table(map, contexts, path, table)
+        end
+        map
+      end
+
+      def absorb_table(map, contexts, path, table)
+        table.all? do |index, encoded|
+          position = parse_index(index, contexts.size)
+          bitmap = parse_bitmap(encoded)
+          map.record(contexts.fetch(position), path => bitmap) if position && bitmap
+        end
+      end
+
+      # A serialized context index is a decimal string pointing into the entry's
+      # own context list. An out-of-range one makes the whole map malformed.
+      def parse_index(index, size)
+        return nil unless index.instance_of?(String) && index.match?(/\A\d+\z/)
+
+        value = index.to_i
+        value if value < size
+      end
+
+      def parse_bitmap(encoded)
+        return nil unless encoded.instance_of?(String) && encoded.match?(/\A\h+\z/)
+
+        encoded.to_i(16)
+      end
+    end
+
+    private
+
+    # Sorted by index: recording and merge order vary run to run, and a
+    # deterministic serialization keeps stored resultsets diffable.
+    def serialize_table(table)
+      table.sort.to_h { |index, bitmap| [index.to_s, bitmap.to_s(16)] }
+    end
+
+    protected
+
+    # Live state, not copies, which is why these are protected rather than
+    # public.
+    def interned_contexts
+      @contexts
+    end
+
+    def file_tables
+      @files
+    end
+  end
+end

data/lib/simplecov/coverage_json.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SimpleCov
+  module CoverageJSON
+    class Error < StandardError; end
+
+    def self.load(path)
+      source = File.binread(path).force_encoding(Encoding::UTF_8)
+      raise Error, "input is not valid UTF-8" unless source.valid_encoding?
+
+      document = JSON.parse(source)
+      return document if document.instance_of?(Hash)
+
+      raise Error, "top-level value must be an object"
+    rescue JSON::ParserError => e
+      raise Error, e
+    end
+  end
+end

data/lib/simplecov/coverage_statistics.rb

@@ -1,45 +1,41 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  # Holds the individual data of a coverage result.
-  #
-  # This is uniform across coverage criteria as they all have:
-  #
-  # * total - how many things to cover there are (total relevant loc/branches)
-  # * covered - how many of the coverables are hit
-  # * missed - how many of the coverables are missed
-  # * percent - percentage as covered/missed
-  # * strength - average hits per/coverable (will not exist for one shot lines format)
+  # One coverage criterion's numbers, uniform across criteria: total, covered,
+  # missed, omitted (only meaningful for line coverage), percent, and strength,
+  # the average hits per coverable unit, which the oneshot-lines format has no
+  # way to produce.
   class CoverageStatistics
-    attr_reader :total, :covered, :missed, :strength, :percent
+    attr_reader :total, :covered, :missed, :omitted, :strength, :percent
 
+    ZERO_STATS = [0, 0, 0, 0.0].freeze #: [Integer, Integer, Integer, Float]
+
+    # Strength is remultiplied by loc because files have different strengths and
+    # line counts, giving them a different weight in the total.
     def self.from(coverage_statistics)
-      sum_covered, sum_missed, sum_total_strength =
-        coverage_statistics.reduce([0, 0, 0.0]) do |(covered, missed, total_strength), file_coverage_statistics|
+      sum_covered, sum_missed, sum_omitted, sum_total_strength =
+        coverage_statistics.reduce(ZERO_STATS) do |(covered, missed, omitted, total_strength), stats|
           [
-            covered + file_coverage_statistics.covered,
-            missed + file_coverage_statistics.missed,
-            # gotta remultiply with loc because files have different strength and loc
-            # giving them a different "weight" in total
-            total_strength + (file_coverage_statistics.strength * file_coverage_statistics.total)
+            covered + stats.covered,
+            missed + stats.missed,
+            omitted + stats.omitted,
+            total_strength + (stats.strength * stats.total)
           ]
         end
 
-      new(covered: sum_covered, missed: sum_missed, total_strength: sum_total_strength)
+      new(covered: sum_covered, missed: sum_missed, omitted: sum_omitted, total_strength: sum_total_strength)
     end
 
-    # Requires only covered, missed and strength to be initialized.
-    #
-    # Other values are computed by this class.
-    def initialize(covered:, missed:, total_strength: 0.0)
-      @covered  = covered
-      @missed   = missed
-      @total    = covered + missed
-      @percent  = compute_percent(covered, missed, total)
+    def initialize(covered:, missed:, omitted: 0, total_strength: 0, percent: nil)
+      @covered = covered
+      @missed = missed
+      @omitted = omitted
+      @total = covered + missed
+      @percent = percent || compute_percent(covered, missed, total)
       @strength = compute_strength(total_strength, total)
     end
 
-  private
+    private
 
     def compute_percent(covered, missed, total)
       return 100.0 if missed.zero?
@@ -50,7 +46,7 @@ module SimpleCov
     def compute_strength(total_strength, total)
       return 0.0 if total.zero?
 
-      total_strength.to_f / total
+      total_strength.fdiv(total)
     end
   end
 end

data/lib/simplecov/coverage_violations.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module CoverageViolations
+    class << self
+      def minimum_overall(result, thresholds)
+        thresholds.filter_map do |criterion, expected|
+          actual = floored_percent_for(result, criterion) or next
+          {criterion: criterion, expected: expected, actual: actual} if actual < expected
+        end
+      end
+
+      # An actual of 95.4287 floors to 95.42, so a maximum of 95.42 passes
+      # (#187).
+      def maximum_overall(result, thresholds)
+        thresholds.filter_map do |criterion, expected|
+          actual = floored_percent_for(result, criterion) or next
+          {criterion: criterion, expected: expected, actual: actual} if actual > expected
+        end
+      end
+
+      # A file and criterion with a `baseline` floor is exempt here: the baseline
+      # check holds it to its own floor instead, which is the fall-through the
+      # ratchet workflow rests on (#1268).
+      def minimum_by_file(result, defaults, overrides = {}, baseline: nil)
+        result.files.flat_map do |file|
+          effective = effective_per_file_thresholds(file, defaults, overrides)
+          effective.filter_map do |criterion, expected|
+            next if baseline&.covers?(file.project_filename, criterion)
+
+            file_minimum_violation(file, criterion, expected)
+          end
+        end
+      end
+
+      # A baseline violation needs the file below its floor on both axes: a
+      # percent under the floor's, and (when the floor records one) more misses
+      # than it allows. The missed count is what keeps percent movement from
+      # pure edits out of the answer.
+      def baseline(result, baseline)
+        return [] unless baseline
+
+        result.files.flat_map do |file|
+          entry = baseline.entry_for(file.project_filename)
+          next [] unless entry
+
+          entry.filter_map { |criterion, floor| baseline_violation(file, criterion, floor) }
+        end
+      end
+
+      def maximum_missed(result, caps)
+        caps.filter_map do |criterion, maximum|
+          actual = missed_for(result, criterion) or next
+          {criterion: criterion, maximum: maximum, actual: actual} if actual > maximum
+        end
+      end
+
+      def maximum_missed_by_file(result, defaults, overrides = {}, baseline: nil)
+        result.files.flat_map do |file|
+          effective = effective_per_file_thresholds(file, defaults, overrides)
+          effective.filter_map do |criterion, maximum|
+            next if baseline&.covers?(file.project_filename, criterion)
+
+            file_missed_cap_violation(file, criterion, maximum)
+          end
+        end
+      end
+
+      def minimum_by_group(result, thresholds)
+        thresholds.flat_map do |group_name, minimums|
+          group = lookup_group(result, group_name)
+          none = [] # : Array[Hash[Symbol, untyped]]
+          group ? group_minimum_violations(group_name, group, minimums) : none
+        end
+      end
+
+      def maximum_drop(result, thresholds, last_run: nil, mode: SimpleCov.drop_baseline)
+        baseline = drop_baseline_percents(mode, last_run)
+        return [] unless baseline
+
+        thresholds.filter_map do |criterion, maximum|
+          actual = compute_drop(criterion, result, baseline)
+          {criterion: criterion, maximum: maximum, actual: actual} if actual && actual > maximum
+        end
+      end
+
+      private
+
+      # Answers nil, and the caller silently skips, when the criterion was
+      # configured but not measured by the runtime (`branch: 100` under the
+      # "strict" profile on JRuby, say). The config-time
+      # `raise_if_criterion_disabled` check catches the genuine mistake earlier.
+      def floored_percent_for(stats_source, criterion)
+        stats = stats_source.coverage_statistics[SimpleCov.coverage_statistics_key(criterion)]
+        round(stats.percent) if stats
+      end
+
+      def effective_per_file_thresholds(file, defaults, overrides)
+        path = file.project_filename
+        overrides.reduce(defaults) do |acc, (pattern, criterion_thresholds)|
+          path_matches?(path, pattern) ? acc.merge(criterion_thresholds) : acc
+        end
+      end
+
+      # `==` and `eql?` are indistinguishable for the String operands, so that
+      # mutation is equivalent. The override examples pin every arm instead.
+      # mutant:disable
+      # mutant:disable
+      def path_matches?(project_filename, pattern)
+        return project_filename.match?(pattern) if pattern.is_a?(Regexp)
+        return project_filename.start_with?(pattern) if pattern.end_with?("/")
+
+        project_filename == pattern
+      end
+
+      def missed_for(stats_source, criterion)
+        stats = stats_source.coverage_statistics[SimpleCov.coverage_statistics_key(criterion)]
+        stats&.missed
+      end
+
+      def file_missed_cap_violation(file, criterion, maximum)
+        actual = missed_for(file, criterion) or return
+        return unless actual > maximum
+
+        {criterion: criterion, maximum: maximum, actual: actual,
+         filename: file.filename, project_filename: file.project_filename}
+      end
+
+      def baseline_violation(file, criterion, floor)
+        stats = file.coverage_statistics[SimpleCov.coverage_statistics_key(criterion)]
+        return unless stats
+
+        actual = round(stats.percent)
+        return unless actual < floor.percent
+        return if floor.missed && stats.missed <= floor.missed
+
+        {criterion: criterion, expected: floor.percent, allowed_missed: floor.missed, actual: actual,
+         actual_missed: stats.missed, filename: file.filename, project_filename: file.project_filename}
+      end
+
+      def file_minimum_violation(file, criterion, expected)
+        actual = floored_percent_for(file, criterion) or return
+        return unless actual < expected
+
+        {
+          criterion: criterion,
+          expected: expected,
+          actual: actual,
+          filename: file.filename,
+          project_filename: file.project_filename
+        }
+      end
+
+      def group_minimum_violations(group_name, group, minimums)
+        minimums.filter_map do |criterion, expected|
+          actual = floored_percent_for(group, criterion) or next
+          {group_name: group_name, criterion: criterion, expected: expected, actual: actual} if actual < expected
+        end
+      end
+
+      # The misconfiguration notice is enforcement output, not a Ruby warning: it
+      # must survive `-W0` and `Warning.warn` hooks, and honor `print_errors`. A
+      # configured group that matched no files is absent from `result.groups`
+      # too, but has nothing to gate rather than nothing to look up.
+      def lookup_group(result, group_name)
+        group = result.groups[group_name]
+        if group.nil? && SimpleCov.print_errors && !result.configured_group?(group_name)
+          ExitCodes.print_error "minimum_coverage_by_group: no group named '#{group_name}' exists. " \
+                                "Available groups: #{result.groups.keys.join(", ")}"
+        end
+        group
+      end
+
+      def drop_baseline_percents(mode, last_run)
+        case mode
+        when :median then median_baseline
+        when :branch then branch_baseline
+        else last_run_baseline(last_run || LastRun.read)
+        end
+      end
+
+      # A hand-edited .last_run.json can carry any value type, and `LastRun.read`
+      # only vouches for the top level being a Hash. `:covered_percent` is the
+      # pre-criteria file format's spelling of the line percent.
+      def last_run_baseline(last_run)
+        return nil unless last_run.is_a?(Hash)
+
+        previous = (_ = last_run)[:result]
+        return nil unless previous.is_a?(Hash)
+
+        previous = _ = previous
+        {line: previous[:line] || previous[:covered_percent],
+         branch: previous[:branch], method: previous[:method]}
+      end
+
+      def median_baseline
+        totals = history_totals
+        baseline = {} #: Hash[Symbol, untyped]
+        %i[line branch method].each do |criterion|
+          values = totals.map { |entry| entry[criterion.to_s] }.grep(Numeric)
+          baseline[criterion] = median(values) unless values.empty?
+        end
+        baseline
+      end
+
+      def history_totals
+        History.read.filter_map do |entry|
+          entry.fetch("totals") if entry.is_a?(Hash) && entry["totals"].is_a?(Hash)
+        end
+      end
+
+      def median(values)
+        sorted = values.sort
+        mid = sorted.length / 2
+        sorted.length.odd? ? sorted.fetch(mid) : (sorted.fetch(mid - 1) + sorted.fetch(mid)).fdiv(2)
+      end
+
+      def branch_baseline
+        branch, = History.git_info
+        return nil unless branch
+
+        entry = History.read.reverse_each.find { |candidate| branch_entry?(candidate, branch) }
+        return nil unless entry
+
+        totals = {} #: Hash[Symbol, untyped]
+        entry.fetch("totals").each { |key, value| totals[key.to_sym] = value }
+        totals
+      end
+
+      # `==` and `eql?` are indistinguishable for the String operands, so that
+      # mutation is equivalent. The branch-baseline examples pin every clause.
+      # mutant:disable
+      # mutant:disable
+      def branch_entry?(candidate, branch)
+        candidate.is_a?(Hash) && candidate["branch"] == branch && candidate["totals"].is_a?(Hash)
+      end
+
+      def compute_drop(criterion, result, baseline)
+        stats_key = SimpleCov.coverage_statistics_key(criterion)
+        last_coverage_percent = baseline[stats_key]
+        # Treat a non-numeric percent like a missing one instead of
+        # raising out of the at_exit hook.
+        return unless last_coverage_percent.is_a?(Numeric)
+
+        current = floored_percent_for(result, criterion) or return
+        (last_coverage_percent - current).floor(10)
+      end
+
+      def round(percent)
+        SimpleCov.round_coverage(percent)
+      end
+    end
+  end
+end

data/lib/simplecov/current_run.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # The state one measured run accumulates in one process: the pid and start
+  # time that identify it, the result it computes, the flags the merge
+  # coordination reads, and the serial the parent hands each forked
+  # subprocess. A new run is a new object, which is what lets anything needing
+  # a clean slate begin one instead of unsetting state by hand.
+  class CurrentRun
+    attr_accessor :pid, :process_start_time, :result
+    attr_writer :collating_result
+
+    # The result, the coordination flags and the identity belong to the run that
+    # ends; the fork genealogy belongs to the process and carries over. A child
+    # that restarts tracking must not forget it was forked, or it would produce
+    # the final report itself, and a parent must not recount from zero, or its
+    # next children's names would collide with its first ones (#1171).
+    def successor
+      following = self.class.new
+      following.subprocess_serial = @subprocess_serial
+      following.mark_forked_subprocess! if forked_subprocess?
+      following
+    end
+
+    # Answers exactly false while no result was ever stored, which is how "never
+    # computed" stays distinct from "cleared to nil".
+    def result?
+      instance_variable_defined?(:@result) && (_ = @result)
+    end
+
+    def collating_result?
+      !!@collating_result
+    end
+
+    # Reading a mark that was never set answers nil, which is the answer wanted.
+    def forked_subprocess?
+      !!@forked_subprocess
+    end
+
+    def mark_forked_subprocess!
+      @forked_subprocess = true
+    end
+
+    # A monotonically increasing serial the parent assigns to each forked
+    # subprocess. The default `at_fork` builds the worker's command_name from
+    # this rather than the OS pid: the serial sequence is the same from one run
+    # to the next, so a re-run overwrites the previous run's resultset entries
+    # instead of writing uniquely-named ones that pile up (#1171).
+    def subprocess_serial
+      @subprocess_serial ||= 0
+    end
+
+    def next_subprocess_serial!
+      @subprocess_serial = subprocess_serial + 1
+    end
+
+    protected
+
+    attr_writer :subprocess_serial
+  end
+end

data/lib/simplecov/defaults.rb

@@ -1,53 +1,45 @@
 # frozen_string_literal: true
 
-# Load default formatter gem
+require "English"
 require "pathname"
-require_relative "default_formatter"
-require_relative "profiles/root_filter"
-require_relative "profiles/test_frameworks"
-require_relative "profiles/bundler_filter"
-require_relative "profiles/hidden_filter"
-require_relative "profiles/rails"
+require_relative "formatter/html_formatter"
 
-# Default configuration
 SimpleCov.configure do
-  formatter SimpleCov::Formatter::MultiFormatter.new(
-    SimpleCov::Formatter.from_env(ENV)
-  )
+  formatter SimpleCov::Formatter::HTMLFormatter
 
   load_profile "bundler_filter"
   load_profile "hidden_filter"
-  # Exclude files outside of SimpleCov.root
   load_profile "root_filter"
+  load_profile "test_frameworks"
 end
 
-# Gotta stash this a-s-a-p, see the CommandGuesser class and i.e. #110 for further info
-SimpleCov::CommandGuesser.original_run_command = "#{$PROGRAM_NAME} #{ARGV.join(' ')}"
+# Stashed as early as possible, before rake or test/unit tamper with ARGV
+# (#110). The program name is kept separately as well: the join is lossy for
+# a path containing a space, and the guesser reads the executable from it.
+SimpleCov::CommandGuesser.original_run_command = "#{$PROGRAM_NAME} #{ARGV.join(" ")}"
+SimpleCov::CommandGuesser.original_program_name = $PROGRAM_NAME
 
-at_exit do
-  next if SimpleCov.external_at_exit?
-
-  SimpleCov.at_exit_behavior
-end
-
-# Autoload config from ~/.simplecov if present
 require_relative "load_global_config"
 
-# Autoload config from .simplecov if present
-# Recurse upwards until we find .simplecov or reach the root directory
-
 config_path = Pathname.new(SimpleCov.root)
 loop do
   filename = config_path.join(".simplecov")
   if filename.exist?
-    begin
-      load filename
-    rescue LoadError, StandardError
+    SimpleCov.with_dot_simplecov_autoload do
+      load filename.to_s
+    rescue LoadError, StandardError => e
+      # simplecov:disable — only fires when .simplecov is unreadable
+      # or raises during load
       warn "Warning: Error occurred while trying to load #{filename}. " \
-        "Error message: #{$!.message}"
+           "Error message: #{e.message}"
+      # simplecov:enable
     end
     break
   end
+  # simplecov:disable — only fires when no .simplecov is found up to
+  # the filesystem root; simplecov's own dogfood run finds the repo's
+  # .simplecov on the first iteration and breaks before getting here.
   config_path, = config_path.split
   break if config_path.root?
+  # simplecov:enable
 end