ultra-pro-pkg 0.0.1

data/simplecov-1.0.0/lib/simplecov/configuration/coverage.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # The `coverage` configuration method configures each coverage criterion
+  # (`:line`, `:branch`, `:method`, `:eval`) uniformly in one place: naming a
+  # criterion enables it,
+  # and every threshold is declared with the same syntax regardless of which
+  # criterion it applies to. Because the criterion is fixed by the enclosing
+  # `coverage` call, threshold values are always plain percentages — there is
+  # no per-criterion Hash competing with the value for a slot.
+  #
+  #   SimpleCov.start do
+  #     coverage :line do
+  #       minimum          90
+  #       minimum_per_file 80
+  #       minimum_per_file 100, only: "app/mailers/request_mailer.rb"
+  #       maximum_drop     5
+  #     end
+  #
+  #     coverage :branch, minimum: 80
+  #     coverage :method, minimum: 100
+  #   end
+  #
+  # Line coverage is enabled by default, so `coverage :line` is only needed to
+  # set line thresholds or options. Thresholds feed the same internal stores
+  # as the flat `minimum_coverage` family, so enforcement is unchanged.
+  module Configuration
+    # One-liner keyword options `coverage` accepts, each forwarding to the
+    # `CoverageCriterion` verb of the same name. `minimum_per_group` is omitted
+    # because it needs an `only:` target, so it's block-only.
+    COVERAGE_THRESHOLD_OPTIONS = %i[minimum maximum exact maximum_drop minimum_per_file].freeze
+
+    #
+    # Configure (and, unless `enabled: false`, enable) a coverage criterion.
+    #
+    # Threshold options mirror the block verbs for one-liner use:
+    #   coverage :branch, minimum: 80, maximum_drop: 5
+    #
+    # `primary: true` makes this the report's leading criterion (and the one a
+    # bare `minimum_coverage 90` targets). `oneshot: true` (valid only for
+    # `:line`) selects the faster oneshot-lines mode. `:eval` is enable-only.
+    #
+    def coverage(criterion, primary: false, enabled: true, oneshot: false, **thresholds, &block)
+      criterion = enable_coverage_criterion(criterion, enabled: enabled, oneshot: oneshot)
+      primary_coverage(criterion) if primary
+
+      configurator = CoverageCriterion.new(self, criterion)
+      apply_threshold_options(configurator, thresholds)
+      configurator.instance_eval(&block) if block
+
+      criterion
+    end
+
+  private
+
+    # Forward the one-liner threshold keywords (`coverage :branch, minimum: 80`)
+    # to the matching `CoverageCriterion` verbs, rejecting anything that isn't a
+    # recognized threshold option.
+    def apply_threshold_options(configurator, options)
+      options.each do |verb, value|
+        unless COVERAGE_THRESHOLD_OPTIONS.include?(verb)
+          raise SimpleCov::ConfigurationError,
+                "Unknown `coverage` option #{verb.inspect}. " \
+                "Supported options are #{COVERAGE_THRESHOLD_OPTIONS.inspect}."
+        end
+
+        configurator.public_send(verb, value)
+      end
+    end
+
+    # Enable the criterion (or its oneshot / eval variant) and return the
+    # criterion symbol that thresholds should be stored under.
+    def enable_coverage_criterion(criterion, enabled:, oneshot:)
+      return enable_oneshot_line(criterion) if oneshot
+      return enable_eval_coverage_criterion if criterion == :eval
+
+      enabled ? enable_coverage(criterion) : disable_coverage(criterion)
+      criterion
+    end
+
+    def enable_oneshot_line(criterion)
+      unless criterion == :line
+        raise SimpleCov::ConfigurationError, "`oneshot: true` is only valid for `coverage :line`"
+      end
+
+      enable_coverage(ONESHOT_LINE_COVERAGE_CRITERION)
+      ONESHOT_LINE_COVERAGE_CRITERION
+    end
+
+    def enable_eval_coverage_criterion
+      enable_coverage(:eval)
+      :eval
+    end
+
+    # @api private — threshold-store writers used by CoverageCriterion. They
+    # write the same `@minimum_coverage` / `@maximum_coverage` / ... hashes the
+    # flat threshold methods populate, so the exit-code checks are unchanged.
+    def store_overall_threshold(setting, criterion, percent)
+      raise_on_invalid_coverage({criterion => percent}, setting.to_s)
+      public_send(setting)[criterion] = percent
+    end
+
+    def store_minimum_per_file(criterion, percent, target)
+      raise_on_invalid_coverage({criterion => percent}, "minimum_coverage_by_file")
+      return minimum_coverage_by_file[criterion] = percent if target.nil?
+
+      unless target.is_a?(String) || target.is_a?(Regexp)
+        raise SimpleCov::ConfigurationError, "`only:` must be a String path or Regexp, got #{target.inspect}"
+      end
+
+      (minimum_coverage_by_file_overrides[target] ||= {})[criterion] = percent
+    end
+
+    def store_minimum_per_group(criterion, percent, group_name)
+      raise_on_invalid_coverage({criterion => percent}, "minimum_coverage_by_group")
+      (minimum_coverage_by_group[group_name] ||= {})[criterion] = percent
+    end
+
+    #
+    # Receiver for a `coverage <criterion> do ... end` block. Each verb writes a
+    # threshold for the single criterion the block configures, so the value is
+    # always a plain percentage (`minimum_per_file 100` is unambiguous) and the
+    # syntax is identical across line, branch, and method coverage.
+    #
+    class CoverageCriterion
+      def initialize(config, criterion)
+        @config = config
+        @criterion = criterion
+      end
+
+      # Overall (suite-wide) minimum for this criterion.
+      def minimum(percent)
+        @config.send(:store_overall_threshold, :minimum_coverage, @criterion, percent)
+      end
+
+      # Overall maximum: fails the build if coverage rises above it. Paired with
+      # `minimum` (or via `exact`) this pins coverage so an unexpected jump fails.
+      def maximum(percent)
+        @config.send(:store_overall_threshold, :maximum_coverage, @criterion, percent)
+      end
+
+      # Pin coverage to an exact figure (sets both `minimum` and `maximum`).
+      def exact(percent)
+        minimum(percent)
+        maximum(percent)
+      end
+
+      # Maximum allowed drop between runs (`maximum_drop 0` refuses any drop).
+      def maximum_drop(percent)
+        @config.send(:store_overall_threshold, :maximum_coverage_drop, @criterion, percent)
+      end
+
+      # Per-file minimum. With no `only:`, sets the default applied to every
+      # file; with `only:` (a String path or Regexp), overrides that default
+      # for the matching files.
+      def minimum_per_file(percent, only: nil)
+        @config.send(:store_minimum_per_file, @criterion, percent, only)
+      end
+
+      # Per-group minimum for the named group (defined via `group`).
+      def minimum_per_group(percent, only:)
+        @config.send(:store_minimum_per_group, @criterion, percent, only)
+      end
+
+      # Make this criterion the report's primary (leading) criterion.
+      def primary
+        @config.primary_coverage(@criterion)
+      end
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/configuration/coverage_criteria.rb

@@ -0,0 +1,156 @@
+# 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`, plus the standalone
+  # `:eval` toggle for instrumenting `eval`'d code.
+  module Configuration
+    SUPPORTED_COVERAGE_CRITERIA = %i[line branch method oneshot_line].freeze
+    DEFAULT_COVERAGE_CRITERION = :line
+    ONESHOT_LINE_COVERAGE_CRITERION = :oneshot_line
+
+    # Enable one or more coverage criteria. `:eval` is accepted as a
+    # shorthand for the standalone eval-coverage toggle.
+    def enable_coverage(*criteria)
+      criteria.each do |criterion|
+        if criterion == :eval
+          enable_eval_coverage
+        else
+          raise_if_criterion_unsupported(criterion)
+          # :oneshot_lines can not be combined with :lines
+          coverage_criteria.delete(DEFAULT_COVERAGE_CRITERION) if criterion == ONESHOT_LINE_COVERAGE_CRITERION
+          coverage_criteria << criterion
+        end
+      end
+    end
+
+    # Remove `criterion` from the set of enabled coverage criteria.
+    # 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)
+      raise_if_criterion_unsupported(criterion)
+      coverage_criteria.delete(criterion)
+      @primary_coverage = nil if @primary_coverage == criterion
+    end
+
+    def primary_coverage(criterion = nil)
+      if criterion.nil?
+        @primary_coverage ||= default_primary_coverage
+      else
+        raise_if_criterion_disabled(criterion)
+        @primary_coverage = criterion
+      end
+    end
+
+    def coverage_criteria
+      @coverage_criteria ||= Set[DEFAULT_COVERAGE_CRITERION]
+    end
+
+    def coverage_criterion_enabled?(criterion)
+      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`."
+    end
+
+    def branch_coverage?
+      branch_coverage_supported? && coverage_criterion_enabled?(:branch)
+    end
+
+    def branch_coverage_supported?
+      coverage_criterion_supported?(:branches)
+    end
+
+    def method_coverage?
+      method_coverage_supported? && coverage_criterion_enabled?(:method)
+    end
+
+    def method_coverage_supported?
+      coverage_criterion_supported?(:methods)
+    end
+
+    def coverage_for_eval_supported?
+      coverage_criterion_supported?(:eval)
+    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
+    def coverage_criterion_supported?(criterion)
+      require "coverage"
+      return Coverage.supported?(criterion) if Coverage.respond_to?(:supported?)
+
+      criterion != :eval && RUBY_ENGINE != "jruby"
+    end
+    # simplecov:enable
+
+    def coverage_for_eval_enabled?
+      @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`.")
+      enable_eval_coverage
+    end
+
+  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"
+      end
+    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`.
+    def default_primary_coverage
+      return DEFAULT_COVERAGE_CRITERION if coverage_criterion_enabled?(DEFAULT_COVERAGE_CRITERION)
+
+      coverage_criteria.first
+    end
+
+    def raise_if_criterion_disabled(criterion)
+      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)"
+    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}"
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/configuration/filters.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Inclusion / exclusion / grouping methods: `cover`, `skip`, `group`,
+  # plus the deprecated `track_files` / `add_filter` / `add_group`
+  # aliases. Mutates the same `filters`, `groups`, and `cover_filters`
+  # collections the main Configuration module exposes.
+  module Configuration
+    attr_writer :filters, :groups
+
+    #
+    # Restrict the universe of files in the coverage report to those matching
+    # one or more globs, regexps, or block predicates. Multiple calls union;
+    # 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.
+    #
+    # 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
+    #
+    def cover(*args, &block)
+      args.each { |arg| cover_filters << build_cover_filter(arg) }
+      cover_filters << SimpleCov::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.add_not_loaded_files` 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.
+    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)}")
+      @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.
+    def track_files_replacement_hint(glob)
+      if glob.nil?
+        "Replace with `SimpleCov.cover_filters.clear` — clearing the inclusion list."
+      else
+        "Replace with `SimpleCov.cover #{glob.inspect}` — `cover` includes unloaded files on disk " \
+          "(the historical `track_files` behavior) and also restricts the report to the matching set. " \
+          "If you want to keep additional files outside #{glob.inspect} in the report, pass every " \
+          "directory you care about, e.g. `cover #{glob.inspect}, \"app/**/*.rb\"`."
+      end
+    end
+
+    # Returns the glob used to include files that were not explicitly required.
+    def tracked_files
+      @tracked_files if defined?(@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.
+    #
+    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}.")
+      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
+    end
+
+    # Remove every filter from the chain, including the defaults installed
+    # by `SimpleCov.start`.
+    def clear_filters
+      @filters = []
+    end
+
+    # Returns the configured groups. Add groups using SimpleCov.group.
+    def groups
+      @groups ||= {}
+    end
+
+    # Define a display group for files. Same matcher grammar as `skip`,
+    # but instead of dropping the matching files it bins them under
+    # `group_name` for the formatter. Files matched by no group fall
+    # into the implicit "Ungrouped" bucket.
+    def group(group_name, filter_argument = nil, &)
+      groups[group_name] = parse_filter(filter_argument, &)
+    end
+
+    # DEPRECATED: alias for `group`. Same arguments, same behavior.
+    def add_group(group_name, filter_argument = nil, &block)
+      example = if block
+                  "`SimpleCov.group #{group_name.inspect} { ... }`"
+                else
+                  "`SimpleCov.group #{group_name.inspect}, #{filter_argument.inspect}`"
+                end
+      SimpleCov::Deprecation.warn(
+        "`SimpleCov.add_group` is deprecated. " \
+        "Replace with `SimpleCov.group` (same arguments, same behavior). Example: #{example}."
+      )
+      group(group_name, filter_argument, &block)
+    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.
+    def no_default_skips
+      clear_filters
+    end
+
+  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)
+    end
+
+    # Build a filter for a `cover` argument. Strings are treated as
+    # globs (not substrings — that's `skip`/`add_filter`'s semantics).
+    def build_cover_filter(arg)
+      case arg
+      when String            then SimpleCov::GlobFilter.new(arg)
+      when Regexp            then SimpleCov::RegexFilter.new(arg)
+      when Proc              then SimpleCov::BlockFilter.new(arg)
+      when SimpleCov::Filter then arg
+      when Array             then SimpleCov::ArrayFilter.new(arg.map { |a| build_cover_filter(a) })
+      else raise SimpleCov::ConfigurationError, "Unsupported `cover` argument #{arg.inspect}; " \
+                                                "expected a String glob, Regexp, Proc, " \
+                                                "SimpleCov::Filter, or Array of those."
+      end
+    end
+
+    # Walk a list of cover filters and return the string globs they hold,
+    # descending 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)
+        else []
+        end
+      end
+    end
+  end
+end

data/simplecov-1.0.0/lib/simplecov/configuration/formatting.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+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. 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.
+    #
+    def formatter(formatter = :__no_arg__)
+      return @formatter if formatter == :__no_arg__
+
+      @formatter = formatter || nil # normalize `false` to `nil`
+    end
+
+    # Sets the configured formatters. Pass `[]` to opt out of
+    # formatting entirely; see `formatter` for the rationale.
+    def formatters(formatters = :__no_arg__)
+      return Array(formatter) if formatters == :__no_arg__
+
+      self.formatters = formatters
+      formatters
+    end
+
+    # Sets the configured formatters. Equivalent to `formatters [...]`.
+    def formatters=(formatters)
+      @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.
+    #
+    def color(value = :__no_arg__)
+      return defined?(@color) ? @color : :auto if value == :__no_arg__
+
+      @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__
+
+      @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 viewer's `coverage_data.js` 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__
+
+      @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
+    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.")
+      current_nocov_token(nocov_token)
+    end
+    alias 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?
+
+      @nocov_token = value || "nocov"
+    end
+  end
+end