simplecov 1.1.1 → 1.3.0

data/lib/simplecov/configuration/coverage_criteria.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  # Selection and validation of the coverage criteria Ruby's `Coverage`
-  # library should track. Supports `:line` (the historical default),
-  # `:branch`, `:method`, and `:oneshot_line`. The standalone `:eval`
-  # toggle lives in `eval_coverage.rb`.
   module Configuration
     SUPPORTED_COVERAGE_CRITERIA = %i[line branch method oneshot_line].freeze
     DEFAULT_COVERAGE_CRITERION = :line
@@ -12,34 +8,36 @@ module SimpleCov
     LINE_COVERAGE_ALTERNATIVES = {line: :oneshot_line, oneshot_line: :line}.freeze #: line_coverage_alternatives
     private_constant :LINE_COVERAGE_ALTERNATIVES
 
-    # Enable one or more coverage criteria. `:eval` is accepted as a
-    # shorthand for the standalone eval-coverage toggle.
     def enable_coverage(*criteria)
-      criteria.each { |criterion| criterion == :eval ? enable_eval_coverage : add_coverage_criterion(criterion) }
+      criteria.each do |criterion|
+        criterion.equal?(:eval) ? enable_eval_coverage : add_coverage_criterion(_ = criterion)
+      end
     end
 
-    # Remove `criterion` from the set of enabled coverage criteria.
-    # `:eval` turns the standalone eval-coverage toggle back off,
-    # mirroring `enable_coverage`. Disabling every criterion raises at
-    # `start_tracking` (not here), so config files that toggle criteria
-    # in arbitrary order don't have to worry about transient empty states.
+    # Disabling every criterion raises at `start_tracking`, not here, so config
+    # files that toggle criteria in arbitrary order don't have to worry about
+    # transient empty states.
     def disable_coverage(criterion)
-      return disable_eval_coverage if criterion == :eval
+      return disable_eval_coverage if criterion.equal?(:eval)
 
-      raise_if_criterion_unsupported(criterion)
-      coverage_criteria.delete(criterion)
-      @primary_coverage = nil if @primary_coverage == criterion
+      raise_if_criterion_unsupported(_ = criterion)
+      coverage_criteria.delete(_ = criterion)
+      @primary_coverage = nil if @primary_coverage.equal?(criterion)
     end
 
     def primary_coverage(criterion = nil)
       if criterion.nil?
         @primary_coverage ||= default_primary_coverage
       else
-        raise_if_criterion_disabled(criterion)
-        @primary_coverage = criterion
+        self.primary_coverage = criterion
       end
     end
 
+    def primary_coverage=(criterion)
+      raise_if_criterion_disabled(criterion)
+      @primary_coverage = criterion
+    end
+
     def coverage_criteria
       @coverage_criteria ||= Set[DEFAULT_COVERAGE_CRITERION]
     end
@@ -48,20 +46,17 @@ module SimpleCov
       coverage_criteria.member?(criterion)
     end
 
-    # Reset the criteria back to the lazy default (`Set[:line]`).
     def clear_coverage_criteria
       @coverage_criteria = nil
       @primary_coverage = nil
     end
 
-    # @api private — called from `SimpleCov.start_tracking` to fail
-    # fast when the user has disabled every coverage criterion.
     def validate_coverage_criteria!
       return unless coverage_criteria.empty?
 
-      raise SimpleCov::ConfigurationError,
-            "At least one coverage criterion must be enabled. " \
-            "Re-enable one with `enable_coverage :line`, `:branch`, or `:method`."
+      raise ConfigurationError,
+        "At least one coverage criterion must be enabled. " \
+        "Re-enable one with `enable_coverage :line`, `:branch`, or `:method`."
     end
 
     # Whether this run produces line data at all. The oneshot variant counts:
@@ -89,23 +84,23 @@ module SimpleCov
       coverage_criterion_supported?(:methods)
     end
 
-    # Ask the Coverage runtime itself whether a criterion is supported
-    # (Ruby >= 3.2). Older Rubies don't expose `Coverage.supported?`, so
-    # fall back to the historical engine check that line/branch/method
-    # were unavailable on JRuby. `:eval` was added later, so on older
-    # Rubies its fallback is "always unsupported" rather than the
-    # JRuby-only one above. The fallback arm is unreachable from the
-    # dogfood report, which runs on a newer Ruby.
-    # simplecov:disable
+    # Older Rubies don't expose `Coverage.supported?`, so fall back to the
+    # historical engine check that line/branch/method were unavailable on JRuby.
+    # `:eval` was added later, so its fallback is "always unsupported".
     def coverage_criterion_supported?(criterion)
-      require "coverage"
+      load_coverage
       return Coverage.supported?(criterion) if Coverage.respond_to?(:supported?)
 
-      criterion != :eval && RUBY_ENGINE != "jruby"
+      !criterion.eql?(:eval) && !RUBY_ENGINE.eql?("jruby")
+    end
+
+    # Loading `simplecov/configuration` on its own leaves Coverage undefined, and
+    # this question is asked at configuration time.
+    def load_coverage
+      require "coverage"
     end
-    # simplecov:enable
 
-  private
+    private
 
     def add_coverage_criterion(criterion)
       raise_if_criterion_unsupported(criterion)
@@ -114,41 +109,35 @@ module SimpleCov
       coverage_criteria << criterion
     end
 
-    # If `:line` is enabled, it's the default primary; otherwise fall
-    # back to whichever criterion the user actually enabled (in
-    # insertion order). Returning `:line` even when disabled would
-    # propagate broken state into `minimum_coverage 90`.
+    # Answering `:line` even when it is disabled would propagate broken state
+    # into `minimum_coverage 90`, so fall back to whichever criterion the user
+    # actually enabled, in insertion order.
     def default_primary_coverage
       return DEFAULT_COVERAGE_CRITERION if coverage_criterion_enabled?(DEFAULT_COVERAGE_CRITERION)
 
-      # Set#first types as nilable, but an empty criteria set is rejected at
-      # start_tracking before any caller can observe a nil here.
       _ = coverage_criteria.first
     end
 
     def raise_if_criterion_disabled(criterion)
-      # `coverage :eval` by itself IS supported — it's a standalone
-      # toggle, never in the enabled-criteria set — so the generic
-      # "unsupported criterion" message below would mislead here.
-      if criterion == :eval
-        raise SimpleCov::ConfigurationError,
-              "Coverage criterion :eval only toggles measuring eval'd code; " \
-              "it cannot carry thresholds or serve as the primary criterion"
+      if criterion.equal?(:eval)
+        raise ConfigurationError,
+          "Coverage criterion :eval only toggles measuring eval'd code; " \
+          "it cannot carry thresholds or serve as the primary criterion"
       end
 
       raise_if_criterion_unsupported(criterion)
       return if coverage_criterion_enabled?(criterion)
 
-      raise SimpleCov::ConfigurationError,
-            "Coverage criterion #{criterion}, is disabled! " \
-            "Please enable it first through enable_coverage #{criterion} (if supported)"
+      raise ConfigurationError,
+        "Coverage criterion #{criterion}, is disabled! " \
+        "Please enable it first through enable_coverage #{criterion} (if supported)"
     end
 
     def raise_if_criterion_unsupported(criterion)
       return if SUPPORTED_COVERAGE_CRITERIA.member?(criterion)
 
-      raise SimpleCov::ConfigurationError,
-            "Unsupported coverage criterion #{criterion}, supported values are #{SUPPORTED_COVERAGE_CRITERIA}"
+      raise ConfigurationError,
+        "Unsupported coverage criterion #{criterion}, supported values are #{SUPPORTED_COVERAGE_CRITERIA}"
     end
   end
 end

data/lib/simplecov/configuration/deprecations.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../deprecation"
+
+module SimpleCov
+  module Configuration
+    DEPRECATION_MODES = Deprecation::MODES
+
+    # The configuration DSL migrates by warn-and-delegate, which means a project
+    # can run on deprecated spellings indefinitely without noticing.
+    # `deprecations :raise` turns every deprecated API into a ConfigurationError,
+    # so a project that has migrated can guard in CI against old spellings
+    # creeping back. There is deliberately no silencing mode: a deprecation you
+    # cannot see is a migration you never make.
+    def deprecations(mode = nil)
+      return Deprecation.mode unless mode
+
+      Deprecation.mode = mode
+    end
+  end
+end

data/lib/simplecov/configuration/eval_coverage.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  # The standalone eval-coverage toggle (`enable_coverage :eval`),
-  # instrumenting `eval`'d code on Rubies that support it. Kept separate
-  # from the criteria-set logic in `coverage_criteria.rb` because `:eval`
-  # is a boolean toggle, never a member of the enabled-criteria set.
   module Configuration
+    # The standalone eval-coverage toggle, kept apart from the criteria-set logic
+    # in `coverage_criteria.rb` because `:eval` is a boolean toggle, never a
+    # member of the enabled-criteria set.
     def coverage_for_eval_supported?
       coverage_criterion_supported?(:eval)
     end
@@ -14,22 +13,19 @@ module SimpleCov
       @coverage_for_eval_enabled ||= false
     end
 
-    # DEPRECATED: prefer `enable_coverage :eval`.
     def enable_coverage_for_eval
-      SimpleCov::Deprecation.warn("`SimpleCov.enable_coverage_for_eval` is deprecated. " \
-                                  "Replace with `SimpleCov.enable_coverage :eval`.")
+      Deprecation.warn("`SimpleCov.enable_coverage_for_eval` is deprecated. " \
+                       "Replace with `SimpleCov.enable_coverage :eval`.")
       enable_eval_coverage
     end
 
-  private
+    private
 
-    # Shared implementation backing both `enable_coverage :eval` and
-    # the deprecated `enable_coverage_for_eval`.
     def enable_eval_coverage
       if coverage_for_eval_supported?
         @coverage_for_eval_enabled = true
       else
-        warn "Coverage for eval is not available; Use Ruby 3.2.0 or later"
+        warn "Coverage for eval is not available on this Ruby"
       end
     end
 

data/lib/simplecov/configuration/filters.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  # Inclusion and exclusion methods: `cover` and `skip`, plus the deprecated
-  # `track_files` and `add_filter` aliases.
   module Configuration
     attr_writer :filters
 
@@ -12,59 +10,38 @@ module SimpleCov
     # when any `cover` matcher is configured the report drops every file that
     # doesn't match at least one of them.
     #
-    # Strings are interpreted as shell globs (e.g. "lib/**/*.rb"), not
-    # substring matches — this is a deliberate departure from the legacy
-    # `add_filter` semantics and matches the way `track_files` already
-    # interprets its argument.
+    # Strings are interpreted as shell globs, not substring matches, a
+    # deliberate departure from the legacy `add_filter` semantics.
     #
-    # When the matcher is a string-glob, `cover` also expands the glob on
-    # disk so files that exist but were never required during the run still
-    # appear in the report (at 0% coverage). This is the "include unloaded
-    # files" half of the legacy `track_files` behavior, rolled into the
-    # same call.
-    #
-    #     SimpleCov.start do
-    #       cover "lib/**/*.rb", "app/**/*.rb"
-    #       cover(/_helper\.rb\z/)
-    #       cover { |sf| sf.lines.count > 5 }
-    #     end
+    # A string glob is also expanded on disk, so files that exist but were
+    # never required during the run still appear in the report at 0%. This is
+    # the "include unloaded files" half of the legacy `track_files` behavior.
     #
     def cover(*args, &block)
       args.each { |arg| cover_filters << build_cover_filter(arg) }
-      cover_filters << SimpleCov::BlockFilter.new(block) if block
+      cover_filters << BlockFilter.new(block) if block
       cover_filters
     end
 
-    # Returns the list of configured inclusion filters added via `cover`.
     def cover_filters
       @cover_filters ||= []
     end
 
-    # Returns the list of string globs passed to `cover` — used by the
-    # disk-discovery pass in `SimpleCov.tracked_file_paths` so files
-    # matching a `cover` glob appear in the report even when they were
-    # never required during the suite.
-    #
-    # Walks into `ArrayFilter` entries (built when a caller passes an
-    # array to `cover`) so a glob nested inside `cover(["lib/**/*.rb",
-    # /helper\.rb\z/])` still drives unloaded-file discovery.
+    # The string globs passed to `cover`, used by the disk-discovery pass in
+    # `SimpleCov.tracked_file_paths` so files matching a `cover` glob appear in
+    # the report even when they were never required during the suite.
     def cover_globs
       collect_cover_globs(cover_filters)
     end
 
-    # DEPRECATED: prefer `cover`, which both includes unloaded files (the
-    # historical `track_files` behavior) and restricts the report to the
-    # matching set.
     def track_files(glob)
-      SimpleCov::Deprecation.warn("`SimpleCov.track_files` is deprecated. " \
-                                  "#{track_files_replacement_hint(glob)}")
+      Deprecation.warn("`SimpleCov.track_files` is deprecated. " \
+                       "#{track_files_replacement_hint(glob)}")
       @tracked_files = glob
     end
 
-    # `track_files(nil)` is the documented way to clear a previously-set
-    # glob, but `cover(nil)` raises `ConfigurationError`, so don't point
-    # users at it. The `cover` API has no direct equivalent for "reset
-    # the inclusion list" — point users at the `@cover_filters` reset.
+    # `track_files(nil)` is the documented way to clear a previously-set glob,
+    # but `cover(nil)` raises `ConfigurationError`, so don't point users at it.
     def track_files_replacement_hint(glob)
       if glob.nil?
         "Replace with `SimpleCov.cover_filters.clear` — clearing the inclusion list."
@@ -76,86 +53,76 @@ module SimpleCov
       end
     end
 
-    # Returns the glob used to include files that were not explicitly required.
+    # Nil until `cover` names a glob: an unset ivar reads as nil, so the absence
+    # needs no guard of its own.
     def tracked_files
-      @tracked_files if defined?(@tracked_files)
+      @tracked_files
     end
 
-    # Returns the list of configured exclusion filters added via `skip`
-    # (or the deprecated `add_filter`).
     def filters
       @filters ||= []
     end
 
     #
     # Drop matching files from the coverage report. The inverse of `cover`.
-    #
-    # See README for the full grammar; `skip` accepts a String (path-segment
-    # substring), Regexp, block predicate, or Array of any of those.
+    # Accepts a String (path-segment substring), Regexp, block predicate, or
+    # Array of any of those.
     #
     def skip(filter_argument = nil, &)
       filters << parse_filter(filter_argument, &)
     end
 
-    # DEPRECATED: alias for `skip`. Same matcher grammar, identical behavior.
     def add_filter(filter_argument = nil, &block)
       example = block ? "`SimpleCov.skip { ... }`" : "`SimpleCov.skip #{filter_argument.inspect}`"
-      SimpleCov::Deprecation.warn("`SimpleCov.add_filter` is deprecated. " \
-                                  "Replace with `SimpleCov.skip` (same arguments, same behavior). Example: #{example}.")
+      Deprecation.warn("`SimpleCov.add_filter` is deprecated. " \
+                       "Replace with `SimpleCov.skip` (same arguments, same behavior). Example: #{example}.")
       skip(filter_argument, &block)
     end
 
-    # Remove any filters whose `filter_argument` equals the given value.
-    # Returns true when at least one filter was removed, false otherwise.
-    def remove_filter(filter_argument) # rubocop:disable Naming/PredicateMethod
-      before = filters.size
-      filters.reject! { |filter| filter.respond_to?(:filter_argument) && filter.filter_argument == filter_argument }
-      filters.size != before
+    # `reject!` answers nil when it rejected nothing, which is the whole of
+    # "was anything removed".
+    def remove_filter(filter_argument)
+      rejected = filters.reject! do |filter|
+        filter.respond_to?(:filter_argument) && filter.filter_argument.eql?(filter_argument)
+      end
+      !rejected.nil?
     end
 
-    # Remove every filter from the chain, including the defaults installed
-    # by `SimpleCov.start`.
     def clear_filters
       @filters = []
     end
 
-    # Drop every filter previously installed (defaults plus anything
-    # earlier in this block) so subsequent `skip` calls start from a
-    # clean slate. Order matters — call this before your own `skip`
-    # invocations.
+    # Order matters: call this before your own `skip` invocations.
     def no_default_skips
       clear_filters
     end
 
-  private
+    private
 
-    # The actual filter processor. Not meant for direct use.
     def parse_filter(filter_argument = nil, &filter_proc)
       filter = filter_argument || filter_proc
 
       raise ArgumentError, "Please specify either a filter or a block to filter with" unless filter
 
-      SimpleCov::Filter.build_filter(filter)
+      Filter.build_filter(filter)
     end
 
-    # Build a filter for a `cover` argument. Strings are treated as
-    # globs (not substrings — that's `skip`/`add_filter`'s semantics);
-    # everything else dispatches exactly like `add_filter`.
+    # Strings are treated as globs, not substrings (that's `skip`'s
+    # semantics); everything else dispatches exactly like `add_filter`.
     def build_cover_filter(arg)
-      SimpleCov::Filter.build_filter(arg, string_filter: SimpleCov::GlobFilter)
-    rescue SimpleCov::ConfigurationError
-      raise SimpleCov::ConfigurationError, "Unsupported `cover` argument #{arg.inspect}; " \
-                                           "expected a String glob, Regexp, Proc, " \
-                                           "SimpleCov::Filter, or Array of those."
+      Filter.build_filter(arg, string_filter: GlobFilter)
+    rescue ConfigurationError
+      raise ConfigurationError, "Unsupported `cover` argument #{arg.inspect}; " \
+                                "expected a String glob, Regexp, Proc, " \
+                                "SimpleCov::Filter, or Array of those."
     end
 
-    # Walk a list of cover filters and return the string globs they hold,
-    # descending into `ArrayFilter` wrappers built by `cover(["a", "b"])`.
+    # Descends into `ArrayFilter` wrappers built by `cover(["a", "b"])`.
     def collect_cover_globs(filter_list)
       filter_list.flat_map do |filter|
         case filter
-        when SimpleCov::GlobFilter  then filter.filter_argument
-        when SimpleCov::ArrayFilter then collect_cover_globs(filter.filter_argument)
+        when GlobFilter then filter.filter_argument
+        when ArrayFilter then collect_cover_globs(filter.filter_argument)
         else []
         end
       end

data/lib/simplecov/configuration/formatting.rb

@@ -3,35 +3,33 @@
 require_relative "../formatter/multi_formatter"
 
 module SimpleCov
-  # Formatter selection (`formatter` / `formatters`), reporting toggles
-  # (`print_errors`), and the deprecated `# :nocov:` token hook.
   module Configuration
     attr_writer :formatter, :print_error_status
 
-    #
-    # Gets or sets the configured formatter. Accepts a formatter class
-    # (instantiated fresh for every report) or a ready-built instance,
-    # which is how constructor options are passed — e.g.
-    # `formatter SimpleCov::Formatter::HTMLFormatter.new(silent: true)`
-    # to suppress the "Coverage report generated" status line (see
-    # #1240). Pass `false` (or `nil`) to opt out of formatting
-    # entirely — worker processes in big parallel CI setups (see #964)
-    # only need their `.resultset.json` on disk so a final
-    # `SimpleCov.collate` job can produce the report; running them
-    # without a formatter saves the per-job HTML/multi-formatter
-    # overhead.
-    #
+    BUILT_IN_FORMATS = {
+      html: :HTMLFormatter, json: :JSONFormatter, simple: :SimpleFormatter, baseline: :BaselineFormatter
+    }.freeze
+    private_constant :BUILT_IN_FORMATS
+
+    LAZY_FORMAT_REQUIRES = {html: "../../simplecov-html"}.freeze
+    private_constant :LAZY_FORMAT_REQUIRES
+
+    def formats(*names)
+      return formatters if names.empty?
+
+      self.formatters = names.map { |name| resolve_format(name) }
+      formatters
+    end
+
     def formatter(formatter = :__no_arg__)
       case formatter
       when :__no_arg__
         @formatter
       else
-        @formatter = formatter || nil # normalize `false` to `nil`
+        @formatter = formatter || nil
       end
     end
 
-    # Sets the configured formatters. Pass `[]` to opt out of
-    # formatting entirely; see `formatter` for the rationale.
     def formatters(formatters = :__no_arg__)
       case formatters
       when :__no_arg__
@@ -39,100 +37,93 @@ module SimpleCov
         configured ? [configured] : []
       else
         self.formatters = formatters
-        formatters
       end
     end
 
-    # Sets the configured formatters. Equivalent to `formatters [...]`.
-    # Accepts a single formatter as well as an Array, matching the pre-1.0 behavior
-    # where `MultiFormatter.new` normalized its input. Elements may be
-    # formatter classes or ready-built instances; see `formatter`.
-    # `nil`, `false`, and `[]` all opt out of formatting entirely —
-    # `false` normalized like `formatter false` does, since `Array(false)`
-    # would otherwise smuggle it in as a "formatter" that can only fail.
+    # `nil`, `false`, and `[]` all opt out of formatting entirely. `false` is
+    # normalized first, since `Array(false)` would otherwise smuggle it in as a
+    # "formatter" that can only fail.
     def formatters=(formatters)
-      formatters = Array(formatters || nil)
-      @formatter = formatters.empty? ? nil : SimpleCov::Formatter::MultiFormatter.new(formatters)
-    end
-
-    #
-    # Get or set whether SimpleCov colorizes its stderr diagnostics. Accepts
-    # `true` (always on), `false` (always off), or `:auto` (default: defer
-    # to `SimpleCov::Color`, which checks `$stderr.tty?` with `NO_COLOR`
-    # and `FORCE_COLOR` overrides). An explicit `true`/`false` wins over
-    # both auto-detection and the env vars, which is the right escape
-    # hatch when stderr is being piped through a wrapper that still
-    # renders ANSI in its own terminal (parallel_tests with
-    # `--combine-stderr`, log multiplexers, some CI runners). See #1157.
-    #
+      @formatter = combined_formatter(Array(formatters || nil))
+    end
+
     def color(value = :__no_arg__)
-      return defined?(@color) ? @color : :auto if value == :__no_arg__
+      return instance_variable_defined?(:@color) ? @color : :auto if value.eql?(:__no_arg__)
+
+      self.color = _ = value
+    end
 
+    def color=(value)
       @color = value
     end
 
-    #
-    # Get or set whether SimpleCov prints its own diagnostic warnings to
-    # stderr. Covers per-check threshold violations, the trailing
-    # "SimpleCov failed with exit ..." summary, and the deferred-report /
-    # previous-error notices. Defaults to true. Set to false to silence
-    # SimpleCov entirely when parsing tooling output (see issue #1155).
-    #
     def print_errors(value = :__no_arg__)
-      return defined?(@print_error_status) ? @print_error_status : true if value == :__no_arg__
+      return instance_variable_defined?(:@print_error_status) ? @print_error_status : true if value.eql?(:__no_arg__)
 
+      self.print_errors = _ = value
+    end
+
+    def print_errors=(value)
       @print_error_status = value
     end
 
-    #
-    # Get or set whether `coverage.json` includes the full source-text
-    # array for every file. Defaults to true. Set to false when a
-    # downstream tool reads the project's source files directly and
-    # only needs the coverage metrics, so `coverage.json` doesn't carry
-    # a copy of the source tree (which dominates the payload on larger
-    # projects).
-    #
-    # The HTML report's embedded data always includes source — the
-    # client-side renderer needs it. Only `coverage.json` honors
-    # this setting.
-    #
-    #     SimpleCov.start do
-    #       source_in_json false
-    #     end
-    #
     def source_in_json(value = :__no_arg__)
-      return defined?(@source_in_json) ? @source_in_json : true if value == :__no_arg__
+      return instance_variable_defined?(:@source_in_json) ? @source_in_json : true if value.eql?(:__no_arg__)
+
+      self.source_in_json = _ = value
+    end
 
+    def source_in_json=(value)
       @source_in_json = value
     end
 
-    # DEPRECATED: alias for `print_errors`. Same value, same behavior.
     def print_error_status
-      SimpleCov::Deprecation.warn("`SimpleCov.print_error_status` is deprecated. " \
-                                  "Replace with `SimpleCov.print_errors` (same value).")
-      defined?(@print_error_status) ? @print_error_status : true
+      Deprecation.warn("`SimpleCov.print_error_status` is deprecated. " \
+                       "Replace with `SimpleCov.print_errors` (same value).")
+      instance_variable_defined?(:@print_error_status) ? @print_error_status : true
     end
 
-    #
-    # DEPRECATED: configure `# :nocov:` token override. Prefer
-    # `# simplecov:disable` / `# simplecov:enable` block comments (see
-    # SimpleCov::Directive). The `# :nocov:` toggle and this hook will
-    # be removed in a future release.
-    #
     def nocov_token(nocov_token = nil)
-      SimpleCov::Deprecation.warn("`SimpleCov.nocov_token` and `SimpleCov.skip_token` are deprecated. " \
-                                  "Replace with `# simplecov:disable` / `# simplecov:enable` block comments.")
+      Deprecation.warn("`SimpleCov.nocov_token` and `SimpleCov.skip_token` are deprecated. " \
+                       "Replace with `# simplecov:disable` / `# simplecov:enable` block comments.")
       current_nocov_token(nocov_token)
     end
-    alias skip_token nocov_token
+    alias_method :skip_token, :nocov_token
 
-    # Internal accessor used by SimpleCov to recognise `# :nocov:`
-    # markers without emitting the public-API deprecation warning. Will
-    # be removed alongside the deprecated `nocov_token` setter.
     def current_nocov_token(value = nil)
-      return @nocov_token if defined?(@nocov_token) && value.nil?
+      return @nocov_token if instance_variable_defined?(:@nocov_token) && value.nil?
 
       @nocov_token = value || "nocov"
     end
+
+    private
+
+    # An empty list is how a project opts out of formatting.
+    def combined_formatter(formatters)
+      return if formatters.empty?
+
+      Formatter::MultiFormatter.new(formatters)
+    end
+
+    def resolve_format(name)
+      return name unless name.instance_of?(Symbol)
+
+      constant = BUILT_IN_FORMATS[name]
+      unless constant
+        raise ConfigurationError,
+          "Unknown format #{name.inspect}. Built-in formats are :html, :json, :simple, and :baseline; " \
+          "pass a formatter class or instance for anything else."
+      end
+
+      require_html_formatter(name)
+      Formatter.const_get(constant)
+    end
+
+    # `formats :html` has to work in a process that never required the HTML
+    # formatter, which under SIMPLECOV_NO_DEFAULTS nothing else has.
+    def require_html_formatter(name)
+      path = LAZY_FORMAT_REQUIRES[name]
+      require_relative(path) if path
+    end
   end
 end