simplecov 1.1.1 → 1.3.0

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,37 @@
+# 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. 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

data/lib/simplecov/configuration.rb

@@ -3,82 +3,81 @@
 require "fileutils"
 
 module SimpleCov
-  #
-  # Bundles the configuration options used for SimpleCov. All methods
-  # defined here are usable from SimpleCov directly. Please check out
-  # SimpleCov documentation for further info.
-  #
   module Configuration
-    #
-    # The root for the project. This defaults to the
-    # current working directory.
-    #
-    # Configure with SimpleCov.root('/my/project/path')
-    #
     def root(root = nil)
-      return @root if defined?(@root) && root.nil?
+      return @root if instance_variable_defined?(:@root) && root.nil?
 
+      self.root = root
+      @root
+    end
+
+    # nil means the working directory, the default the reader would have derived.
+    def root=(root)
       @coverage_path = nil unless @coverage_path_explicit # invalidate cache
       @root = File.expand_path(root || Dir.getwd)
     end
 
-    #
-    # The name of the output and cache directory. Defaults to 'coverage'
-    #
-    # Configure with SimpleCov.coverage_dir('cov')
-    #
     def coverage_dir(dir = nil)
-      return @coverage_dir if defined?(@coverage_dir) && dir.nil?
+      return @coverage_dir if instance_variable_defined?(:@coverage_dir) && dir.nil?
+
+      self.coverage_dir = dir
+      @coverage_dir
+    end
 
+    # nil means the default 'coverage', recorded as a derivation rather than a
+    # choice.
+    def coverage_dir=(dir)
       @coverage_path = nil unless @coverage_path_explicit # invalidate cache
       @coverage_dir_explicit = true unless dir.nil?
       @coverage_dir = dir || "coverage"
     end
 
     #
-    # Returns the full path to the output directory. By default
-    # constructed from `SimpleCov.root` + `SimpleCov.coverage_dir`, but
-    # callers can override with an arbitrary absolute path — handy for
-    # out-of-tree build directories. See #716.
+    # Defaults to `SimpleCov.root` + `SimpleCov.coverage_dir`, but callers can
+    # override with an arbitrary absolute path, handy for out-of-tree build
+    # directories (#716).
     #
-    # Reading is pure: the directory is only created when a path is
-    # explicitly assigned (the user has signaled they intend to write
-    # there). The codepaths that actually write into the directory
-    # (formatters, `LastRun`, `ResultsetStore`) ensure existence
-    # themselves, so read-only CLI subcommands that interpolate the
-    # path into status text don't materialize a stray `coverage/`
-    # directory.
+    # Reading is pure: the directory is only created when a path is explicitly
+    # assigned. The codepaths that write into it ensure existence themselves,
+    # so read-only CLI subcommands that interpolate the path into status text
+    # don't materialize a stray `coverage/` directory.
     #
     def coverage_path(path = nil)
-      if path
-        expanded = File.expand_path(path)
-        @coverage_path = expanded
-        @coverage_path_explicit = true
-        FileUtils.mkdir_p expanded
-      end
+      self.coverage_path = path if path
 
       @coverage_path ||= File.expand_path(coverage_dir, root)
     end
 
+    # Assigning is the signal the caller intends to write there, so the
+    # directory is created.
+    def coverage_path=(path)
+      expanded = File.expand_path(path)
+      @coverage_path = expanded
+      @coverage_path_explicit = true
+      FileUtils.mkdir_p expanded
+    end
+
     #
-    # The name of the command (a.k.a. Test Suite) currently running.
-    # Used for result merging and caching. Auto-detected; set explicitly
-    # with SimpleCov.command_name("test:units").
+    # The name of the command (a.k.a. Test Suite) currently running. Used for
+    # result merging and caching. Auto-detected.
     #
     def command_name(name = nil)
-      @command_name = name unless name.nil?
-      @command_name ||= SimpleCov::CommandGuesser.guess
+      self.command_name = name unless name.nil?
+      @command_name ||= CommandGuesser.guess
+    end
+
+    def command_name=(name)
+      @command_name = name
     end
 
-    # Returns the hash of available profiles
     def profiles
-      @profiles ||= SimpleCov::Profiles.new
+      @profiles ||= Profiles.new
     end
 
     #
-    # Allows you to configure simplecov in a block instead of
-    # prepending SimpleCov to each config method. Parameterized blocks retain
-    # their caller context and receive this configuration target explicitly.
+    # Configure simplecov in a block instead of prepending SimpleCov to each
+    # config method. Parameterized blocks retain their caller context and
+    # receive this configuration target explicitly.
     #
     def configure(&block)
       raise ArgumentError, "configuration block required" unless block
@@ -91,61 +90,49 @@ module SimpleCov
       self
     end
 
-    #
-    # Gets or sets the behavior to process coverage results.
-    # By default, it stores/merges the current result and formats only
-    # from the final reporting process.
-    #
     def at_exit(&block)
       @at_exit = block if block
       configured = @at_exit
       return configured if configured
-      return proc {} unless active_session?
+      return -> {} unless active_session?
 
-      @at_exit = proc do
+      @at_exit = lambda do
         result = SimpleCov.result
         result.format! if result && SimpleCov.merge_finalization_owner?
       end
     end
 
-    # Whether SimpleCov has anything to do at exit: the Coverage module
-    # is actively tracking, or a `@result` has already been assembled
-    # (e.g. by `SimpleCov.collate`, which never starts Coverage).
+    # The Coverage module is actively tracking, or a `@result` has already been
+    # assembled (`SimpleCov.collate` never starts Coverage).
     def active_session?
-      SimpleCov.result? || (defined?(Coverage) && Coverage.running?)
+      !!SimpleCov.result? || coverage_running?
+    end
+
+    # A configuration loaded on its own may have no Coverage to ask, which is
+    # not something a suite that measures coverage can be.
+    def coverage_running?
+      defined?(Coverage) ? Coverage.running? : false
     end
 
-    #
-    # Gets or sets the behavior to start a new forked Process.
-    # Defaults to adding " (subprocess: #{serial})" to command_name and
-    # starting SimpleCov in quiet mode.
-    #
     def at_fork(&block)
       @at_fork = block if block
       @at_fork ||= lambda { |_pid|
-        # Needs a name that's unique per worker within a run yet identical
-        # across runs. Build it from SimpleCov's stable fork serial rather
-        # than the OS pid: with the pid, every run produced uniquely-named
-        # results that never overwrote the previous run's, so they piled up
-        # in .resultset.json until merge_timeout and the merged report's
-        # file set drifted from run to run. See issue #1171.
+        # Needs a name that's unique per worker within a run yet identical across
+        # runs. Built from SimpleCov's stable fork serial rather than the OS pid:
+        # with the pid, every run produced uniquely-named results that never
+        # overwrote the previous run's, so they piled up in .resultset.json
+        # until merge_timeout and the merged report's file set drifted from run
+        # to run (#1171).
         SimpleCov.command_name "#{SimpleCov.command_name} (subprocess: #{SimpleCov.subprocess_serial})"
-        # be quiet, the parent process will use the regular formatter
         SimpleCov.print_errors false
-        SimpleCov.formatter SimpleCov::Formatter::SimpleFormatter
+        SimpleCov.formatter Formatter::SimpleFormatter
         SimpleCov.minimum_coverage 0
         SimpleCov.start
       }
     end
 
-    #
-    # Returns the project name — defaults to the last dirname in
-    # SimpleCov.root, capitalized with underscores → spaces.
-    #
+    # Only a String renames, and a name already chosen survives anything else.
     def project_name(new_name = nil)
-      current = defined?(@project_name) ? @project_name : nil
-      return current if current && new_name.nil?
-
       @project_name = new_name if new_name.is_a?(String)
       @project_name ||= File.basename(root).capitalize.tr("_", " ")
     end
@@ -160,4 +147,11 @@ require_relative "configuration/groups"
 require_relative "configuration/formatting"
 require_relative "configuration/ignored_entries"
 require_relative "configuration/merging"
+require_relative "configuration/test_tracking"
 require_relative "configuration/thresholds"
+require_relative "configuration/baseline"
+require_relative "configuration/deprecations"
+require_relative "configuration/history"
+require_relative "configuration/missed_caps"
+require_relative "configuration/production"
+require_relative "configuration/view_coverage"

data/lib/simplecov/configuration_error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class ConfigurationError < StandardError; end
+end

data/lib/simplecov/context_map/union.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class ContextMap
+    # Accumulates the context maps of every result a merge absorbs, under the
+    # all-or-nothing rule the resultset format needs: the merged result carries
+    # the union of the maps when every merged result recorded one, and no map at
+    # all otherwise. Keeping a partial union would present one worker's map as
+    # the whole run's, silently omitting the tests of the results that didn't
+    # record.
+    class Union
+      attr_reader :carrying, :entries
+
+      def initialize
+        @map = ContextMap.new
+        @complete = true
+        @carrying = 0
+        @entries = 0
+      end
+
+      def collector
+        ->(surviving) { absorb_resultset(surviving) }
+      end
+
+      def absorb_resultset(resultset)
+        resultset.each_value { |data| absorb_entry(data) }
+      end
+
+      def absorb_entry(data)
+        @entries += 1
+        map = ContextMap.from_hash(data["contexts"])
+        return @complete = false unless map
+
+        @carrying += 1
+        @map.absorb(map)
+      end
+
+      # The parallel merge builds one union per worker over its slice and ships it
+      # back, so the parent combines unions rather than re-reading entries.
+      def absorb_union(other)
+        @entries += other.entries
+        @carrying += other.carrying
+        @complete &&= other.complete?
+        @map.absorb(other.partial_map)
+        self
+      end
+
+      def complete?
+        @complete
+      end
+
+      # The union when every absorbed result carried a map, nil otherwise. Dropping
+      # warns when the merge mixed results with and without maps, since that
+      # usually means `track_tests` is on in some workers and not others; a merge
+      # where nothing recorded stays quiet.
+      def map
+        return @map if @complete
+
+        warn_about_partial_maps
+      end
+
+      protected
+
+      # Protected: only another union folding this one in may read it.
+      def partial_map
+        @map
+      end
+
+      private
+
+      def warn_about_partial_maps
+        return unless @carrying.positive? && SimpleCov.print_errors
+
+        warn "[SimpleCov]: Dropped the per-test map from the merged result: " \
+             "only #{@carrying} of #{@entries} merged results carry one. The map is " \
+             "kept only when every merged result records it, so enable `track_tests` " \
+             "in every suite that should contribute."
+      end
+    end
+  end
+end