simplecov 1.1.0 → 1.2.0

data/lib/simplecov/configuration/merging.rb

@@ -1,80 +1,93 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  # Result merging and subprocess / parallel-test coordination:
-  # `merging`, `merge_subprocesses`, `merge_timeout`, `parallel_tests`.
   module Configuration
     #
-    # Get or set whether SimpleCov should hook `Process._fork` to
-    # attach itself to subprocesses. Required when the suite uses
-    # parallel test workers (e.g. Rails' `parallelize(workers:)`).
-    # Defaults to false.
+    # Whether SimpleCov should hook `Process._fork` to attach itself to
+    # subprocesses. Required when the suite uses parallel test workers (Rails'
+    # `parallelize(workers:)`). Defaults to false.
     #
     def merge_subprocesses(value = nil)
-      return @enable_for_subprocesses if defined?(@enable_for_subprocesses) && value.nil?
+      return @enable_for_subprocesses if instance_variable_defined?(:@enable_for_subprocesses) && value.nil?
 
+      self.merge_subprocesses = value
+      @enable_for_subprocesses
+    end
+
+    # false stands in for nothing, so the answer is always a real opt-in or
+    # opt-out.
+    def merge_subprocesses=(value)
       @enable_for_subprocesses = value || false
     end
 
-    # @api private — predicate used by `start_tracking` to decide
-    # whether to install the fork hook.
+    # @api private
     def enabled_for_subprocesses?
-      defined?(@enable_for_subprocesses) ? @enable_for_subprocesses : false
+      !!@enable_for_subprocesses
     end
 
     #
-    # Get or set whether SimpleCov should auto-require the
-    # `parallel_tests` gem when it sees `TEST_ENV_NUMBER` /
-    # `PARALLEL_TEST_GROUPS` in the environment. Defaults to auto-detect
-    # (nil). See #1018.
+    # Whether SimpleCov should auto-require the `parallel_tests` gem when it
+    # sees `TEST_ENV_NUMBER` / `PARALLEL_TEST_GROUPS` in the environment.
+    # Defaults to auto-detect (nil). See #1018.
     #
     def parallel_tests(value = :__no_arg__)
-      return defined?(@parallel_tests) ? @parallel_tests : nil if value == :__no_arg__
+      return @parallel_tests if value.eql?(:__no_arg__)
+
+      self.parallel_tests = _ = value
+    end
 
+    def parallel_tests=(value)
       @parallel_tests = value
     end
 
-    # DEPRECATED: alias for `merge_subprocesses`. Same value/behavior.
     def enable_for_subprocesses(value = nil)
-      SimpleCov::Deprecation.warn("`SimpleCov.enable_for_subprocesses` is deprecated. " \
-                                  "Replace with `SimpleCov.merge_subprocesses` (same value, same behavior).")
+      Deprecation.warn("`SimpleCov.enable_for_subprocesses` is deprecated. " \
+                       "Replace with `SimpleCov.merge_subprocesses` (same value, same behavior).")
       merge_subprocesses(value)
     end
 
-    #
-    # Get or set whether to merge results from multiple test suites
-    # (test:units, test:functionals, cucumber, ...) into a single
-    # coverage report. Defaults to true.
-    #
     def merging(use = nil)
-      @use_merging = use unless use.nil?
-      @use_merging = true unless defined?(@use_merging) && @use_merging == false
+      self.merging = use unless use.nil?
+      # Unset reads as nil, and only an explicit `merging false` turns it off.
+      @use_merging = true if @use_merging.nil?
       @use_merging
     end
 
+    def merging=(use)
+      @use_merging = use
+    end
+
     #
-    # Get or set whether SimpleCov's selected final process owns merge processing:
-    # waiting for sibling workers, building the merged result, formatting,
-    # enforcing thresholds, and writing `.last_run.json`.
+    # Whether SimpleCov's selected final process owns merge processing: waiting
+    # for sibling workers, building the merged result, formatting, enforcing
+    # thresholds, and writing `.last_run.json`.
     #
-    # Defaults to true, except for recognized multi-worker parallel runs
-    # that explicitly write to a custom coverage destination while merging
-    # is enabled. Those runs are likely using an external `SimpleCov.collate`
-    # step to finalize the merge.
+    # Defaults to true, except for recognized multi-worker parallel runs that
+    # explicitly write to a custom coverage destination while merging is
+    # enabled. Those runs are likely using an external `SimpleCov.collate` step
+    # to finalize the merge.
     #
-    def finalize_merge(value = :__no_arg__)
-      unless value == :__no_arg__
-        @finalize_merge = value
-        @finalize_merge_explicit = true
+    # Splatted rather than defaulted: false is a value someone sets on purpose,
+    # so "given nothing" cannot be told from it by looking at the argument.
+    def finalize_merge(*value)
+      unless value.empty?
+        explicit, = value
+        self.finalize_merge = _ = explicit
       end
 
-      return @finalize_merge if defined?(@finalize_merge_explicit) && @finalize_merge_explicit
+      return @finalize_merge if @finalize_merge_explicit
 
       inferred = inferred_finalize_merge?
       warn_about_inferred_finalize_merge unless inferred
       inferred
     end
 
+    # Writing is what makes the answer explicit rather than inferred.
+    def finalize_merge=(value)
+      @finalize_merge = value
+      @finalize_merge_explicit = true
+    end
+
     def finalize_merge?
       finalize_merge
     end
@@ -84,45 +97,65 @@ module SimpleCov
       collating_result? || (finalize_merge? && final_result_process?)
     end
 
-    # DEPRECATED: alias for `merging`. Same value, same behavior.
-    # Delegating (rather than duplicating the body) also fixes the
-    # return value: this used to return nil where `merging` returns
-    # false, because the final expression was the skipped guard
-    # assignment rather than the stored value.
     def use_merging(use = nil)
-      SimpleCov::Deprecation.warn("`SimpleCov.use_merging` is deprecated. " \
-                                  "Replace with `SimpleCov.merging` (same value, same behavior).")
+      Deprecation.warn("`SimpleCov.use_merging` is deprecated. " \
+                       "Replace with `SimpleCov.merging` (same value, same behavior).")
       merging(use)
     end
 
     #
-    # Defines the maximum age (in seconds) of a resultset to still be
-    # included in merged results. Default is 600 seconds (10 minutes).
+    # The maximum age (in seconds) of a resultset to still be included in
+    # merged results. Default is 600 seconds.
+    #
+    # A numeric SIMPLECOV_MERGE_TIMEOUT in the environment takes precedence
+    # over the configured value: `simplecov watch` re-runs test subsets across
+    # a long session and extends its child runs' merge window this way, where
+    # editing every watched project's configuration is not an option.
     #
     def merge_timeout(seconds = nil)
-      @merge_timeout = seconds if seconds.is_a?(Integer)
-      @merge_timeout ||= 600
+      self.merge_timeout = seconds
+      # Memoized through a local rather than `|| (@merge_timeout ||= 600)`:
+      # steep 2.0's logic-type interpreter crashes on an or-assignment nested in
+      # a logical operand, and ivar narrowing doesn't carry across statements
+      # the way a local's does.
+      configured = @merge_timeout || 600
+      @merge_timeout = configured
+      env_merge_timeout || configured
+    end
+
+    # Anything but an Integer is ignored, the way the dual method always did.
+    def merge_timeout=(seconds)
+      @merge_timeout = seconds if seconds.instance_of?(Integer)
+    end
+
+    def env_merge_timeout
+      value = ENV.fetch("SIMPLECOV_MERGE_TIMEOUT", nil)
+      Integer(value, 10) if value&.match?(/\A\d+\z/)
     end
 
     #
-    # Defines how long (in seconds) the reporting process waits for the
-    # remaining parallel-test workers to write their resultsets before it
-    # proceeds with a partial merge. Default is 60 seconds. Raise it when a
-    # slow worker routinely finishes well after the others, so its coverage
-    # is still included and the minimum / maximum coverage checks aren't
-    # skipped against a partial total.
+    # How long (in seconds) the reporting process waits for the remaining
+    # parallel-test workers to write their resultsets before it proceeds with a
+    # partial merge. Default is 60 seconds. Raise it when a slow worker
+    # routinely finishes well after the others, so its coverage is still
+    # included and the threshold checks aren't skipped against a partial total.
     #
     def parallel_wait_timeout(seconds = nil)
-      @parallel_wait_timeout = seconds if seconds.is_a?(Integer)
+      self.parallel_wait_timeout = seconds
       @parallel_wait_timeout ||= 60
     end
 
-  private
+    # Anything but an Integer is ignored, the way the dual method always did.
+    def parallel_wait_timeout=(seconds)
+      @parallel_wait_timeout = seconds if seconds.instance_of?(Integer)
+    end
+
+    private
 
     def inferred_finalize_merge?
       return true unless merging
 
-      adapter = SimpleCov::ParallelAdapters.current
+      adapter = ParallelAdapters.current
       return true unless adapter
       return true unless adapter.expected_worker_count > 1
       return true unless parallel_worker_environment?
@@ -138,20 +171,19 @@ module SimpleCov
     def explicit_custom_coverage_destination?
       return false unless explicit_coverage_destination?
 
-      coverage_path != File.expand_path("coverage", root)
+      !coverage_path.eql?(File.expand_path("coverage", root))
     end
 
     def explicit_coverage_destination?
-      (defined?(@coverage_path_explicit) && @coverage_path_explicit) ||
-        (defined?(@coverage_dir_explicit) && @coverage_dir_explicit)
+      @coverage_path_explicit || @coverage_dir_explicit
     end
 
     def warn_about_inferred_finalize_merge
-      return if defined?(@finalize_merge_inference_warned) && @finalize_merge_inference_warned
+      return if @finalize_merge_inference_warned
       return unless print_errors
 
       @finalize_merge_inference_warned = true
-      warn SimpleCov::Color.colorize(inferred_finalize_merge_warning, :yellow)
+      warn Color.colorize(inferred_finalize_merge_warning, :yellow)
     end
 
     def inferred_finalize_merge_warning

data/lib/simplecov/configuration/missed_caps.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Configuration
+    # Caps the total number of misses per criterion. Where a percent minimum
+    # asks for a ratio, this asks for an absolute burn-down number, which stays
+    # meaningful as the codebase grows and shrinks.
+    def maximum_missed(counts = nil)
+      return @maximum_missed ||= {} unless counts
+
+      @maximum_missed = normalized_missed_caps(counts, "maximum_missed")
+    end
+
+    # Unlike a percent minimum, which systematically flatters big files, this
+    # holds every file to the same absolute budget. Files with a baseline entry
+    # are exempt per covered criterion, as they are from the per-file minimum.
+    def maximum_missed_per_file(counts = nil)
+      return @maximum_missed_per_file ||= {} unless counts
+
+      Deprecation.warn("`SimpleCov.maximum_missed_per_file` is deprecated. " \
+                       "Replace it with:\n#{missed_per_file_replacement(counts)}")
+      @maximum_missed_per_file = normalized_missed_caps(counts, "maximum_missed_per_file")
+    end
+
+    def maximum_missed_per_file_overrides
+      @maximum_missed_per_file_overrides ||= {}
+    end
+
+    private
+
+    def normalized_missed_caps(counts, setting)
+      counts = {primary_coverage => counts} if counts.is_a?(Numeric)
+      counts.each_key { |criterion| raise_if_criterion_disabled(criterion) }
+      counts.each_value { |cap| raise_on_invalid_missed_cap(cap, setting) }
+      _ = counts
+    end
+
+    def raise_on_invalid_missed_cap(cap, setting)
+      return if cap.instance_of?(Integer) && cap >= 0
+
+      raise ConfigurationError,
+        "#{setting} takes a non-negative integer count of misses, got #{cap.inspect}"
+    end
+
+    def missed_per_file_replacement(counts)
+      counts = {primary_coverage => counts} if counts.is_a?(Numeric)
+      counts.map { |criterion, cap| "  coverage(#{criterion.inspect}) { maximum_missed #{cap}, per: :file }" }
+        .join("\n")
+    end
+  end
+end

data/lib/simplecov/configuration/production.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Configuration
+    # The path to a production coverage store, the file a `SimpleCov::Production`
+    # sink wrote. Relative paths resolve against `SimpleCov.root`. The store is
+    # read at report time, and an unreadable or invalid file warns and leaves the
+    # section out, because a missing night's data should not fail the suite that
+    # measured the tests.
+    def production_coverage(path = nil)
+      return @production_coverage if path.nil?
+
+      self.production_coverage = path
+      @production_coverage
+    end
+
+    def production_coverage=(path)
+      raise ConfigurationError, "production_coverage takes a path, got #{path.inspect}" unless path.is_a?(String)
+
+      @production_coverage = File.expand_path(path, root)
+    end
+  end
+end

data/lib/simplecov/configuration/test_tracking.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Configuration
+    TRACK_TESTS_GRANULARITIES = %i[test file].freeze
+
+    # Enables recording of which test covered which line. Off by default:
+    # sampling coverage around every test costs run time, and the recorded map
+    # costs space in `.resultset.json`. RSpec examples and Minitest tests are
+    # wrapped automatically; other runners wrap their own units of work with
+    # `SimpleCov.track_test`. A bare `track_tests` enables, and only an explicit
+    # `track_tests false` turns it back off.
+    #
+    # `granularity` decides what one recorded context stands for: a test
+    # (`:test`, the default) or a whole test file (`:file`). File granularity is
+    # the batching lever for suites where per-test sampling costs too much.
+    def track_tests(enabled = nil, granularity: nil)
+      if granularity && !TRACK_TESTS_GRANULARITIES.include?(granularity)
+        raise ConfigurationError,
+          "Unsupported track_tests granularity #{granularity.inspect}, " \
+          "supported values are #{TRACK_TESTS_GRANULARITIES.inspect}"
+      end
+
+      @track_tests_granularity = granularity if granularity
+      @track_tests = enabled.nil? || enabled
+    end
+
+    def track_tests?
+      !!@track_tests
+    end
+
+    def track_tests_granularity
+      @track_tests_granularity || :test
+    end
+
+    # @api private. The map is built from per-line execution count deltas, which
+    # `:oneshot_line` does not produce: a line reports only its first hit ever,
+    # so every test after the first would show no delta.
+    def validate_test_tracking!
+      return unless track_tests?
+      return if coverage_criterion_enabled?(DEFAULT_COVERAGE_CRITERION)
+
+      raise ConfigurationError,
+        "`track_tests` needs line coverage with execution counts. " \
+        "Enable it with `enable_coverage :line` (`:oneshot_line` cannot record per-test data)."
+    end
+  end
+end

data/lib/simplecov/configuration/thresholds.rb

@@ -1,16 +1,7 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  # Coverage threshold configuration: `minimum_coverage`,
-  # `maximum_coverage`, `expected_coverage`, `maximum_coverage_drop`,
-  # `minimum_coverage_by_file`, `minimum_coverage_by_group`,
-  # `refuse_coverage_drop`, and friends.
   module Configuration
-    #
-    # Defines the minimum overall coverage required for the testsuite to pass.
-    # Returns non-zero if the current coverage is below this threshold.
-    # Default is 0% (disabled).
-    #
     def minimum_coverage(coverage = nil)
       return @minimum_coverage ||= {} unless coverage
 
@@ -25,10 +16,10 @@ module SimpleCov
     end
 
     #
-    # Defines the maximum overall coverage allowed for the testsuite to
-    # pass. Useful paired with `minimum_coverage` (or via
-    # `expected_coverage`) to pin coverage to an exact value, so an
-    # unexpected jump up fails the build. See #187.
+    # The maximum overall coverage allowed for the testsuite to pass. Useful
+    # paired with `minimum_coverage` (or via `expected_coverage`) to pin
+    # coverage to an exact value, so an unexpected jump up fails the build
+    # (#187).
     #
     def maximum_coverage(coverage = nil)
       return @maximum_coverage ||= {} unless coverage
@@ -36,10 +27,6 @@ module SimpleCov
       @maximum_coverage = normalized_threshold(coverage, "maximum_coverage")
     end
 
-    #
-    # Pins the suite to an exact coverage figure by setting both
-    # `minimum_coverage` and `maximum_coverage`. See #187.
-    #
     def expected_coverage(coverage = nil)
       return minimum_coverage if coverage.nil?
 
@@ -47,10 +34,6 @@ module SimpleCov
       maximum_coverage(coverage)
     end
 
-    #
-    # Defines the maximum coverage drop at once allowed for the
-    # testsuite to pass. Default is 100% (disabled).
-    #
     def maximum_coverage_drop(coverage_drop = nil)
       return @maximum_coverage_drop ||= {} unless coverage_drop
 
@@ -58,11 +41,10 @@ module SimpleCov
     end
 
     #
-    # Defines the minimum coverage per file required for the testsuite
-    # to pass. Accepts a Numeric (global threshold on the primary
-    # criterion), a Symbol-keyed Hash (per-criterion globals), or a
-    # Hash mixing Symbol keys with String / Regexp keys to declare
-    # per-path overrides. See README and #575.
+    # The minimum coverage per file required for the testsuite to pass.
+    # Accepts a Numeric (global threshold on the primary criterion), a
+    # Symbol-keyed Hash (per-criterion globals), or a Hash mixing Symbol keys
+    # with String / Regexp keys to declare per-path overrides (#575).
     #
     def minimum_coverage_by_file(coverage = nil)
       return @minimum_coverage_by_file ||= {} unless coverage
@@ -70,8 +52,8 @@ module SimpleCov
       coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
       defaults, overrides = partition_per_file_thresholds(coverage)
 
-      SimpleCov::Deprecation.warn("`SimpleCov.minimum_coverage_by_file` is deprecated. " \
-                                  "Replace it with:\n#{per_file_coverage_replacement(defaults, overrides)}")
+      Deprecation.warn("`SimpleCov.minimum_coverage_by_file` is deprecated. " \
+                       "Replace it with:\n#{per_file_coverage_replacement(defaults, overrides)}")
 
       raise_on_invalid_coverage(defaults, "minimum_coverage_by_file")
       overrides.each_value { |criteria| raise_on_invalid_coverage(criteria, "minimum_coverage_by_file") }
@@ -80,91 +62,80 @@ module SimpleCov
       @minimum_coverage_by_file_overrides = overrides
     end
 
-    # Returns the per-path overrides set via `minimum_coverage_by_file`.
     def minimum_coverage_by_file_overrides
       @minimum_coverage_by_file_overrides ||= {}
     end
 
-    #
-    # Defines the minimum coverage per group required for the testsuite
-    # to pass. Default is 0% (disabled).
-    #
     def minimum_coverage_by_group(coverage = nil)
       return @minimum_coverage_by_group ||= {} unless coverage
 
-      SimpleCov::Deprecation.warn("`SimpleCov.minimum_coverage_by_group` is deprecated. " \
-                                  "Replace it with:\n#{per_group_coverage_replacement(coverage)}")
+      Deprecation.warn("`SimpleCov.minimum_coverage_by_group` is deprecated. " \
+                       "Replace it with:\n#{per_group_coverage_replacement(coverage)}")
       @minimum_coverage_by_group = coverage.to_h do |group_name, group_coverage|
         [GroupNames.normalize(group_name), normalized_threshold(group_coverage, "minimum_coverage_by_group")]
       end
     end
 
-    #
-    # Refuses any coverage drop. Coverage is only allowed to increase.
-    #
     def refuse_coverage_drop(*criteria)
       criteria = coverage_criteria if criteria.empty?
       maximum_coverage_drop(criteria.to_h { |c| [c, 0] })
     end
 
-  private
+    private
 
-    # Shared normalize-and-validate step behind every threshold setter:
-    # a bare Numeric targets the primary criterion, and the resulting
+    # A bare Numeric targets the primary criterion, and the resulting
     # per-criterion hash is validated before it is stored.
     def normalized_threshold(coverage, setting)
       coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
-      raise_on_invalid_coverage(coverage, setting)
-      coverage
+      coverage.tap { |thresholds| raise_on_invalid_coverage(thresholds, setting) }
     end
 
-    # Split a `minimum_coverage_by_file` argument into Symbol-keyed
-    # criterion defaults and String/Regexp-keyed per-path overrides;
-    # normalize Numeric override values to `{primary_coverage => N}`
-    # so downstream code only has one shape to handle.
+    # Splits into Symbol-keyed criterion defaults and String/Regexp-keyed
+    # per-path overrides, normalizing Numeric override values to
+    # `{primary_coverage => N}` so downstream code has one shape to handle.
     def partition_per_file_thresholds(coverage)
       coverage.each_key { |key| validate_per_file_key(key) }
-      pairs = coverage.partition { |key, _| key.is_a?(Symbol) }
-      # The assertions restate what the partition predicate guarantees:
-      # Symbol keys carry per-criterion Numeric defaults, the rest are paths.
-      defaults = pairs[0].to_h #: coverage_thresholds
-      raw = pairs[1].to_h #: Hash[String | Regexp, Numeric | coverage_thresholds]
+      # The assertions restate what the partition predicate guarantees: Symbol
+      # keys carry per-criterion Numeric defaults, the rest are paths.
+      symbol_pairs, path_pairs = coverage.partition { |key, _| key.instance_of?(Symbol) }
+      defaults = symbol_pairs.to_h #: coverage_thresholds
+      raw = path_pairs.to_h #: Hash[String | Regexp, Numeric | coverage_thresholds]
       overrides = raw.transform_values { |value| value.is_a?(Numeric) ? {primary_coverage => value} : value }
       [defaults, overrides]
     end
 
     def validate_per_file_key(key)
-      return if key.is_a?(Symbol) || key.is_a?(String) || key.is_a?(Regexp)
+      # Symbols have no subclasses; paths and patterns may.
+      return if key.instance_of?(Symbol) || key.is_a?(String) || key.is_a?(Regexp)
 
-      raise SimpleCov::ConfigurationError,
-            "minimum_coverage_by_file keys must be Symbol (criterion), String, or Regexp; got #{key.inspect}"
+      raise ConfigurationError,
+        "minimum_coverage_by_file keys must be Symbol (criterion), String, or Regexp; got #{key.inspect}"
     end
 
     def minimum_possible_coverage_exceeded(coverage_option)
       warn "The coverage you set for #{coverage_option} is greater than 100%"
     end
 
-    # Render the `coverage` configuration equivalent to a (deprecated)
-    # `minimum_coverage_by_file` argument so the deprecation warning can be
+    # Renders the `coverage` configuration equivalent to a deprecated
+    # `minimum_coverage_by_file` argument, so the deprecation warning can be
     # copy-pasted verbatim into the user's config.
     def per_file_coverage_replacement(defaults, overrides)
       by_criterion = {} #: Hash[Symbol, Array[String]]
-      defaults.each { |criterion, percent| (by_criterion[criterion] ||= []) << "minimum_per_file #{percent}" }
+      defaults.each { |criterion, percent| (by_criterion[criterion] ||= []) << "minimum #{percent}, per: :file" }
       overrides.each do |target, criteria|
         criteria.each do |criterion, percent|
-          (by_criterion[criterion] ||= []) << "minimum_per_file #{percent}, only: #{target.inspect}"
+          (by_criterion[criterion] ||= []) << "minimum #{percent}, per: #{target.inspect}"
         end
       end
       render_coverage_blocks(by_criterion)
     end
 
-    # Same, for a (deprecated) `minimum_coverage_by_group` argument.
     def per_group_coverage_replacement(coverage)
       by_criterion = {} #: Hash[Symbol, Array[String]]
       coverage.each do |group_name, thresholds|
         normalized = (thresholds.is_a?(Numeric) ? {primary_coverage => thresholds} : thresholds) #: coverage_thresholds
         normalized.each do |criterion, percent|
-          (by_criterion[criterion] ||= []) << "minimum_per_group #{percent}, only: #{group_name.inspect}"
+          (by_criterion[criterion] ||= []) << "minimum #{percent}, per: group(#{group_name.inspect})"
         end
       end
       render_coverage_blocks(by_criterion)
@@ -172,7 +143,7 @@ module SimpleCov
 
     def render_coverage_blocks(by_criterion)
       by_criterion.map do |criterion, statements|
-        "  coverage(#{criterion.inspect}) { #{statements.join('; ')} }"
+        "  coverage(#{criterion.inspect}) { #{statements.join("; ")} }"
       end.join("\n")
     end
   end

data/lib/simplecov/configuration/view_coverage.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Configuration
+    DEFAULT_VIEW_GLOBS = %w[app/views/**/*.{erb,haml,slim}].freeze
+
+    # Reports coverage for ActionView templates, defaulting to a Rails app's
+    # views. Globs are expanded against `SimpleCov.root`, and one naming an
+    # extension no handler is registered for (as the default does whenever a
+    # project has no Haml or Slim) leaves those files out rather than reporting
+    # them as empty.
+    #
+    # Templates the suite renders are measured through eval coverage, which this
+    # enables, so it needs Ruby 3.2 or later. Templates it never renders are
+    # compiled at the end of the run so they appear at 0% instead of going
+    # missing.
+    def cover_views(*globs)
+      globs = globs.flatten.compact
+      globs = DEFAULT_VIEW_GLOBS.dup if globs.empty?
+      @view_globs = globs
+      enable_eval_coverage
+      globs
+    end
+
+    # Nil rather than an empty Array when `cover_views` was never called, so
+    # "not asked for" stays distinguishable from "asked for, with nothing to
+    # match".
+    def view_globs
+      @view_globs
+    end
+
+    # False when eval coverage couldn't be enabled, where `cover_views` has
+    # already warned and the templates would come back empty rather than at 0%.
+    def view_coverage?
+      !view_globs.nil? && coverage_for_eval_enabled?
+    end
+  end
+end